Kotlin

以你之姓@ 2024-03-24 19:38 65阅读 0赞

## 一、了解Kotlin ##

#### 1.概述 ####

*  一种在Java虚拟机上运行的静态类型编程语言
 *  虽然与Java语法并不兼容，但可以和Java代码相互运作，可以使用Java现有框架
 *  容易在Android项目中替代Java或者同Java一起使用

在2019年的Google 1/0大会上Kotlin被选为Android开发首选语言

#### 2.特点 ####

*  简洁易用，提供大量扩展使代码更加的简洁，开发的框架更加易用
 *  安全，避免了空指针异常等一些常有类的错误，让代码更加的健壮
 *  互操作性，充分利用Android JVM 浏览器和现有的库，和已有的技术，完成一个互通
 *  工具友好，可以使用任意Java的ide 或者浏览器来构建kotlin 应用

#### 3.构建流程 ####

Kotlin文件会被Kotlin 编译器编译成Java字节码文件，字节码文件会被jar工具打包成jar包，最终会被各平台的打包工具输出成我们的应用程序

## 二、基础 ##

### 1.数据类型 ###

Byte、Short、Int、Long、Float、Double

*  整数
    
     *  Byte 8位
     *  Short 16位
     *  Int 32位
     *  Long 64位
 *  浮点数
    
     *  Float；32位
     *  Double；64位

### 2.数组 ###

**数组的创建**

// arrayOf
            val array: Array<Int> = arrayOf(1, 2, 3)
    
            // arrayOfNulls
            val array1: Array<Int?> = arrayOfNulls<Int>(3)
            array1[0] = 4
            array1[1] = 5
            array1[2] = 6
    
            // Array(5)的构造函数
            val array2: Array<String> = Array(5) { i ->
                (i * i).toString()
            }
    
            // intArrayOf(), doubleArrayOf()
            val x: IntArray = intArrayOf(1, 2, 3)
            println("x[0] + x[1] = ${x[0] + x[1]}")
    
            // 大小为5，值为【0，0，0，0，0】的整型数组
            val array3 = IntArray(5)
    
            // 大小为5，值为【1，1，1，1，1】的整型数组
            val array4 = IntArray(5) { 1 }
    
            // 大小为5、值为【0，1，2，3，4】的整形数组（值初始化为其索引值）
            val array5 = IntArray(5) { it * 1 }
            println(array5[4])

**数组的遍历**

// 数组遍历
            for (item in array) {
                println(item)
            }
    
            // 带索引遍历数组
            for (i in array.indices) {
                println("$i -> ${array[i]}")
            }
    
            // 遍历元素（带索引）
            for ((index, item) in array.withIndex()) {
                println("$index -> $item")
            }
            
            // forEach遍历数组
            array.forEach {
                println(it)
            }
    
            // forEach增强版
            array.forEachIndexed { index, item ->
                println("$index -> $item")
            }

### 3.集合 ###

*  List
 *  Set
 *  Map

**集合的可变形与不可变性--**以mutable为前缀的为可变集合

//不可变集合
    val stringList: List<String> = listOf("one", "two", "one")
    
    //可变集合
    val numbers: MutableList<Int> = mutableListOf(1, 2, 3, 4)

**集合排序：**

val number3 = mutableListOf(1, 2, 3, 4)
    
            // 随机排序
            number3.shuffle()
    
            // 从小到大
            number3.sort() 
    
            // 从大到小
            number3.sortDescending() 
    
            // 使用sortBy进行排序，适合单条件排序
            lauguageList.sortBy { it.score }
    
            // 使用sortWith进行排序，适合多条件排序
            lauguageList.sortWith(compareBy({
                it.score
            }, { it.name }))

### 4.方法 ###

**方法声明**

//方法申明   
    fun learn(days: Int): Boolean {
        return days > 100
    }
    fun  方法（参数）：返回值{
        方法体
    }

**方法可以直接定义在文件中**

package com.lf.testkotlin
    
    fun functionLearn(days: Int): Boolean {
        return days > 100
    }

**成员方法：**类().成员方法

fun main() {
        Person().test1()
    }
    
    class Person {
    
        fun test1() {
            println("成员方法")
        }
    }

**静态方法（类方法）：**使用伴生对象来实现类方法 类.类方法

fun main() {
        Person.test2()
    }
    
    class Person {
        companion object {
            fun test2() {
                println("companion object 实现类方法")
            }
        }
    }

**工具类：**Object关键字来修饰，内部所有的方法都是静态的

package com.lf.testkotlin
    
    object NumUtil {
        fun double(num: Int): Int {
            return num * 2
        }
    }
    
    fun main() {
        NumUtil.double(2)
    }

**单表达式方法：**当方法返回单个表达式时，可以省略花括号并且在 = 之后指定代码体即可

fun double(x: Int): Int = x * 2

**参数默认值****：**方法参数可以有默认值，当省略相应的参数时使用默认值，与其java相比，减少重载数量

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    
    }

**可变数量的参数**：vararg

fun append(vararg str: Char): String {
        val result = StringBuffer()
        for (char in str) {
            result.append(char)
        }
        return result.toString()
    }

**局部方法：**在方法的内部创建方法

fun magic(): Int {
        fun foo(v: Int): Int {
            return v * v
        }
    
        val v1 = (0..100).random()
        return foo(v1)
    }

### 5.Lambda表达式 ###

**无参数的情况**

val/var 变量名 = { 操作的代码 }
    
    eg:
        //源代码
        fun test() {
            println("无参数")
        }
    
        //lambda代码
        val test1 = { println("无参数") }

**有参数的情况**

val/var 变量名 : (参数的类型, 参数类型, ...) -> 返回值类型 
        = {参数1, 参数2, ... -> 操作参数的代码}
    // 等价于，即表达式的返回值类型会根据操作的代码自推导出来。
    val/var 变量名 = {参数1: 类型, 参数2: 类型, ... -> 
        操作参数的代码}
    
    eg:
        // 源代码
        fun test2(a: Int, b: Int): Int {
            return a + b
        }
    
        // lambda代码
        val test3: (Int, Int) -> Int = { a, b -> a + b }
        //或者
        val test4 = { a: Int, b: Int -> a + b }

### 6.it ###

it是在当一个高阶方法中Lambda表达式的参数只有一个的时候可以使用it来使用此参数

// 这里举例一个语言自带的一个高阶方法filter，此方法的作用是过滤掉不满足条件的值
    val arr = arrayOf(1, 3, 5, 7, 9)
    // 过滤掉数组中元素小于5的元素，取其第一个打印。这里的it就表示每一个元素。
    println(arr.filter { it < 5 }.component1())
    
    testClosure(1)(2) {
        println(it)
    }

### 7.下划线 ###

在使用Lambda表达式的时候，可以用下划线（\_）表示未使用的参数，表示不处理这个参数

val map = mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3")
    map.forEach { (key, value) ->
        println("$key \t $value")
    }
    
    // 不需要key的时候
    map.forEach { (_, value) -> println(value) }

## 三、方法进阶 ##

#### 高阶方法（函数） ####

**函数作为参数**

/**
         * eg: 实现一个能够对集合元素进行求和的高阶函数，并且每遍历一个集合元素要有回调
         */
        fun List<Int>.sum(callback: (Int) -> Unit): Int {
            var result = 0
            for (v in this) {
                result += v
                callback(v)
            }
            return result
        }
    // 调用
    val list = listOf(1, 2, 3)
    val result = list.sum { println("it:${it}") }
    println("${result}")

**函数作为返回值**

/**
         * eg: 实现一个能够对集合元素进行求和的高阶函数，并且返回一个声明为（scale: Int）-> Float的函数
         */
        fun List<String>.toIntSum(): (scale: Int) -> Float {
            println("第一层函数")
            return fun(scale): Float {
                var result = 0f
                for (v in this) {
                    result += v.toInt() * scale
                }
                return result
            }
        }
    // 调用
    val listString = listOf("1", "2", "3", "4")
    val result2 = listString.toIntSum()(2)
    println("计算结果：${result2}")

#### 闭包（Closure） ####

*  闭包可以理解为能够读取其他方法内部变量的方法；
 *  闭包是将方法内部和方法外部连接起来的桥梁；

**特性：**

*  方法可以作为另一个方法的返回值或参数，还可以作为一个变量的值；
 *  方法可以嵌套定义，即在一个方法内部可以定义另一个方法；

**好处：**

*  加强模块化
 *  抽象
 *  灵活
 *  简化代码

**举例：**  
实现一个接受一个testClosure方法，该方法要接受一个Int类型的v1参数，同时能够返回一个声明为(v2: Int, (Int) -> Unit)的函数，并且这个函数能够计算v1与v2的和。

fun testClosure(v1: Int): (v2: Int, (Int) -> Unit) -> Unit {
        return fun(v2: Int, printer: (Int) -> Unit) {
            printer(v1 + v2)
        }
    }
    // 调用
    testClosure(1)(2) {
        println(it)
    }

#### 方法的解构声明 ####

把里面的字段给解构出来

data class Result(val message: String, val code: Int)
    
    fun test11() {
        var result = Result("message", 0)
        // 解构
        val (message, code) = result
        println("message:${message} code:${code}")
    }

#### 匿名方法 ####

val fun1 = fun(x: Int, y: Int): Int = x + y

#### 方法字面值 ####

fun literal() {
            // 定义了一个变量tmp，而该变量的类型就是(Int)-> Boolean
            var temp: ((Int) -> Boolean)? = null
            // { num -> (num > 10) } 就是方法字面值
            temp = { num -> (num > 10) }
            println("temp(11):${temp(11)}")
        }

## 四、构造方法 ##

/**
     * 主构造方法(主构造方法constructer()可以省略)
     */
    class KotlinClass constructor(name: String) {
        // 次构造方法
        constructor(view: View, name: String) : this(name) {
            println("name:$name")
        }
    
        constructor(view: View, name: String, index: Int) : this(name) {
            println("name:$name,index:$index")
        }
    }

## 五、继承与覆盖 ##

父类必须用open修饰，需要被覆盖的方法也需要open修饰，需要被覆盖的属性也需要open修饰

open class Animal(age: Int) {
        init {
            println(age)
        }
    
        open val foot: Int = 0
        open fun eat() {
    
        }
    }
    
    class Dog : Animal {
        constructor(age: Int) : super(age)
    
        override val foot = 4
        override fun eat() {
            super.eat()
        }
    }

## 六、属性 ##

//其初始器（initializer）、getter和setter都是可选的。如果属性类型可以从初始器（或者从其getter返回值）中推断出来，也可以省略
    var <propertyName>[: <PropertyType>] [ = <property_initializer>]
            [<getter>]
            [<setter>]
    
    eg:
    
    val simple: Int? // 类型Int、默认getter、必须在构造方法中初始化
    
    //定义了一个自定义的getter，每次访问该属性时都会调用它。
    val isClose: Boolean
            get() = Calendar.getInstance().get(Calendar.HOUR_OF_DAY) > 11
    
    //定义了一个自定义的setter，每次给属性赋值时都会调用它
     var score: Float = 0.0f
            get() = if (field < 0.2f) 0.2f else field * 1.5f
            set(value) {
                println(value)
            } 
    
    属性延迟初始化
    
    lateinit var shop: Shop2
        fun setup() {
            shop = Shop2()
        }
    
        fun test() {
            // ::表示创建成员引用或类引用
            if (::shop.isInitiaized) println(shop.address)
        }

## 七、抽象类与接口 ##

/**
     * 抽象方法
     */
    abstract class Printer {
        abstract fun print()
    }
    
    class FilePrinter : Printer() {
        override fun print() {
    
        }
    }
    
    /**
     * 接口
     */
    interface Study {
        val time: Int//抽象的
        fun discuss()
        fun learnCourses() {
            println("Android 架构师")
        }
    }
    
    class StudyAS(override val time: Int) : Study {
        override fun discuss() {
    
        }
    }

#### **数据类** ####

必须要有至少一个参数，并且不能被定义成open或者抽象的，不能被继承。

/**
     * 数据类，可以有自己的类体，包括属性和方法
     */
    data class Address(val name: String, val number: Int) {
        var city: String = ""
        fun print() {
            println(city)
        }
    }

#### **对象表达式与对象声明** ####

open class Address2(name: String) {
        open fun print() {
    
        }
    }
    
    class Shop2 {
        var address: Address2? = null
        fun addAddress(address2: Address2) {
            this.address = address2
        }
    }
    
    fun test3() {
        // 如果超类型有一个构造方法，则必须传递适当的构造方法参数给它
        Shop2().addAddress(object : Address2("Android") {
            override fun print() {
                super.print()
            }
        })
    }
    
    fun foo() {
        val adHoc = object {
            var x: Int = 0
            var y: Int = 0
        }
        println(adHoc.x + adHoc.y)
    }
    
    /**
     * 对象的声明
     */
    object DataUtil {
        fun <T> isEmpty(list: ArrayList<T>): Boolean {
            return list?.isEmpty()
        }
    }

#### **伴生对象** ####

class Student(val name: String) {
        companion object {
            val student = Student("Android")
            fun study() {
                println("Android 架构师")
            }
        }
    }
    
    fun testStudent() {
        println(Student.student)
        Student.study()
    }

## 八、泛型 ##

泛型接口

interface Drinks<T> {
        fun taste(): T
        fun price(t: T)
    }
    
    class Sweet {
        val price = 5
    }
    
    class Coke : Drinks<Sweet> {
        override fun taste(): Sweet {
            println("Sweet")
            return Sweet()
        }
    
        override fun price(t: Sweet) {
            println("Coke price:${t.price}")
        }
    }

泛型方法

/**
     * 泛型方法
     */
    fun <T> fromJson(json: String, tClass: Class<T>): T? {
        // 获取t的实例
        val t: T? = tClass.newInstance()
        return t
    }

泛型约束

在kotlin中out代表协变，in代表逆变，为了加深理解我们可以将kotlin的协变看成java的上界通配符，将逆变看成java的下界通配符

## 九、注解 ##

#### 注解的申明 ####

//和一般的声明很类似，只是在class前面加上了annotation修饰符
    annotation class ApiDoc(val value: String)
    
    @ApiDoc("修饰类")
    class Box {
        @ApiDoc("修饰字段")
        val size = 8
    
        @ApiDoc("修饰方法")
        fun test() {
            
        }
    }

#### **元注解：** ####

给注解类加注解

>  *  @Target：定义注解能够应用于哪些目标对象；
>  *  @Retention：注解的保留期；
>  *  @Repeatable：标记的注解可以多次应用于相同的声明或类型；
>  *  @MustBeDocumented：修饰的注解将被文档工具提取到API文档中；

**@Target**

接受一个vararg可变数量的参数，可以同时指定多个作用的目标对象，参数类型限定为AnnotationTarget

public enum class AnnotationTarget {
        CLASS,// 表示作用对象有类、接口、object对象表达式、注解类
        ANNOTATION_CLASS,//表示作用对象只有注解类
        TYPE_PARAMETER,//表示作用对象是泛型类型参数（暂时还不支持）
        PROPERTY,//表示作用对象是属性
        FIELD,//表示作用对象是字段，包括属性的幕后字段
        LOCAL_VARIABLE,//表示作用对象是局部变量
        VALUE_PARAMETER,//表示作用对象是函数或构造函数的参数
        CONSTRUCTOR,//表示作用对象是构造函数，主构造函数或次构造函数
        FUNCTION,//表示作用对象是函数，不包括构造函数
        PROPERTY_GETTER,//表示作用对象是属性的getter函数
        PROPERTY_SETTER,//表示作用对象是属性的setter函数
        TYPE,//表示作用对象是一个类型，比如类、接口、枚举
        EXPRESSION, //表示作用对象是一个表达式
        FILE,//表示作用对象是一个File
        @SinceKotlin("1.1")
        TYPEALIAS//表示作用对象是一个类型别名
    }

**@Retention**

接收一个AnnotationRetention类型的参数，该参数有个默认值，默认是保留在运行时期

@Retention元注解取值主要来源于AnnotationRetention枚举类
    public enum class AnnotationRetention {
        SOURCE,//源代码时期（SOURCE）：注解不会存储在输出class字节码中
        BINARY,//编译时期（BINARY）：注解会存储在class字节码中，但是对反射不可见
        RUNTIME//运行时期（RUNTIME）：注解会存储在class字节码中，也会对反射可见
    }

#### 使用场景： ####

*  提供信息给编译器：编译器可以利用注解来处理一些，比如一些警告信息、错误等。
 *  编译阶段时处理：利用注解信息来生成一些代码，在kotlin生成代码非常常见，一些内置的注解为了与java API的互操作性，往往借助注解在编译阶段生成一些额外的代码。
 *  运行时处理：某些注解可以在程序运行时，通过反射机制获取注解信息来处理一些程序逻辑。

## 十、扩展 ##

#### 1.好处 ####

*  提供架构的易用性；
 *  减少代码量，让代码更加整洁、纯粹；
 *  提高编码的效率，生产力提高；

#### 2.扩展方法 ####

//交换列表中的两个元素的位置
    fun MutableList<Int>.swap(index1: Int, index2: Int) {
        val temp = this[index1]
        this[index1] = this[index2]
        this[index2] = temp
    }
    
    //泛型扩展方法
    fun <T> MutableList<T>.swap2(index1: Int, index2: Int) {
        val temp = this[index1]
        this[index1] = this[index2]
        this[index2] = temp
    }

#### 3.扩展属性 ####

//获取字符串中的最后一个元素
    fun String.lastChar():Char = this.get(this.length - 1)

#### 4.为伴生对象添加扩展 ####

class Jump {
        companion object {}
    }
    
    fun Jump.Companion.print(str: String) {
        println(str)
    }

#### 5.kotlin中的扩展 ####

**let**

*  一个作用域函数
 *  可以避免写一些判断null的操作

//原型
    fun <T, R> T.let(f: (T) -> R): R = f(this)
    
    //举例
    fun testLet(str: String?) {
        // 避免为null的操作
        str?.let {
            println(it.length)
        }
        //限制作用域
        str.let {
            val str2 = "let作用域"
            println(it + str2)
        }
    }

**run**

只接收一个lambda函数为参数，以闭包形式返回，返回值为最后一行的值或者指定的return的表达式，在run函数中可以直接访问实例的公有属性和方法。

//原型
    fun <T, R> T.run(f: T.() -> R): R = f()
    
    //举例
    data class Room(val address: String, val price: String, val size: Float)
    
    fun testRun(room: Room) {
        room.run {
            println("Room:$address,$price,$size")
        }
    }

**apply**

调用某对象的apply函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象。

//原型
    fun <T> T.apply(f: T.() -> Unit): T { f(); return this }
    
    //举例
    fun testApply() {
        ArrayList<String>().apply {
            add("1")
            add("2")
            add("3")
        }.let {
            println(it)
        }
    }

从结构上来看apply函数和run函数很像，唯一不同点就是它们各自返回的值不一样，run函数是以闭包形式返回最后一行代码的值，而apply函数的返回的是传入对象的本身。

## 十一、扩展案例 ##

**使用Kotlin扩展为控件绑定监听器减少模版代码**

//为Activity添加find扩展方法，用于通过资源id获取控件
    fun <T : View> Activity.find(@IdRes id: Int): T {
        return findViewById(id)
    }
    
    //为Int添加onClick扩展方法，用于为资源id对应的控件添加onclick监听
    fun Int.onClick(activity: Activity, click: () -> Unit) {
        activity.find<View>(this).apply {
            setOnClickListener {
                click
            }
        }
    }
    
    //使用
    val textView = find<TextView>(R.id.text)
    R.id.text.onClick(this) {
        textView.text = "kotlin扩展"
    }

## 十二、实用技巧 ##

*  使用Kotlin安卓扩展，减少findViewById的模板代码

//使用方法
    //1.gradle中引入插件：
    apply plugin: 'kotlin-android-extensions'
    
    //2.在代码中导入：
    import kotlinx.android.synthetic.main.<布局>.*
    
    //3.若需要调用View的合成属性，同时还应该导入
    import kotlinx.android.synthetic.main.view.*
    
    //4.最后可以通过控件id来访问这些控件了

*  字符串的空判断，使用 isNullOrEmpty、isNullOrBlank
 *  使用@JvmOverloads告别繁琐的构造函数重载

//java
    public class CustomView extends FrameLayout {
        public CustomView(@NonNull Context context) {
            super(context);
        }
    
        public CustomView(@NonNull Context context, @Nullable AttributeSet attrs) {
            super(context, attrs);
        }
    
        public CustomView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
        }
    }
    
    //kotlin
    class CustomKotlinView @JvmOverloads constructor(
        context: Context,
        attrs: AttributeSet? = null,
        defStyleAttr: Int = 0
    ) : FrameLayout(context, attrs, defStyleAttr) {
        
    }