面向对象：属性

Kotlin 中的属性（field）比 Java 更加复杂，主要由于如下几点：

1. Kotlin 中容许 包级属性 的存在，即属性不必定在类里；

2. 全部非抽象属性都强制要求初始化，没有初始化的属性没法经过编译（除标记为 lateinit var 的属性外）；

3. 标准化的 getter 和 setter；

4. 大量的高级属性修饰符。

1. 类内声明属性

首先看一下在类里面声明属性的完整格式吧：

[修饰符] val|var 属性名[: 属性类型][= 初始化语句]
    [get() = getter 语句]
    [set() = setter 语句]

这里有几个小细节：

1. 属性不能缺乏初始化语句，要么写在定义属性的地方，要么写在 init 语句里，不然就会编译错误；

2. 标记为 val 的属性不能有自定义的 setter，这个很容易理解，由于 Kotlin 强制要求属性初始化，标记为 val 的属性已经在建立对象的时候初始化了，不能再次赋值。

咱们用几个例子说明一下：

// 初始化语句class Person(val name: String) {
  val age: Int
  val id: Long = 0
  val nationality: String
  
  init {
    age = 0
  }}

这个 Person 类定义了 4 个属性，各有不一样的初始化方式：

• name 属性在主构造方法里定义，使用转入的参数初始化；

• age 属性在 init 语句里初始化；

• id 属性在定义属性时初始化；

• nationality 属性不是抽象属性，没有在定义时初始化，也没有在 init 里初始化，编译错误。

2. getter 和 setter

Kotlin 把 Java 中没有固定标准的 getter 和 setter 方法标准化，而且规定调用 Kotlin 类的属性时强制使用 setter 和 getter 方法，不会直接操做类的属性。

须要注意，Kotlin 和 Java 访问 name 属性的写法是不同的：

// Kotlin 访问属性val p = Person("Alex")println(p.name)p.name = "Bob"

// Java 访问属性Person p = new Person("Alex");// System.out.println(p.name); 编译错误，没法访问 private 属性System.out.println(p.getName());p.setName("Bob");

不对吧，不是说 Kotlin 不容许直接操做类属性吗，为何 Kotlin 中能够用“对象.属性”的写法呢？这是由于 Kotlin 中的“对象.属性”会视状况自动编译为调用 getter 或 setter 方法。

同时，Kotlin 容许属性添加自定义的 getter 和 setter：

class Person(name: String) {
    var name = name
        set(value) {
            field = if (value.isEmpty()) "" else value[0].toUpperCase() + value.substring(1)
        }

    val isValidName
        get() = !name.isEmpty()}

这里有几个细节：

1. 须要自定义 setter 或 getter 的属性，不能放在类头里定义，必须在类体内定义，要否则 Kotlin 怎么知道你自定义了哪一个属性的 getter 和 setter 呢？因此这里咱们把本来在类头里定义的 name 属性挪到了类体内定义，并使用传入的 String 类型参数初始化 name 属性，name 属性被自动推导为 String 类型；

2. getter 是一个没有参数、返回类型与属性类型相同的函数。完整的写法应该是这样的：

   get(): 属性类型 {
     //……}
   

   可是通常 getter 的方法比较短，并且能够自动推导类型，因此若是只有一句的话能够写成“get() = 函数语句”的形式。须要注意一点，不能在 getter 里再调用本属性，由于 Kotlin 代码里全部对属性的访问都会被编译为 getter 方法，这样写就会出现无限迭代和 StackOverFlowError

3. setter 的参数列表通常有一个与属性类型相同的参数，没有返回值。

   Kotlin 中通常用 value 表示这个参数，固然也能够用其余关键字；

   这里的 field 是表示 幕后字段 的关键字，它在使用时至关于 this.name，可是只能用在 setter 方法内。

3. 类外属性

在 Kotlin 类外定义的属性有两种，一是直接写在类外并初始化的包级属性，二是使用 const val 定义的 编译期常量。

1. 在类外定义的包级属性，会被编译为一个“文件类”的静态变量：

   // oop.Person.ktclass Person(val name: String)val maxID = Int.MAX_VALUE
   

   编译这个文件，实际上会造成两个类，一个是咱们定义的 Person 类，另外一个是“文件类”PersonKt。反编译这个类的字节码，咱们发现它是这样的：

   public final class PersonKt {
     private static final int maxID = Integer.MAX_VALUE;
     public static final int getMaxID() {
       return maxID;
     }}
   

   maxID 被编译为这个类私有的静态字段，并拥有一个默认的 getter 方法。要调用这个属性，Kotlin 和 Java 代码有所不一样，以下：

   // Kotlin 调用包级属性import oop.maxID // 由于是包级变量，因此使用“包名.属性名”的方式导入val a = maxID // 直接调用，不须要标明变量所在的文件
   

   // Java 调用包级属性import oop.PersonKt; // 导入自动生成的“文件类”int a = PersonKt.getMaxID(); // 使用默认的 getter 方法调用静态属性
   

2. 
   

3. 编译期常量使用 const val 定义在类外，它与包级属性有必定的类似之处。咱们把上面的 maxID 声明为编译期常量：

   // oop.Person.ktclass Person(val name: String)const val maxID = Int.MAX_VALUE // 将 maxID 声明为编译期常量
   

   再看一下反编译的 PersonKt 类：

   public final class PersonKt {
      public static final int maxID = Integer.MAX_VALUE;}
   

   能够看到，编译期常量其实就是 Java 中经常使用的常量。但与 Java 中的常量相比，Kotlin 的编译期常量有如下几点限制：

   还有，Kotlin 中，使用在注解参数中的属性，只能是编译期常量（其余形式的属性都不能使用在注解的参数里）：

   const val DEPRECATED_MESSAGE = "This is deprecated."@Deprecated(DEPRECATED_MESSAGE) fun foo() {……}
   

   4. lateinit 修饰符

   Kotlin 强制要求类内定义的非抽象属性都要初始化，可是有些属性不须要在新建实例时初始化，或可能须要外部注入来初始化，这些时候咱们都没法按照 Kotlin 的要求初始化属性。为了不编译错误，可使用 lateinit 关键字修饰属性。

   看下面的例子：

   class Person(val name: String) {
       lateinit var hello: String
       fun initHello() {
           hello = "Hello, my name is $name"
       }}
   

   咱们使用 lateinit 关键字修饰 hello 属性，定义了 initHello() 函数来初始化 hello 属性。

   // Test.ktfun main(args: Array<String>) {
     val p = Person("Alex")
     println(p.hello)}
   

   若是调用了未初始化的 lateinit 属性，就会抛出 UninitializedPropertyAccessException。咱们修改下测试函数，在调用 hello 属性前初始化属性：

   // Test.ktfun main(args: Array<String>) {
     val p = Person("Alex")
     p.initHello()
     println(p.hello)}
   

   这样，就能输出正确的结果了：

   Hello, my name is Alex
   

• 只能定义在类外或对象（Object）内；

• 只能使用 String 或原生类型（Int、Double 等）初始化；

• 不能自定义 getter（直接调用，不须要 getter）