Kotlin 基础(二)

1.延迟初始化属性

// Kotlin可以对属性设置为延迟初始化
lateinit var dept: Department

提示:　延迟初始化属性要求：不能是可空类型；只能使用为var声明；lateinit关键字应该放在var之前。

2. 委托属性

Kotlin提供一种委托属性，使用by关键字声明

class User {
    var name: String by Delegate() 
}
class Delegate {
    operator fun getValue(thisRef: Any, property: KProperty<*>): String = property.name 
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) { 
        println(value)
    }
}
fun main(args: Array<String>) {
    val user = User()
    user.name = "Tom" 
    println(user.name) 
}

注意这两个函数前面都有operator关键字修饰，operator所修饰的函数是运算符重载函数，本例中说明了getValue和setValue函数重载by运算符。

3.惰性加载属性

惰性加载属性与延迟初始化属性类似，只有第一次访问该属性时才进行初始化。不同的是惰性加载属性使用的lazy函数声明委托属性，而延迟初始化属性lateinit关键字修饰属性。还有惰性加载属性必须是val的，而延迟初始化属性必须是var的。

val fullName: String by lazy {   // ①
    firstName + "." + lastName
}
lateinit var dept: Department   // ②

上述代码第①行声明了的惰性加载属性fullName，by后面是lazy函数，注意lazy不是关键字，而是函数。lazy函数后面跟着的是尾随Lambda表达式。惰性加载属性使用val声明。
代码第②行声明了延迟初始化属性dept，使用关键字lateinit。延迟初始化属性使用var声明。

4. 可观察属性

另一个使用委托属性示例是可观察属性，委托对象监听属性的变化，当属性变化时委托对象会被触发。

class Department {
    var no: Int = 0 // 部门编号属性
    var name: String by Delegates.observable("<无>") { p, oldValue, newValue -> ①
        println("$oldValue -> $newValue")
    }
}

fun main(args: Array<String>) {
    val dept = Department()
    dept.no = 20
    dept.name = "技术部" //输出<无> -> 技术部 ②
    dept.name = "市场部" //输出技术部 -> 市场部 ③
}

上述代码第①行是声明name委托属性，by关键字后面Delegates.observable()函数有两个参数：第一个参数是委托属性的初始化值，第二个参数是属性变化事件的响应器，响应器是函数类型，具体调用时可使用Lambda表达式作为实际参数。在用Lambda表达式中有三个参数，其中p是属性，oldValue是属性的旧值，newValue是属性的新值。

5. 扩展函数

fun 接收类型.函数名(参数列表) : 返回值类型 {
    函数体
    return 返回值
}

//基本数据类型扩展
fun Double.interestBy(interestRate: Double): Double { ①
    return this * interestRate
}
//自定义账户类
class Account {
    var amount: Double = 0.0 //账户金额
    var owner: String = "" //账户名
}
//账户类扩展函数
fun Account.interestBy(interestRate: Double): Double { ②
    return this.amount * interestRate
}

6. 扩展属性

var|val 接收类型.属性名 [ : 数据类型]
           [getter访问器]
           [setter访问器]

 

7. 定义中缀运算符

注意　定义中缀运算符，就是要声明一个infix关键字修饰的函数，该函数只能有一个参数，该函数不能是顶层函数，只能成员函数或扩展函数。

//定义中缀函数interestBy
infix fun Double.interestBy(interestRate: Double): Double { 
    return this * interestRate
}

8. 主构造函数

主构造函数涉及到两个关键字constructor和init。主构造函数在类头中、类名的后面声明，使用关键字constructor。

class Rectangle constructor(w: Int, h: Int) { 
    // 矩形宽度
    var width: Int 
    // 矩形高度
    var height: Int 
    // 矩形面积
    var area: Int 
    init { //初始化代码块 
        width = w
        height = h
        area = w * h// 计算矩形面积
    }
}
// 简化
class Rectangle constructor(var width: Int, var height: Int) {
    // 矩形面积
    var area: Int
    init {//初始化代码块
        area = width * height// 计算矩形面积
    }
}

如果所有的属性都在主构造函数中初始化，可以省略init代码块

提示：　如果主构造函数没有注解（Annotation）或可见性修饰符，constructor关键字可以省略。

class User(val name: String, var password: String)

// User类不能省略constructor关键字，因为User前面private可见行修饰符

class User private constructor(val name: String, var password: String)

9. 次构造函数

由于主构造函数只能有一个，而且初始化时只有init代码块，有时候不够灵活，这时可以使用次构造函数。次构造函数是在函数体中声明的，使用关键字constructor声明。

class Rectangle(var width: Int, var height: Int) {
    // 矩形面积
    var area: Int
    init {//初始化代码块
        area = width * height// 计算矩形面积
    }
    constructor(width: Int, height: Int, area: Int) : this(width, height) { 
        this.area = area
    }
    constructor(area: Int) : this(200, 100) {//width=200 height=100 
        this.area = area
    }
}

次构造函数后面的this(width, height)和this(200, 100)表达式就是调用当前对象的主构造函数

10. 默认构造函数

如果一个非抽象类中根本看不到任何的构造函数，编译器会为其生成一个默认的构造函数，即无参数public的主构造函数。

//默认构造函数
class User {
    // 用户名
    val username: String?
    // 用户密码
    val password: String?
    init {
        username = null
        password = null
    }
}

11.可见性修饰符使用规则

可见性              修饰符            类成员声明                    顶层声明                                  说明
公有                 public            所有地方可见                所有地方可见                     public是默认修饰符
内部                 internal           模块中可见                   模块中可见                         不同于Java中的包
保护                protected         子类中可见                                                             顶层声明中不能使用

私有                private              类中可见                       文件中可见

12. 数据类

// 数据类的声明很简单，只需要类头class前面加上data关键字即可
data class User(val name: String, var password: String)

提示:　使用data声明的数据类的主构造函数中参数一定声明为val或var的，不能省略。而普通类可以省略的，

使用is和!is进行类型检查

使用as和as?进行类型转换

 

Lambda体中it隐式变量是由Kotlin编译器生成的，它的使用有两个前提：一是Lambda表达式只有一个参数，二是根据上下文能够推导出参数类型。

 

泛型

泛型特性对Kotlin影响最大是在集合中使用泛型

 

Kotlin中创建对象数组有三种方式：
arrayOf(vararg elements: T)工厂函数。指定数组元素列表创建元素类型为T的数组，vararg表明参数个数是可变的。
arrayOfNulls<T>(size: Int)函数。size参数指定数组大小，创建元素类型为T的数组，数组中的元素为空值。
Array(size: Int, init: (Int) -> T)构造函数。通过size参数指定数组大小，init参数指定一个用于初始化元素的函数，实际使用时经常是Lambda表达式。

 

基本数据类型数组的创建三种方式，下面以Int类型为例介绍一下：
intArrayOf(vararg elements: Int)工厂函数。通过对应的工厂函数，vararg表明参数是可变参数，是Int数据列表。
IntArray(size: Int)构造函数。size参数指定数组大小创建元素类型为Int的数组，数组中的元素为该类型默认值，Int的默认值是0。
IntArray(size: Int, init: (Int) -> Int)构造函数。通过size参数指定数组大小，init参数指定一个用于初始化元素的函数，参数经常使用Lambda表达式。

 

Kotlin 数据类

data class User(var name: String, var password: String)

Kotlin数据类，其中有两个属性，var声明的属性会生成setter和getter函数，如果是val声明的属性是只读的，只生成getter函数

 

引用类有两种形式：类名::class和对象::class。

//1.获得“类名::class”引用类
val clz1 = Int::class
val clz2 = Person::class
val person = Person("Tom")
//2.获得“对象::class”引用类
val clz3 = person::class