Kotlin学习系列——类属性和字段(Properties/Fields)

痛定思痛。 2023-06-25 10:24 62阅读 0赞

官方文档: [http://kotlinlang.org/docs/reference/properties.html][http_kotlinlang.org_docs_reference_properties.html]

## 1.声明类属性 ##

类属性可用关键字var声明为可变的, val声明为只读:
        class Address {
            var name: String = ...
            var street: String = ...
            var city: String =  ...         
        }
    
    使用类属性,和使用Java类字段(成员变量)差不多:
        fun copyAddress(address: Address): Address {
            val result = Address() // Kotlin没有new关键字
            result.name = address.name
            result.street = address.street       
            return result
        }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14

## 2.属性访问器Getters和Setters ##

声明属性的完整语法:
        var <propertyName>[: <PropertyType>] [= <initializer>]
            [<getter>]
            [<setter>]
    其中初始器<initializer>、<getter>和<setter>都是可选的!
    如果属性类型:<PropertyType>可从初始器(或者从getter返回值)推断出,也可省略!
    
    1.默认访问器get和set方法   
        var i = 1 // 推断类型Int、默认getter和setter
        val c = 1 // 推断类型Int 、默认getter
    
    2.自定义访问器get和set方法
        val isEmpty: Boolean
            get() = this.size == 0   
    
        var stringRepresentation: String
            get() = this.toString()
            set(value) {
                calxx(value) //按惯例,setter参数名是value,但也可自定义！
            }
    
        val isEmpty get() = this.size == 0  // 如能推断出属性类型,则可省略
    
    
    3.改变访问器get和set可见性或者对其注解,但不改变默认实现:
        var setterVisibility: String = "abc"
            private set //私有,不改变默认实现
    
        var setterWithAnnotation: Any? = null
            @Inject set //注解,不改变默认实现
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29

**实例：**  
以下实例定义了一个 Person 类，包含两个可变变量 lastName 和 no，lastName 修改了 getter 方法，no 修改了 setter 方法。

class Person { 
    
        var lastName: String = "zhang"
            get() = field.toUpperCase()   // 将变量赋值后转换为大写
            set
    
        var no: Int = 100
            get() = field                // 后端变量
            set(value) { 
                if (value < 10) {        // 如果传入的值小于 10 返回该值
                    field = value
                } else { 
                    field = -1         // 如果传入的值大于等于 10 返回 -1
                }
            }
    
        var heiht: Float = 145.4f
            private set
    }
    
    // 测试
    fun main(args: Array<String>) { 
        var person: Person = Person()
    
        person.lastName = "wang"
    
        println("lastName:${ person.lastName}")
    
        person.no = 9
        println("no:${ person.no}")
    
        person.no = 20
        println("no:${ person.no}")
    
    }

输出结果为：

lastName:WANG
    no:9
    no:-1

## 3.幕后字段和属性 ##

1.隐式幕后字段
    Kotlin类不能有字段,但有时在自定义的访问器中需要字段,
    为此自动提供隐式幕后字段(backing field),可field标识符访问,
    field只能用在属性的访问器中.
        var counter = 0 //初始值直接写入到幕后字段
            set(value) {
                if (value >= 0)
                field = value
            }
    
    2.显式幕后属性
    如果隐式幕后字段不符合需求,可用显式幕后属性(backing property)
        private var _table: Map<String, Int>? = null //幕后属性
        public val table: Map<String, Int>
            get() {
                if (_table == null) {
                    _table = HashMap() //类型参数已推断出
                }
                return _table ?: throw AssertionError("Set to null by another thread")
            }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20

通过默认getter和setter访问私有属性会被优化,不会引入函数调用开销!

## 4.属性的初始化 ##

1.编译期常量
    属性用const修饰符标记,称为编译期常量Compile-Time Constants,需满足以下要求:
        位于顶层或者是object的成员
        用 String 或原生类型初始化
        没有自定义getter
    
    const val DE: String = "This subsystem is deprecated"
    //编译期常量属性可用在注解中
    @Deprecated(DE) fun foo(){        
    }
    
    2.延迟初始化属性
    一般情况,属性声明为非空类型,必须在构造函数中初始化。
    然而这不方便,为此可用lateinit修饰符非空属性:
        public class MyTest {
            lateinit var subject: TestSubject
    
            @SetUp fun setup() {
                subject = TestSubject()
            }
    
            @Test fun test() {
                subject.method()  // 直接解引用
            }
        }
    lateinit只能用在类体中的var属性,
    该属性不能自定义getter和setter方法,
    该属性必须是非空类型,不能是原生类型
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28

阅读：  
[https://www.runoob.com/kotlin/kotlin-class-object.html][https_www.runoob.com_kotlin_kotlin-class-object.html]  
1、field 关键字

这个问题对 Java 开发者来说十分难以理解，网上有很多人讨论这个问题，但大多数都是互相抄，说不出个所以然来，要说还是老外对这个问题的理解比较透彻，可以参考这个帖子：[https://stackoverflow.com/questions/43220140/whats-kotlin-backing-field-for/43220314][https_stackoverflow.com_questions_43220140_whats-kotlin-backing-field-for_43220314]

其中最关键的一句：**Remember in kotlin whenever you write foo.bar = value it will be translated into a setter call instead of a PUTFIELD.**

也就是说，在 Kotlin 中，任何时候当你写出“一个变量后边加等于号”这种形式的时候，比如我们定义 var no: Int 变量，当你写出 no = … 这种形式的时候，这个等于号都会被编译器翻译成调用 setter 方法；而同样，在任何位置引用变量时，只要出现 no 变量的地方都会被编译器翻译成 getter 方法。那么问题就来了，当你在 setter 方法内部写出 no = … 时，相当于在 setter 方法中调用 setter 方法，形成递归，进而形成死循环，例如文中的例子：

var no: Int = 100
        get() = field                // 后端变量
        set(value) { 
            if (value < 10) {        // 如果传入的值小于 10 返回该值
                field = value
            } else { 
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

这段代码按以上这种写法是正确的，因为使用了 field 关键字，但是如果不用 field 关键字会怎么样呢？例如：

var no: Int = 100
        get() = no
        set(value) { 
            if (value < 10) {        // 如果传入的值小于 10 返回该值
                no = value
            } else { 
                no = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

注意这里我们使用的 Java 的思维写了 getter 和 setter 方法，那么这时，如果将这段代码翻译成 Java 代码会是怎么样呢？如下：

int no = 100;
    public int getNo() { 
        return getNo();// Kotlin中的get() = no语句中出来了变量no，直接被编译器理解成“调用getter方法”
    }
    
    public void setNo(int value) { 
        if (value < 10) { 
            setNo(value);// Kotlin中出现“no =”这样的字样，直接被编译器理解成“这里要调用setter方法”
        } else { 
            setNo(-1);// 在setter方法中调用setter方法，这是不正确的
        }
    }

翻译成 Java 代码之后就很直观了，在 getter 方法和 setter 方法中都形成了递归调用，显然是不正确的，最终程序会出现内存溢出而异常终止。

[http_kotlinlang.org_docs_reference_properties.html]: http://kotlinlang.org/docs/reference/properties.html
[https_www.runoob.com_kotlin_kotlin-class-object.html]: https://www.runoob.com/kotlin/kotlin-class-object.html
[https_stackoverflow.com_questions_43220140_whats-kotlin-backing-field-for_43220314]: https://stackoverflow.com/questions/43220140/whats-kotlin-backing-field-for/43220314