Android笔试面试题AI答之Kotlin（20）

98. 简述什么是Elvis操作符 ？

Elvis操作符（?:）是Kotlin（以及一些其他编程语言）中用于处理可空表达式的一种简洁方式。它允许在表达式的值为null时提供一个默认值，从而简化了空值的处理。

基本概念

• 名称由来：Elvis操作符的名称来源于猫王埃尔维斯·普雷斯利（Elvis Presley）的昵称“Elvis”，这个名称可能是因为它简洁且有效的特性而得来的。
• 作用：在Kotlin中，Elvis操作符用于在左侧表达式为空（null）时，返回右侧表达式的值。这避免了在代码中频繁使用if-else语句来检查null值，从而提高了代码的可读性和简洁性。

语法

Elvis操作符的基本语法如下：

val result = nullableExpression ?: defaultValue
1

其中，nullableExpression是一个可能为null的表达式，defaultValue是在nullableExpression为null时返回的默认值。

使用场景

• 当有一个可空的引用时，可以使用Elvis操作符来指定一个非空的值作为默认值。
• 在进行链式调用时，如果某个中间环节可能为null，可以使用Elvis操作符来避免NullPointerException。

示例

以下是一个使用Elvis操作符的示例：

val name: String? = null
val displayName = name ?: "John Doe"

// 在这个例子中，如果name为null，那么displayName的值将会是"John Doe"
1
2
3
4

注意事项

• 当且仅当左侧表达式为null时，才会对右侧表达式进行求值。
• Elvis操作符是Kotlin语言的一个特性，因此在其他不支持该操作符的编程语言中无法使用。

综上所述，Elvis操作符是Kotlin中用于处理可空表达式的一种非常便捷的方式，它能够提高代码的可读性和开发效率。

99. Kotlin构造函数类型？ 如何在类中定义？

在Kotlin中，构造函数（Constructor）是类的一个特殊方法，它用于初始化新创建的对象。与Java不同，Kotlin中的构造函数不是通过名称来定义的，而是与类名相同，并且没有返回类型（即使是void）。Kotlin支持主构造函数和次构造函数（也称为辅助构造函数或二级构造函数）。

主构造函数

主构造函数是类头的一部分，它紧随类名之后，由构造函数参数和可能的属性初始化器组成。

class Person(name: String, age: Int) {
    // 构造函数参数直接用于初始化属性
    var name = name
    var age = age

    // 构造函数体可以放在init块中
    init {
        println("Person is being initialized. Name: $name, Age: $age")
    }
}

// 创建Person对象
val person = Person("Alice", 30)
1
2
3
4
5
6
7
8
9
10
11
12
13

在上面的例子中，Person类有一个主构造函数，它接收两个参数：name和age。这些参数直接用于初始化同名的属性。init块是可选的，它允许你执行构造函数体中的代码。

次构造函数

次构造函数是类内定义的额外构造函数，它们通过constructor关键字（但在Kotlin中通常省略此关键字）来声明，并且可以调用同一个类的其他构造函数（包括主构造函数）。

class Person(name: String) {
    // 主构造函数
    var name = name

    // 次构造函数
    constructor(name: String, age: Int) : this(name) {
        // 这里可以添加额外的初始化代码
        println("Person with age is being initialized. Name: $name, Age: $age")
        // 注意：这里没有直接的age属性初始化，但可以添加一个
        // 例如，通过添加一个var age属性并在这里初始化它
    }
}

// 注意：上面的代码示例实际上是不完整的，因为age属性没有在类中声明。
// 正确的做法是在主构造函数中声明所有必要的属性，并在次构造函数中调用主构造函数来初始化它们。

// 改进后的版本
class Person(name: String) {
    var name = name
    var age: Int? = null // 或者使用非空类型并提供默认值或确保在构造函数中赋值

    constructor(name: String, age: Int) : this(name) {
        this.age = age
        println("Person with age is being initialized. Name: $name, Age: $age")
    }
}

// 创建Person对象
val personWithAge = Person("Bob", 25)
val personWithoutAge = Person("Charlie")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在Kotlin中，如果类有主构造函数，那么它的参数可以直接在类头中定义，并且这些参数可以直接用于初始化属性或作为init块中的局部变量。次构造函数通过this关键字调用主构造函数或其他次构造函数来确保所有必要的初始化都已完成。

需要注意的是，Kotlin的构造函数并不直接返回类型（与Java中的void不同），因为Kotlin的构造函数只是类定义的一部分，用于初始化新对象。返回新创建的对象是Kotlin（以及大多数面向对象语言）的构造函数调用的隐式行为。

100. 简述Kotlin类的init代码块？

在Kotlin中，init 代码块是一种特殊的代码块，它用于执行类的初始化代码。这些代码块在类的构造函数执行过程中被调用，但它们是独立于构造函数之外的。init 代码块对于执行那些需要在对象创建时立即执行但又不想在每个构造函数中都重复的代码非常有用。

特点

1. 自动执行：每当创建类的新实例时，init 代码块中的代码都会自动执行。
2. 多个init块：一个类中可以包含多个init 代码块，它们将按照它们在类中出现的顺序执行。
3. 与构造函数的关系：init 代码块在构造函数体之前执行。如果类有主构造函数和次构造函数，并且次构造函数通过this关键字调用了主构造函数，那么init 代码块将在任何构造函数调用之前执行。
4. 属性初始化：init 代码块通常用于初始化那些依赖于构造函数参数的属性，或者执行一些必须在对象完全可用之前完成的设置。

示例

class Person(val firstName: String, val lastName: String) {
    var fullName: String

    init {
        // 在构造函数体之前执行
        println("Init block is called")
        fullName = "$firstName $lastName"
    }

    // 构造函数体
    constructor(name: String) : this(name, "") {
        // 这里是次构造函数的额外初始化代码
        println("Secondary constructor is called")
    }

    // 主构造函数没有直接的代码体，但参数可以直接用于初始化属性或init块
}

fun main() {
    val person1 = Person("John", "Doe")
    println(person1.fullName) // 输出: Init block is called, John Doe

    val person2 = Person("Jane")
    println(person2.fullName) // 输出: Init block is called, Secondary constructor is called, Jane 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在这个例子中，Person 类有一个主构造函数和两个属性（firstName、lastName 和 fullName）。init 代码块用于初始化 fullName 属性，它依赖于主构造函数的参数。此外，Person 类还有一个次构造函数，它调用了主构造函数，并添加了一些额外的初始化代码。注意，无论调用哪个构造函数，init 代码块都会先执行。

注意事项

• 如果你的类没有显式定义任何构造函数（包括主构造函数），Kotlin 会为你生成一个无参的主构造函数。在这种情况下，init 代码块仍然会在这个隐式生成的无参构造函数之前执行。
• 如果你的类既有主构造函数又有次构造函数，并且次构造函数通过this关键字调用了主构造函数，那么init 代码块会在任何构造函数调用之前执行一次。
• init 代码块是Kotlin中初始化逻辑的一个重要部分，它使得类的初始化过程更加灵活和强大。

101. 函数中Unit-return的目的是什么？为什么 VALUE 在那里？这个价值是多少？

fun printHello(name : String?) : Unit {
	if (name != null)
		print("Hello, $name!")
	else
		print("Hi there!")
// We don't need to write 'return Unit.VALUE' or 'return', although we could
}
1
2
3
4
5
6
7

在Kotlin中，Unit 类型是一个特殊的类型，用于表示“没有返回值”的情况。它相当于Java中的void。当你在Kotlin中定义一个函数而不希望它返回任何具体的值时，你可以将该函数的返回类型指定为Unit。然而，在大多数情况下，如果你没有显式地指定返回类型，并且函数体中没有使用return语句返回任何值（除了在某些特定的上下文，如Lambda表达式中），Kotlin编译器会自动将这样的函数的返回类型推断为Unit。

在你给出的例子中，printHello 函数是一个没有显式返回值的函数，它接收一个可空的String类型参数name，并根据name是否为null来打印不同的问候语。该函数的返回类型被明确指定为Unit，但在实际使用中，由于函数体中没有使用return语句返回任何值，即使你不显式地指定返回类型为Unit，Kotlin编译器也会自动推断出这一点。

关于VALUE：在Kotlin的Unit类型中，存在一个名为VALUE的常量，它的值是Unit类型的唯一实例。这个实例本身并不包含任何有用的数据或信息，它仅仅是一个占位符，用于满足那些需要显式返回Unit类型值的场景。然而，在你的printHello函数中，由于你并没有使用return语句显式地返回任何值（包括Unit.VALUE），所以你不需要（也不应该）在函数体中包含return Unit.VALUE或仅仅return（这在没有明确返回类型的函数中是合法的，但在这里显得多余，因为函数已经被指定为返回Unit类型）。

总结来说，Unit-return的目的是为了表示函数不返回任何具体的值。在你的例子中，VALUE是Unit类型的一个实例，但在这种情况下，你不需要在函数体中使用它，因为函数已经通过其定义和行为隐式地表明了这一点。

102. Koltin 如何使用“apply”重构这段代码？

class Message(message: String, signature: String) {
	val body = MessageBody()

	init {
		body.text = message + "\n" + signature
	}
}
1
2
3
4
5
6
7

在Kotlin中，apply 函数是一个非常有用的作用域函数，它接受一个扩展函数作为参数，并在提供的对象上执行这个函数，最后返回该对象本身。这允许你进行链式调用，使代码更加简洁和易于阅读。

针对你给出的Message类，虽然init块已经相对简洁，但我们仍然可以使用apply来稍微重构一下MessageBody的初始化过程，特别是如果MessageBody的初始化涉及多个属性的设置，或者你想在设置body.text之后立即执行一些其他操作。不过，在这个简单的例子中，apply的使用可能看起来有些过度，但我会展示如何应用它。

首先，我们假设MessageBody是一个简单的类，它至少有一个text属性，并可能包含其他属性和方法。

class MessageBody {
    var text = ""
    // 可能还有其他属性和方法
}

class Message(message: String, signature: String) {
    val body: MessageBody = MessageBody().apply {
        text = message + "\n" + signature
        // 如果还有其他需要立即设置的属性或方法，可以在这里继续
    }

    // 类的其他部分...
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个重构后的版本中，我们在Message类的构造函数中直接初始化了body属性。通过调用MessageBody()的实例上的apply函数，我们能够立即设置text属性，并且由于apply返回了MessageBody的实例，我们可以直接将结果赋值给body。

这种方式使得初始化代码更加紧凑和清晰，特别是当MessageBody的初始化包含多个步骤时。然而，在这个特定的例子中，由于只设置了一个属性，所以重构前后的代码在简洁性方面并没有太大差异。不过，使用apply仍然是一个好习惯，特别是当你想要对对象进行一系列初始化操作时。

另外，值得注意的是，如果MessageBody是一个数据类（Data Class），并且你只是想通过构造函数参数来设置其属性，那么你可能不需要在Message类中显式地使用apply，而是可以直接在MessageBody的构造函数中设置这些值。但是，这取决于MessageBody的具体设计和使用场景。

103. 假设您将代码从 Java 迁移到 Kotlin。你会如何在 Kotlin 中重写这段代码？

public class Foo {
	private static final Logger LOG = LoggerFactory.getLogger(Foo.class);
}
1
2
3

在 Kotlin 中，静态成员（如 Java 中的静态字段）通常通过伴生对象（companion object）来实现，但对于日志记录这样的场景，由于 Logger 通常是基于类的，我们通常会使用 Kotlin 的扩展函数功能来简化日志的获取，而不是在类内部直接声明一个静态的 Logger 实例。

首先，确保你已经添加了 SLF4J 或 Logback 等日志框架的 Kotlin 支持库（如果还没有的话）。然后，你可以通过定义一个扩展函数来简化日志的获取。

这里是一个如何在 Kotlin 中重写你的 Java 代码的示例，使用扩展函数来获取 Logger：

import org.slf4j.LoggerFactory
import org.slf4j.Logger

// 定义一个扩展函数来获取Logger
fun <T> T.logger(): Logger = LoggerFactory.getLogger(T::class.java)

class Foo {
    // 使用扩展函数获取Logger
    private val log = Foo::class.java.logger()

    // 或者更简洁地，直接在需要的地方调用扩展函数
    // 例如：
    // fun someMethod() {
    //     Foo::class.java.logger().info("This is a log message")
    // }

    // 但通常我们会将logger作为类的私有属性来存储
}

// 注意：上面的扩展函数定义方式并不是最优雅的，因为它需要传入Class对象。
// 更常见的做法是直接对类使用扩展函数，如下所示：

// 定义一个针对任意类的扩展函数来获取Logger
fun Any.logger(): Logger = LoggerFactory.getLogger(this::class.java)

class Foo {
    // 现在可以直接使用扩展函数来获取Logger
    private val log = logger()

    fun doSomething() {
        log.info("Doing something...")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

然而，请注意，上面的 Any.logger() 扩展函数虽然方便，但在某些情况下（如泛型类或接口）可能无法正确推断出具体的类类型，因为 this::class.java 在泛型上下文中可能返回 Any::class.java 而不是具体的子类类型。为了解决这个问题，你可能需要显式地传递类类型给扩展函数，或者在你的项目中采用其他日志初始化策略。

对于大多数情况，上面的 Any.logger() 扩展函数已经足够使用，并且能够很好地与 Kotlin 的类型系统一起工作。但是，如果你遇到了类型推断问题，你可能需要回到使用类名直接调用 LoggerFactory.getLogger() 的方式，或者寻找其他日志库提供的 Kotlin 友好解决方案。

104.假设我想重写 Int getter，以便在数据类的值为负时返回 0。这种方法有什么不好？

data class Test(private val _value: Int) {
	val value: Int
	get() = if (_value < 0) 0 else _value
}
1
2
3
4

在 Kotlin 中，重写数据类（data class）的 getter 以改变其原始值（如在你的例子中，将负值更改为 0）确实可以实现你想要的行为，但这种做法有一些潜在的问题和考虑点：

1. 违反了数据类的设计原则：

   • Kotlin 的数据类（data class）主要是为了存储数据而设计的，它们应该直接反映其属性的状态，不添加任何业务逻辑或条件逻辑。当你重写 getter 来改变其值时，实际上是在隐藏数据的真实状态，这可能会导致代码的不可预测性和难以调试。

2. 影响相等性比较：

   • 数据类默认生成了 equals(), hashCode(), 和 toString() 方法的实现，这些方法都是基于类的属性。如果你修改了 getter 的返回值，那么这些方法的行为也会受到影响。例如，两个 Test 实例在 Java 或 Kotlin 的 equals() 比较中可能会被视为不相等，即使它们的 _value 字段实际上是相等的（只是一个是负数，被 getter 修改为 0）。

3. 破坏不可变性：

   • 尽管在你的例子中 value 是通过 val 声明的，看起来像是不可变的，但实际上，通过 getter 的逻辑，它表现出了一种“伪可变性”。这种伪可变性可能会让其他开发者误解类的行为，尤其是在多线程环境下，这种表现可能会更加复杂和难以预测。

4. 混淆 API 使用者：

   • 当其他开发者使用你的 Test 类时，他们可能会期望 value 属性直接反映 _value 字段的值。如果你的 getter 改变了这个行为，那么这可能会导致混淆和错误。

5. 难以维护和扩展：

   • 如果将来你需要改变这个逻辑（比如，改为将负值转换为某个特定的错误码，而不是简单地返回 0），你需要在所有使用到 value 的地方重新测试，以确保新的逻辑不会破坏现有的功能。

解决方案

如果你需要这样的逻辑，但又不想违反数据类的设计原则，你可以考虑以下几种替代方案：

• 使用计算属性：不将数据类用于此类逻辑，而是将数据类和计算属性结合使用。计算属性可以包含你想要的任何逻辑，同时保持数据类的简单性。

• 封装逻辑：在数据类外部封装逻辑，比如通过扩展函数或单独的辅助函数来处理负值的情况。

• 使用不同的类：如果负值有特殊的意义，考虑使用不同的类来表示这些特殊情况，而不是试图在一个类中处理所有情况。

答案来自文心一言，仅供参考