面向对象：属性

翻译

余生浅末 2017-05-27 16:33:12

Kotlin 中的属性（field）比 Java 更加复杂，主要因为以下几点：

Kotlin 中允许 包级属性 的存在，即属性不一定在类里；
所有非抽象属性都强制要求初始化，没有初始化的属性无法通过编译（除标记为 lateinit var 的属性外）；
标准化的 getter 和 setter；
大量的高级属性修饰符。

1. 类内声明属性

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

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

这里有几个小细节：

属性不能缺少初始化语句，要么写在定义属性的地方，要么写在 init 语句里，否则就会编译错误；
标记为 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()}

这里有几个细节：

需要自定义 setter 或 getter 的属性，不能放在类头里定义，必须在类体内定义，要不然 Kotlin 怎么知道你自定义了哪个属性的 getter 和 setter 呢？所以这里我们把原本在类头里定义的 name 属性挪到了类体内定义，并使用传入的 String 类型参数初始化 name 属性，name 属性被自动推导为 String 类型；
getter 是一个没有参数、返回类型与属性类型相同的函数。完整的写法应该是这样的：
```
get(): 属性类型 {
  //……}
```
但是一般 getter 的方法比较短，而且可以自动推导类型，所以如果只有一句的话可以写成“get() = 函数语句”的形式。需要注意一点，不能在 getter 里再调用本属性，因为 Kotlin 代码里所有对属性的访问都会被编译为 getter 方法，这样写就会出现无限迭代和 StackOverFlowError
setter 的参数列表一般有一个与属性类型相同的参数，没有返回值。
Kotlin 中一般用 value 表示这个参数，当然也可以用其他关键字；
这里的 field 是表示 幕后字段 的关键字，它在使用时相当于 this.name，但是只能用在 setter 方法内。

3. 类外属性

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

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

// 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 方法调用静态属性

编译期常量使用 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
```