【Kotlin】Kotlin学习四-属性与字段

学而不思则罔，思而不学则殆

---

属性与字段

---

---

声明属性

Kotlin 类中的属性既可以用关键字 var 声明为可变的，也可以用关键字 val 声明为只读的。

class Address {
    var name: String = "Holmes, Sherlock"
    var street: String = "Baker"
    val city: String = "London"
    var state: String? = null
    var zip: String = "123456"
}

要使用一个属性，只要用名称引用它即可：

fun copyAddress(address: Address): Address {
    val result = Address() // Kotlin 中没有“new”关键字
    result.name = address.name // 将调用访问器
    result.street = address.street
    // ……
    return result
}

Getters 与 Setters

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

var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]

其初始器（initializer）、getter 和 setter 都是可选的。属性类型如果可以从初始器 （或者从其 getter 返回值，如下文所示）中推断出来，也可以省略。

class Address {
    val setterVisibility: String = "abc"
    var name: String = "abc"
}

定义一个val和var属性，都是默认实现了get和set方法，通过javap查看其实际的方法：

可以看出：

默认var ，有两个方法getxxx() 和setxxx(),默认是public final的
默认val , 只有一个方法getxxx(),默认是public final，没有setxxx()方法

一个只读属性的语法和一个可变的属性的语法有两方面的不同：

1、只读属性的用 val 开始代替 var
2、只读属性不允许 setter

我们可以为属性定义自定义的访问器。如果我们定义了一个自定义的 getter，那么每次访问该属性时都会调用它 （这让我们可以实现计算出的属性）。以下是一个自定义 getter 的示例：

class Address {
    var size = 0
    val isEmpty: Boolean
        get() = this.size == 0
}


fun main() {
    val address = Address()
    println(address.isEmpty) //true
    address.size = 9
    println(address.isEmpty) //false
}

如果我们定义了一个自定义的 setter，那么每次给属性赋值时都会调用它。一个自定义的setter 如下所示：

    var stringRepresentation: String
        get() = this.toString()
        set(value) {
            setDataFromString(value) // 解析字符串并赋值给其他属性
        }

    private fun setDataFromString(value: String) {
        println("setDataFromString=$value")
    }
    
    val address = Address()
    println(address.stringRepresentation)
    address.stringRepresentation = "zy"
    println(address.stringRepresentation)
//com.algorithm.Address@2503dbd3
//setDataFromString=zy
//com.algorithm.Address@2503dbd3

按照惯例，setter 参数的名称是 value ，但是如果你喜欢你可以选择一个不同的名称
自 Kotlin 1.1 起，如果可以从 getter 推断出属性类型，则可以省略它：

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

如果你需要改变一个访问器的可见性或者对其注解，但是不需要改变默认的实现， 你可以定义访问器而不定义其实现:

    var setterVisibility: String = "abc"
        private set // 此 setter 是私有的并且有默认实现

幕后字段

在 Kotlin 类中不能直接声明字段。然而，当一个属性需要一个幕后字段时，Kotlin 会自动提供。这个幕后字段可以使用 field 标识符在访问器中引用：

class Address {
    var counter = 0 // 注意：这个初始器直接为幕后字段赋值
        set(value) {
            if (value >= 0) field = value
        }
}

class类方法：

field就是幕后字段，field 标识符只能用在属性的访问器内。

    val address = Address()
    println(address.counter)
    address.counter = -1 //不會复制成功
    println(address.counter)
    address.counter = 10
    println(address.counter)

结果

0
0
10

如果属性至少一个访问器使用默认实现，或者自定义访问器通过 field 引用幕后字段，将会为该属性生成一个幕后字段。
例如，下面的情况下， 就没有幕后字段：

    val isEmpty: Boolean
        get() = this.counter == 0

幕后属性

如果你的需求不符合这套“隐式的幕后字段”方案，那么总可以使用 幕后属性（backingproperty）：

class Address {
    private var _table: Map<String, Int>? = null
    private var age = 18
    public val table: Map<String, Int>
        get() {
            if (_table == null) {
                println("init _table")
                _table = HashMap() // 类型参数已推断出
            }
            return _table ?: throw AssertionError("Set to null by another thread")
        }
}

对于 JVM 平台：通过默认 getter 和 setter 访问私有属性会被优化， 所以本例不会引入函数调用开销。

编译期常量

如果只读属性的值在编译期是已知的，那么可以使用 const 修饰符将其标记为编译期常量。这种属性需要满足以下要求：

• 位于顶层或者是 object 声明 或 companion object 的一个成员
• 以 String 或原生类型值初始化
• 没有自定义 getter

这些属性可以用在注解中：

class Address {
    object One {
        const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated One"
    }

    object Two {
        const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated Two"
    }

    companion object {
        const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated companion"
    }
}

可以看到object 可以构建多个,内部持有了静态不可变的INSTANCE一个引用。

通过【javap -v Address$One.class】可以看到，One对象是在静态代码块中被初始化的。

延迟初始化属性与变量

一般地，属性声明为非空类型必须在构造函数中初始化。 然而，这经常不方便。例如：属性可以通过依赖注入来初始化， 或者在单元测试的 setup 方法中初始化。 这种情况下，你不能在构造函数内提供一个非空初始器。 但你仍然想在类体中引用该属性时避免空检测。
为处理这种情况，你可以用 lateinit 修饰符标记该属性：

public class MyTest {
    lateinit var subject: TestSubject
    fun setup() {
        subject = TestSubject()
    }

    fun test() {
        subject.method() // 直接解引用
    }
}

class TestSubject {
    fun method() {
        println("TestSubject method")
    }
}

fun main() {
    val test = MyTest()
    test.setup()
    test.test()
}

该修饰符只能用于在类体中的属性（不是在主构造函数中声明的 var 属性，并且仅当该属性没有自定义 getter 或 setter 时），而自 Kotlin 1.2 起，也用于顶层属性与局部变量。该属性或变量必须为非空类型，并且不能是原生类型。

看一下字节码：

看不出什么差异，对于lateinit 修饰的变量。
在初始化前访问一个 lateinit 属性会抛出一个特定异常(UninitializedPropertyAccessException)，该异常明确标识该属性被访问及它没有初始化的事实。

Exception in thread "main" kotlin.UninitializedPropertyAccessException: lateinit property subject has not been initialized
	at com.algorithm.MyTest.test(TestOne.kt:10)
	at com.algorithm.TestOneKt.main(TestOne.kt:23)
	at com.algorithm.TestOneKt.main(TestOne.kt)

检测一个 lateinit var 是否已初始化（自 1.2 起）
要检测一个 lateinit var 是否已经初始化过，请在该属性的引用上使用 .isInitialized ：

    fun test() {
        if (this::subject.isInitialized) {
            subject.method() // 直接解引用
        }else{
            println("subject 未初始化")
        }
    }

subject 未初始化