分类
类中的属性有两种：
可以存储值的属性
-
不存储属性值，每一次访问都需要通过 getter / setter 方法，因此每一次访问都需要计算。
interface Parent { val name: String val age: Int get() { println("getter") return 10 } } class Child:Parent{ override val name = "name" // 可以存储值。也可以通过 getter / setter 获取修改 set(value) { println("setter ${field} ${value}") field = value } }
getter 与 setter
-
在方法内部，使用特殊标识符 field 访问支持字段的值。
class Child { var i = 0 var name = "name" set(value) { println("setter ${field} ${value}") field = value // 为字段赋值 } get() { println("get ${field}") i++ field = "${i}" return "${i}" } } fun main(args: Array<String>) { val c = Child() println(c.name) c.name = "main--" println(c.name) }其输出结果为：
-
可以修改 getter/setter 的可见性。
class Test { var name = "" private set(value) { // 将 setter 可见性设置为 private field = value } }
可见性
默认的修饰符是 public
kt 新增修饰符 internal：模板可见。一个模板指的是一起编译的 kt 文件。
protected 只能用于修饰类中的成员
可见性低的类不能用于可见性高的类、方法、属性。
与 java 一样，重写可以提升可见性，但不能降低可见性。
internal class User()
open class Person()
class Student:Person(){
internal var user:User = User()
internal fun test():User = User()
}
上述代码中，由于 User 定义为 internal，所以 Student 类的 user 属性、test() 方法都只能定义成比 internal 或比它低的可见性。
同理，如果将 Person 类的可见性定义 internal ，则 Student 不能继承，除非将 Student 也定义成 internal 或比它低的可见性。
| 修饰符 | 类成员 | 顶层声明 |
|---|---|---|
| public(默认) | 所有地方可见 | 所有地方可见 |
| internal | 模块中可见 | 模块中可见 |
| protected | 子类可见 | - （不能修饰） |
| private | 类中可见 | 文件中可见 |
属性委托
使用关键字 by ，将属性的访问器委托给另一个实例。
属性委托只有在属性被访问时才进行初始化，与 lazy 函数类似。
格式
属性委托基本语法如下：
class Demo{
var p:Type by Delegate()
}
属性 p 将自己的 getter/setter 逻辑委托给了另一个对象，这里是 Delegate 的一个实例：通过对 by 后的表达式求值来获取这个实例。上述代码等价如下代码：
class Demo {
private val delegate = Delegate()
var p: Type
get() = delegate.getValue()
set(value) = delegate.setValue(value)
}
惰性初始化
lazy 函数会延迟加载，再结构 by 关键字可以实现委托属性。
在代码中，经常需要使用 惰性初始化：只有当需要该属性的时候才对属性进行初始化。
如下类，初始化时，并没有初始化 s，只有当访问 s 时才进行初始化，并且将初始化的值存储于 _s 中，这样下次访问时可以直接返回，这就是所谓的惰性初始化：
class Test {
private var _s: String? = null
val s: String
get() {
if (_s == null)
_s = "sss"
return _s!!
}
}
上述代码有点啰嗦，如果有多个惰性属性，这些模板代码需要写多次。而 属性委托可以让代码变得简单，可以封装用于存储值的支持属性以及确保该值只会被初始化一次。
委托类的构造
委托类有如下要求：
定义 getValue 与 setValue（如果是 val 变量，不需要）方法，且被声明为 operator
方法至少有两个参数，一个用于接收属性的实例；一个用于表示属性本身，其类型为 KProperty。可以通过 KProperty.name 获取属性名。
结合关键字 by ，kt 编译器自动完成 ‘惰性初始化‘ 中代码的功能
fun main(args: Array<String>) {
val d = Demo()
println(d.a) // 会输出 getValue ，然后再输出 1
d.a = 3 // 会输出 setValue
println(d.a) // 会输出 getValue ，然后再输出 3
}
class TestDelegate(var propValue: Int) {
operator fun getValue(demo: Demo, name: KProperty<*>): Int {
println("getValue")
return propValue
}
operator fun setValue(demo: Demo, name: KProperty<*>, newValue: Int) {
println("setValue")
propValue = newValue
}
}
class Demo {
var a: Int by TestDelegate(1)
}
从输出中可以发现：访问 a 属性时，所有的请求都转发到 TestDelegate 对应的方法中。这就是所谓的属性委托。
