Android开发知识学习——Kotlin进阶-CSDN博客

次级构造

申明前缀有construct修饰

class Person { 
    constructor(parent: Person){
   }
}

如果有一个主构造函数每个次构造函数需要委托给主构造函数可以直接委托或者通过别的构造函数

class constructor Person(val name:String) {
   constructor(name: String,parent: Person):this(name){
         }  
}

主构造器

主构造函数是类头的一部分跟在类名后面可带参数没有任何注解和可见性修饰符。如

class User (username : String?,password : String?) {
}

主构造函数中没有任何代码初始化代码放在关键字init的代码块中也可以在类体内声明的属性初始化器中使用

class User (username : String?,password : String?) {
      init {
              //执行你的操作
          }
}

class User (username : String?) {}
       var username=username.getname()
}

init 代码块

主构造不能包含任何的代码初始化代码可以放到 init 代码块中

class CodeView constructor(context: Context) :
TextView(context) {
init {
//...
}
}

在初始化的时候初始化块会按照它们在 文件中出现的顺序 执行
Kotlin 中的初始化块会按照它们在文件中出现的顺序执行。可以在其中执行一些特定的初始化操作。

例如以下是一个包含两个初始化块的 Kotlin 类示例

class MyClass {
    var myProperty1: String? = null

    init {
        println("Initializing myProperty1")
        myProperty1 = "Hello"
    }

    init {
        println("Initializing myProperty2")
        // 在这里可以进行其他初始化操作
    }
}

在上面的示例中MyClass 类包含两个初始化块。第一个初始化块初始化了 myProperty1 属性并将其设置为 “Hello”。第二个初始化块只是打印一条消息并没有对任何属性进行初始化。由于初始化块按照它们在文件中出现的顺序执行因此第一个初始化块会先执行然后是第二个初始化块。

当创建 MyClass 的实例时输出将是以下内容

Initializing myProperty1
Initializing myProperty2

这表明第一个初始化块先执行然后是第二个初始化块。

构造属性

在 Kotlin 中构造属性是一种特殊的属性它在类实例化时通过构造器进行初始化。构造属性可以通过在主构造器参数前面加上 var/val 关键字来定义使其同时成为成员变量。

下面是一个使用构造属性的示例

class Person(var name: String, var age: Int) {
    init {
        println("Person instance is created with name: $name and age: $age")
    }
}

fun main() {
    val person = Person("John Doe", 30)
    println(person.name) // 输出: John Doe
    println(person.age) // 输出: 30
}

在上面的示例中Person 类有两个构造属性 name 和 age它们在类的构造函数中声明并使用 var 关键字进行定义使其同时成为成员变量。在 init 块中我们可以访问这些属性并执行初始化操作。在 main 函数中我们创建了一个 Person 实例并访问了其属性。

data class

数据类中自动生成

• toString()

• hashCode()

• equals()

• copy() (浅拷⻉)
  

• componentN()

使用数据类的好处包括简化代码、减少错误

相等性

• == 结构相等 (调用 equals() 比较 )
  

• === 引用(地址值)相等
  

解构

可以把一个对象「解构」成很多变量

val (username,password) = User

对应的Java代码

val username = User.component1()
val password = User.component2()

Elvis 操作符

可以通过 ?: 的操作来简化 if null 的操作

// lesson.date 为空时使用默认值
val date = lesson.date?: "日日期待定"

// lesson.state 为空时提前返回函数
val state = lesson.state?: return

// lesson.content 为空时抛出异常
val content = lesson.content ?: throw IllegalArgumentException("content expected")

when 操作符

when 表达式可以接受返回值多个分支相同的处理方式可以放在一起用逗号分隔

val colorRes = when (lesson.state) {
Lesson.State.PLAYBACK, null -> R.color.playback
Lesson.State.LIVE -> R.color.live
Lesson.State.WAIT -> R.color.wait
}

when 表达式可以用来取代 if-ese-if 链。如果不提供参数所有的分支条件都是布尔表达式

val colorRes = when {
(lesson.state == Lesson.State.PLAYBACK) ->
R.color.playback
(lesson.state == null) -> R.color.playback
(lesson.state == Lesson.State.LIVE) -> R.color.live
(lesson.state == Lesson.State.WAIT) -> R.color.wait
else -> R.color.playback
}

operator

通过 operator 修饰「特定函数名」的函数例如 plus 、 get 可以达到重载运算符的效果

表达式	翻译为
a + b	a.plus(b)
a - b	a.minus(b)
a * b	a.times(b)
a / b	a.div(b)

fun main() {
    val num1 = ComplexNumber(2.0, 3.0)
    val num2 = ComplexNumber(4.0, 5.0)
    
    val result1 = num1 + num2 // 使用重载的加法运算符
    val result2 = num1 - num2 // 使用重载的减法运算符
    val result3 = num1 * num2 // 使用重载的乘法运算符
    val result4 = num1 / num2 // 使用重载的除法运算符
    
    println("Result 1: $result1")
    println("Result 2: $result2")
    println("Result 3: $result3")
    println("Result 4: $result4")

Lambda

Lambda 表达式被广泛使用它们使得编写简洁、优雅的代码更加容易
如果函数的最后一个参数是 lambda 那么 lambda 表达式可以放在圆括号之外

lessons.forEach(){ lesson : Lesson ->
// ...
}

如果你的函数传入参数只有一个 lambda 的话那么小括号可以省略的

lessons.forEach { lesson : Lesson ->
// ...
}

如果 lambda 表达式只有一个参数那么可以省略通过隐式的 it 来访问

lessons.forEach { // it
// ...
}

循环

通过标准函数 repeat()

repeat(100) {
   println(it)
}

通过区间

for (i in 0..99) {
}
// until 不包括右边界
for (i in 0 until 100) {
}

infix 函数

必须是成员函数或扩展函数
必须只能接受一个参数并且不能有默认值

// until() 函数的源码
public infix fun Int.until(to: Int): IntRange {
if (to <= Int.MIN_VALUE) return IntRange.EMPTY
return this .. (to - 1).toInt()
}

Kotlin 的 infix 函数是一种特殊的函数其名称即为所表达的操作可以简化代码。它们通常用于简化对两个对象之间的操作。
下面是一个简单的 infix 函数示例

infix fun Int.add(other: Int): Int {
    return this + other
}

这个函数将两个整数相加返回它们的和。通过使用 infix 关键字我们可以在不创建新的函数对象的情况下直接在两个整数之间调用这个函数。例如

val result = 2 + 3 // 这里使用了 infix 函数
println(result) // 输出5

在这个例子中我们直接在 2 和 3 之间调用了 add 函数而不是像普通函数那样需要使用函数名称和括号。
需要注意的是infix 函数只能有一个参数而且必须是函数的最后一个参数。此外infix 函数不能改变函数参数的值因为它们被视为只读的。

嵌套函数

Kotlin 中可以在函数中继续声明函数

fun main() {
    // 外部函数
    fun outerFunction() {
        // 内部函数
        fun innerFunction() {
            println("我是内部函数")
        }
        
        innerFunction() // 调用内部函数
    }
    
    outerFunction() // 调用外部函数
}

在这个示例中innerFunction 是 outerFunction 的嵌套函数。我们首先调用了 outerFunction然后在 outerFunction 的内部调用了 innerFunction嵌套函数对于封装和代码组织非常有用可以在一个函数内部定义一些辅助函数或私有方法

• 内部函数可以访问外部函数的参数
• 每次调用时会产生一个函数对象

注解使用处目标

注解Annotation被用作一种元数据机制用于向编译器传递额外的信息或者用于在运行时进行反射
当某个元素可能会包含多种内容(例如构造属性成员属性)使用注解时可以通过「注解使用处目标」让注解对目标发生作用例如 @file: 、 @get: 、@set: 等。

• @file:jvmName 指定生成的 Java 字节码文件中该函数的 JVM 名称
  
• @get:jvmName注解的作用是用于指定生成的Java字节码文件中该属性的JVM名称
  
• @set:jvmName 注解的作用是用于指定生成的 Java 字节码文件中该属性的 JVM 名称
  

函数简化

可以通过符号 = 简化原本直接 return 的函数

函数参数默认值

Kotlin 中使用函数参数默认值的示例

fun printMessage(message: String = "Hello") {
    println(message)
}

printMessage() // 输出 "Hello"
printMessage("World") // 输出 "World"

可以通过函数参数默认值来代替 Java 的函数重载

// 使用 @JvmOverloads 对 Java 暴露重载函数
@JvmOverloads
fun toast(text: CharSequence, duration: Int =
Toast.LENGTH_SHORT) {
Toast.makeText(this, text, duration).show()
}

在Java中重载函数也称为方法是指在一个类中定义多个具有相同名称但参数列表不同的方法。这些方法通常具有不同的行为以处理不同的输入参数通过使用相同的方法名Java允许您根据传递给方法的参数类型和数量来调用适当的方法。

public class Example {
    public void print(String message) {
        System.out.println(message);
    }
    
    public void print(int number) {
        System.out.println(number);
    }
}

在上面的示例中print 方法被重载了两次一次接受一个字符串参数另一次接受一个整数参数。根据调用时传递的参数类型将调用适当的方法

扩展

• 扩展函数可以为任何类添加上一个函数从而代替工具类
  

• 扩展函数和成员函数相同时成员函数优先被调用

• 扩展函数是静态解析的在编译时就确定了调用函数(没有多态)
  
  

函数类型

函数类型由「传入参数类型」和「返回值类型」组成用「 -> 」连接传入参数需要用「 () 」如果返回值为 Unit 不能省略 函数类型实际是一个接口我们传递函数的时候可以通过「 ::函数名 」,或者「匿名函数」或者使用 「 lambda 」

匿名函数

lambda

Java中调用

传递函数

内联函数

内联函数 的语义很简单把函数体复制粘贴到函数调用处 。使用起来也毫无困难用 inline关键字修饰函数即可。
用inline修饰的函数就是内联函数inline修饰符影响函数本身和传给它的lambda表达式所有这些都将内联到调用处即编译器会把调用这个函数的地方用这个函数的方法体进行替换而不是创建一个函数对象并生成一个引用

内联函数配合「函数类型」可以减少「函数类型」生成的对象
使用 inline 关键字声明的函数是「内联函数」在「编译时」会将「内联函数」中的函数体直接插入到调用处。
所以在写内联函数的时候需要注意尽量将内联函数中的代码行数减少

Kotlin内联函数的使用是通过关键字inline来声明的。内联函数在编译时会被插入到调用它的代码位置以减少函数调用的开销。
下面是一个简单的Kotlin内联函数的示例

inline fun max(a: Int, b: Int): Int {
    return a > b ? a : b
}

在这个例子中max函数被声明为内联函数。当你在代码中调用max函数时Kotlin编译器会将其代码直接插入到调用处而不是进行常规的函数调用。

需要注意的是内联函数的参数必须是具体的类型不能是可空类型。此外内联函数的代码必须非常简单否则会增加代码的大小和编译的时间。
除了在函数定义时使用inline关键字还可以在调用函数时使用inline关键字来强制内联函数。例如

fun main(args: Array<String>) {
    inline fun printMax(a: Int, b: Int) {
        println(max(a, b))
    }
    printMax(10, 20) // 内联函数调用
    printMax(100, 200) // 内联函数调用
}

在这个例子中printMax函数被声明为内联函数并在调用时使用了inline关键字。这样Kotlin编译器会将其代码直接插入到调用处而不是进行常规的函数调用。

部分禁用用内联

noinline 可以禁止部分参数参与内联编译

inline fun foo(inlined: () -> Unit, noinline notInlined:
() -> Unit) {
//......
}

在Kotlin中内联函数是默认情况下会被编译器内联的函数。内联函数的优点是可以减少函数调用的开销提高代码的执行效率。但是如果内联函数的代码较大会增加代码的大小从而影响到程序的整体性能。

noinline关键字可以用于禁止某些特定参数参与内联编译。当你在定义一个函数时可以使用noinline关键字来标记某些参数这样编译器就不会将这些参数内联到调用该函数的地方。

下面是一个使用noinline关键字的示例

fun foo(inlineParam: Int, noinlineParam: String) {
    // 函数内容
}

在这个例子中inlineParam参数会被编译器内联而noinlineParam参数则不会被内联。这样当你在调用foo函数时编译器会将inlineParam参数直接插入到调用处而noinlineParam参数则保持原样不会参与内联编译。

需要注意的是使用noinline关键字会使得代码的大小增加因为编译器需要保留每个函数的独立代码块。因此在使用noinline关键字时需要权衡代码大小和执行效率之间的利弊。

具体化的类型参数

因为内联函数的存在我们可以通过配合 inline + reified 达到「真泛型」的效果

val RETROFIT = Retrofit.Builder()
.baseUrl("https://api.hencoder.com/")
.build()

inline fun <reified T> create(): T {
return RETROFIT.create(T::class.java)
}
val api = create<API>()

在Kotlin中内联函数inline function和具体化的类型参数reified type parameter结合使用可以实现类似于“真泛型”的效果。

内联函数是指在函数定义中直接将函数体插入到调用处从而减少函数调用的开销。内联函数的优点是可以提高代码的执行效率但需要注意的是内联函数的代码行数不宜过多否则可能会增加代码的长度和编译时间。

具体化的类型参数是指在进行泛型编程时将类型参数具体化为实际的类型。在Kotlin中使用reified修饰符可以将泛型类型参数具体化这样就可以在运行时获取泛型类型的实际类型信息。

通过配合内联函数和具体化的类型参数可以实现类似于“真泛型”的效果。在Kotlin中可以使用内联函数和reified类型参数来实现类似于Java中的静态类型检查和运行时类型信息获取。

下面是一个简单的示例代码

inline fun <reified T> printInstance(instance: T) {
    val className = T::class.java.simpleName
    println("The instance of $className is: $instance")
}

fun main() {
    val stringInstance = "Hello, world!"
    val intInstance = 42

    printInstance(stringInstance) // 输出The instance of String is: Hello, world!
    printInstance(intInstance)   // 输出The instance of Int is: 42
}

在这个示例中我们定义了一个内联函数printInstance它接受一个类型为T的参数instance。通过使用reified修饰符我们可以在运行时获取泛型类型的实际类型信息。在函数内部我们使用T::class.java.simpleName来获取泛型类型的名称并使用println打印出实例的值和类型信息。

在main函数中我们分别传递了一个字符串实例和一个整数实例给printInstance函数。由于使用了内联函数和具体化的类型参数我们可以直接在函数内部获取泛型类型的实际类型信息并打印出实例的值和类型信息。

抽象属性

在 Kotlin 中我们可以声明抽象属性子类对抽象属性重写的时候需要重写对应的setter/getter

委托

属性委托

有些常⻅的属性操作我们可以通过委托的方式让它只实现一次例如
lazy 延迟属性值只在第一次访问的时候计算
observable 可观察属性属性发生改变时的通知
map 集合将属性存在一个 map 中
对于一个只读属性(即 val 声明的)委托对象必须提供一个名为 getValue() 的函数

对于一个可变属性(即 var 声明的)委托对象同时提供
setValue() 、 getValue() 函数

类委托

可以通过类委托的模式来减少继承
类委托的编译器会优先使用自身重写的函数而不是委托对象的函数

interface Base {
fun print()
}
class BaseImpl(val x: Int) : Base {
override fun print() {
print(x)
}
}
// Derived 的 print 实现会通过构造参数中的 b 对象来完成。
class Derived(b: Base) : Base by b

Kotlin 标准函数

使用时可以通过简单的规则作出一些判断

• 返回自身 -> 从 apply 和 also 中选

  • 作用域中使用 this 作为参数 ----> 选择 apply
    

  • 作用域中使用 it 作为参数 ----> 选择 also
    

• 不需要返回自身 -> 从 run 和 let 中选择

  • 作用域中使用 this 作为参数 ----> 选择 run
    

  • 作用域中使用 it 作为参数 ----> 选择 let
    

apply 适合对一个对象做附加操作的时候
let 适合配合空判断的时候 (最好是成员变量而不是局部变量局部变量更适合用 if )
with 适合对同一个对象进行多次操作的时候

课后题

下面的代码会输出什么

data class User

fun main(){
val user = User()
val copy = user.copy()
println(user == copy)
println(user === copy)
}

此代码在 Kotlin 中定义了一个名为 User 的数据类然后创建了一个 User 实例 user 并对其进行了复制创建了另一个实例 copy。然后它打印了两个比较的结果

1. user == copy此行会输出 true因为 user 和 copy 是具有相同属性值和状态的实例。
2. user === copy此行会输出 false因为虽然 user 和 copy 具有相同的属性值和状态但它们是两个不同的对象在内存中占据不同的位置。=== 操作符在 Kotlin
   中用于比较两个对象的引用是否相等而不仅仅是它们的属性值。

2. 【作文题】 声明一个变量 call 写一个「传入参数类型」是 Request 类型「返回值类型」是 Response 类型的「函数类型声明」

val call : /* 函数类型声明 */

可以使用 Kotlin 来声明一个函数类型该类型接受一个 Request 类型的参数并返回一个 Response 类型的结果。下面是如何声明这样的函数类型

val call: (Request) -> Response

这里我们创建了一个名为 CallType 的类型别名它表示一个接受 Request 类型参数并返回 Response
类型结果的函数。你可以根据实际需要更改 Request 和 Response 类型。