我们可以像使用 java 中的字段那样,通过名字直接使用一个属性：

    2.     val result = Address() // 在 kotlin 中没有 new 关键字
    3.     result.name = address.name // accessors are called
    4.     result.street = address.street
    5.     // ...
    6.     return result
    7. }

    Getters 和 Setters

    声明一个属性的完整语法如下：

    1. var <propertyName>: <PropertyType> [ = <property_initializer> ]
    2.     <getter>
    3.     <setter>

    语法中的初始化语句，getter 和 setter 都是可选的。如果属性类型可以从初始化语句或者类的成员函数中推断出来,那么他的类型也是忽略的。

    例子：

    1. var initialized = 1 // 类型为 Int, 默认实现了 getter 和 setter

    只读属性的声明语法和可变属性的声明语法相比有两点不同: 它以 val 而不是 var 开头，不允许 setter 函数：

    我们可以像写普通函数那样在属性声明中自定义的访问器，下面是一个自定义的 getter 的例子:

    1. var isEmpty: Boolean
    2.     get() = this.size == 0

    下面是一个自定义的setter:

    1. var stringRepresentation: String
    2.     get() = this.toString()
    4.         setDataFormString(value) // 格式化字符串,并且将值重新赋值给其他元素
    5. }

    为了方便起见,setter 方法的参数名是value,你也可以自己任选一个自己喜欢的名称.

    1. val isEmpty get() = this.size == 0  //  拥有Boolean类型

    如果你需要改变一个访问器的可见性或者给它添加注解，但又不想改变默认的实现，那么你可以定义一个不带函数体的访问器:

    在 kotlin 中类不可以有字段。然而当使用自定义的访问器时有时候需要备用字段。出于这些原因 kotlin 使用 field 关键词提供了自动备用字段，

    1. var counter = 0 // 初始化值会直接写入备用字段
    2.     set(value) {
    3.         if (value >= 0)
    4.             field  = value
    5.     }

    field 关键词只能用于属性的访问器.

    编译器会检查访问器的代码,如果使用了备用字段(或者访问器是默认的实现逻辑)，就会自动生成备用字段,否则就不会.

    比如下面的例子中就不会有备用字段：

    1. val isEmpty: Boolean
    2.     get() = this.size == 0

    备用属性

    如果你想要做一些事情但不适合这种 “隐含备用字段” 方案，你可以试着用备用属性的方式：

    1. private var _table: Map<String, Int>? = null
    2. public val table: Map<String, Int>
    3.     if (_table == null)
    5.         return _table ?: throw AssertionError("Set to null by another thread")
    6.     }

    综合来讲，这些和 java 很相似，可以避免函数访问私有属性而破坏它的结构

    那些在编译时就能知道具体值的属性可以使用 const 修饰符标记为 编译时常量. 这种属性需要同时满足以下条件:

    • 以String或基本类型进行初始化

    • 没有自定义getter

    这种属性可以被当做注解使用:

    延迟初始化属性

    通常,那些被定义为拥有非空类型的属性,都需要在构造器中初始化.但有时候这并没有那么方便.例如在单元测试中,属性应该通过依赖注入进行初始化,
    或者通过一个 setup 方法进行初始化.在这种条件下,你不能在构造器中提供一个非空的初始化语句,但是你仍然希望在访问这个属性的时候,避免非空检查.

    为了处理这种情况,你可以为这个属性加上 lateinit 修饰符

    1. public class MyTest {
    2.     lateinit var subject: TestSubject
    4.     @SetUp fun setup() {
    5.         subject = TestSubject()
    6.     }
    8.     @Test fun test() {
    9.         subject.method()
    10.     }
    11. }

    这个修饰符只能够被用在类的 类型的可变属性定义中,不能用在构造方法中.并且属性不能有自定义的 getter 和 setter访问器.这个属性的类型必须是非空的,同样也不能为一个基本类型.

    在一个lateinit的属性初始化前访问他,会导致一个特定异常,告诉你访问的时候值还没有初始化.

    参看复写成员

    代理属性

    像这样常用操作可以通过代理属性作为库来实现。更多请参看这里。