问题[kotlin](coding)

我正在使用 Kotlin 编程，我想将skiko用于我的 Kotlin/Native 应用程序。我的 Gradle 构建文件与 skiko 的 README 中的完全相同（见下文），但出于某种原因，我收到错误：“未解析的引用：实现”这可能意味着什么？我以为这是 Kotlin DSL 的一部分？那么它怎么可能不知道这个函数呢？我在其他项目中从未遇到过这个问题。

提前致谢

我使用 Gradle 8.10，并且只在 IntelliJ 中同步 Gradle 更改。从设置“使用 Gradle 构建和运行”来看，我认为 IntelliJ 没有使用 Gradle Wrapper。

我尝试从其他项目复制构建文件，并自己进行等级初始化

来自build.gradle.ktsrepo 的是

repositories {
    mavenCentral()
    maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
}

val osName = System.getProperty("os.name")
val targetOs = when {
    osName == "Mac OS X" -> "macos"
    osName.startsWith("Win") -> "windows"
    osName.startsWith("Linux") -> "linux"
    else -> error("Unsupported OS: $osName")
}

val osArch = System.getProperty("os.arch")
val targetArch = when (osArch) {
    "x86_64", "amd64" -> "x64"
    "aarch64" -> "arm64"
    else -> error("Unsupported arch: $osArch")
}

val version = "0.8.9" // or any more recent version
val target = "${targetOs}-${targetArch}"

dependencies {
    implementation("org.jetbrains.skiko:skiko-awt-runtime-$target:$version")
}

如何在 jetpack compose 中将阴影仅应用于框的一侧或两侧？我想将阴影应用于此列的底部：

                     Column(
                        modifier = Modifier
                            .weight(0.7f)
                            .fillMaxHeight()
                            .clip(
                                shape = RoundedCornerShape(
                                    topStart = 0.dp,
                                    topEnd = 0.dp,
                                    bottomStart = 16.dp,
                                    bottomEnd = 16.dp
                                )
                            )
                            .background(Color.White)

                    )

我想创建一个具有透明背景和圆角的盒子，例如红色（在 jetpack compose android kotlin 中）。我可以将两个盒子放在一起，下面一个是绿色，上面一个是红色圆角，但问题是，如果我想让顶部透明，我们会看到绿色，但我不想显示绿色，我想要透明的

我想要的正是这样的东西：

在学习 lambda 时，我遇到了这个问题 “...局部变量的生命周期受到声明该变量的函数的限制。但如果它被 lambda 捕获，则使用此变量的代码可以存储并在以后执行。” 文本没有提供此过程的代码示例。是否有代码示例可以实现所声称的功能？

我有一个 Room 数据库，其中 BusStops 和 Lines 之间存在多对多关系

@Entity(tableName = "BusStops")
data class BusStopEntity(
    @PrimaryKey val id: Int = 0,
    val name: String,
    val lat: Double,
    val lon: Double
)

@Entity(tableName = "Lines")
data class LineEntity(
    @PrimaryKey val id: Int = 0,
    val name: String
)

@Entity(primaryKeys = ["busStopId", "lineId"])
data class BusStopLineEntity(
    val busStopId: Int,
    val lineId: Int
)

我使用这个数据类来建立关系：

data class LineWithBusStops(
    @Embedded val line: LineEntity,
    @Relation(
        parentColumn = "id",
        entityColumn = "busStopId",
        associateBy = Junction(BusStopLineEntity::class)
    )
    val busStops: List<BusStopEntity>
)

@Relation但我收到了错误entityColumn = "busStopId"

在 com.local.model.BusStopEntity 中找不到子实体列busStopId。选项：id、name、lat、lon

如果我改为busStopId，id我会遇到更多错误。

有什么想法吗？

我已经定义了一个类并为其分配了一个值，但是当我尝试访问该值时，我得到了一个 @，后面跟着一串十六进制数字。我在 Kotlin 官方文档或网上找不到任何信息。有人能告诉我发生了什么以及如何获取我需要的值吗？

这是一项 Hyperskill 任务。

程序如下：

open class Character(val name: String)
class Jedi(name: String, val age: Int) : Character(name)
class Sith(name: String, val hasMask: Boolean) : Character(name)

fun characterBuilder(input: String): Character {
    val (name, type, other) = input.split("-")
    return when (type) {
        "jedi" -> Jedi(name, other.toInt())
        "sith" -> Sith(name, other.toBoolean())
        else -> throw IllegalArgumentException("Unknown character type: $type")
    }
}

fun main() {
    val list = "luke-jedi-25 leia-jedi-25 darkvader-sith-true darksidiuos-sith-false".split(" ")
    val characters = list.map { characterBuilder(it) }

    // code won't recognize value of variable
    //val (jedis, siths) = characters.partition { character -> character.type == "jedi" }
    for (character in characters) { println(character) }
    // println("jedis: ${jedis.size}, siths: ${siths.size}")

}

输出为：

Jedi@728938a9
Jedi@21b8d17c
Sith@6433a2  
Sith@5910e440

我目前正在学习 Kotlin，并使用https://play.kotlinlang.org/编译我的代码。
我尝试创建一个非常简单的程序，收集用户输入并提供输出。
但是，它无法运行。

fun main() {
   println("Give me a number of minutes!") 
   var input:String = readLine()!!
   var inputInMinutes = input.toInt()
   var resultInSeconds:Int = 0
   resultInSeconds = (inputInMinutes*60)
   println("That is " + resultInSeconds + " seconds!") 
}

我期望该程序能够编译并运行，但它显示以下错误消息：

Give me a number of minutes!
Exception in thread "main" java.lang.NullPointerException
 at FileKt.main (File.kt:7) 
 at FileKt.main (File.kt:-1) 
 at jdk.internal.reflect.NativeMethodAccessorImpl.invoke0 (:-2) 

我的代码是否有错误，或者在线 IDE 不允许用户输入？

这是一个枚举类：

enum class Foo(rawValue: Int) {
    FIRST(1),
    SECOND(2)
}

我可以用来companion object通过原始值检索类型：

enum class Foo(rawValue: Int) {
    FIRST(1),
    SECOND(2)


   companion object {
    
      fun getCaseBy(value: Int): Foo? {
        return entries.firstOrNull { it.rawValue == value }
      }
   }
}

然后像这样使用它： Foo.getCaseBy(1)

有没有办法使用泛型将其getCaseBy放入interface？那么就不需要为每个枚举添加这种方法了？

类似于：

interface EnumInterface<T> {
    
    companion object {
        
        fun getCaseBy(value: E): T? {
            return T.entries.firstOrNull { it.rawValue == value }
        }
    }
}

enum class Foo(rawValue: Int): EnumInterface(Foo::class) {
    FIRST(1),
    SECOND(2)
}

1. T仅限于Enum类，E是检索T的 rawValue 类型。
2. 只有Enum输入才能确认此接口EnumInterface

这可能吗？

所以我在 Kotlin 中尝试了泛型。假设我有一个典型Box类型：

class Box<T>

*现在，我明白，当我不关心任何包含该类型的方法或属性时，我可以在函数中使用投影T。

因此，例如，如果有一个takeBox1带有盒子并且根本不使用 T 的，我可以将其声明为：

fun takeBox1(box: Box<*>) {}

然后如果我有一个特定的T盒子我可以提供因为takeBox1并不关心T它是什么：

fun <T> giveBox1(box: Box<T>) {
    takeBox1(box)
}

然而，当我有一个双层包装的盒子时，情况就变得很奇怪了，即takeBox2接受的Box<Box<*>>，它不接受特定的Box<Box<T>>：

fun takeBox2(box: Box<Box<*>>) {}
fun <T> giveBox2(box: Box<Box<T>>) {
    takeBox2(box) // compiler error!
}

这很奇怪，如果它可以接受任何东西的盒子中的盒子，为什么它不能接受某物的盒子中的盒子？请注意，我在实现中根本没有使用 T - 也许我只是在做某事box.size。

经过更多测试后，如果我将外部框声明为out，它确实可以工作，但前提是外部框Box是OutBox；所以：

class OutBox<out T>

fun takeOutBox(box: OutBox<Box<*>>) {}
fun <T> giveOutBox2(box: OutBox<Box<T>>) {
    takeOutBox(box) // works
}

fun takeBoxOut(box: Box<OutBox<*>>) {}
fun <T> giveBoxOut2(box: Box<OutBox<T>>) {
    takeBoxOut(box) // does not compile
}

fun takeOutBoxOut(box: OutBox<OutBox<*>>) {}
fun <T> giveOutBoxOut2(box: OutBox<OutBox<T>>) {
    takeOutBoxOut(box) // works
}

如果我这样做了in，它在任何情况下都根本不起作用。

我读过Kotlin 泛型的文档，特别是关于in、out和星投影 ( *) 的文档，我认为我已经很好地掌握了它，但我似乎无法证明/解释这种特殊行为。我也读过关于 行为的其他答案，*但我不明白为什么双重包装的Box行为与单数 的行为不同Box。

我有两条记录对应两个不同的表（recordA、tableA、recordB 和 tableB）。TableA 和 TableB 具有相同的列名和相同的类型。我如何使用 Jooq 选择它们并将结果映射到不同的记录？

我尝试过这种方法：

fun findEntitiesByGroupId(groupId: UUID): ResultData {
    val entityAQuery = DSL.using(configuration)
        .selectFrom(ENTITY_A)
        .where(ENTITY_A.GROUP_ID.eq(groupId))
    val entityBQuery = DSL.using(configuration)
        .selectFrom(ENTITY_B)
        .where(ENTITY_B.GROUP_ID.eq(groupId))

    val entityA = mutableListOf<EventHistory>()
    val entityB = mutableListOf<EventHistory>()

    entityAQuery.unionAll(entityBQuery).forEach {
        when (it) {
            is EntityARecord -> entityA.add(mapEntityA(it))
            is EntityBRecord -> entityB.add(mapEntityB(it))
            else -> throw AssertionError("Invalid entity type")
        }
    }
    return ResultData(entityA, entityB)
}

我在unionAll方法中收到编译错误：

Type mismatch.
Required:
Select<out EntityARecord!>!
Found:
SelectConditionStep<EntityBRecord!>

我没有找到有关这种联合场景的任何 Jooq 文档，只是针对我们具有相同记录类型的情况。