Kotlin中属性与字段的示例分析

这篇文章主要介绍了Kotlin中属性与字段的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

创新互联专注于郎溪企业网站建设,成都响应式网站建设公司,商城网站建设。郎溪网站建设公司,为郎溪等地区提供建站服务。全流程定制开发，专业设计，全程项目跟踪，创新互联专业和态度为您提供的服务

一、概述
  前面已经为大家讲解了类的使用以及属性的相关知识，在一个类中基本上都会出现属性和字段的，属性在变量和常量的文章中有详细讲解到，这里会重新简单介绍到。

1.1 声明属性
Java 类中的变量声明为成员变量，而 Kotlin 中声明为属性，Kotlin 类中的属性可以使用 var 关键字声明为可变，也可以使用 val 关键字声明为只读。类中的属性必须初始化值，否则会报错。

class Person {
    val id: String = "0" //不可变，值为0
    var nameA: String? = "Android" //可变，允许为null
    var age: Int = 22 //可变，非空类型
}

前面有提到 Kotlin 能有效解决空指针问题，实际上定义类型时增加了可空和非空的标志区分，如上面声明的类型后面有?表示属性可为空，类型后面没有有?表示属性不可为空。如 name: String? 中 name 可以为 null，age: Int 中 age 不可为 null。在使用时，编译器会根据属性是否可为空做出判断，告知开发者是否需要处理，从而避免空指针异常。

Kotlin 中使用类中的属性和 Java 中的一样，通过类名来引用：

    var person = Person()//实例化person，在Kotlin中没有new关键字
    view1.text = person.id //调用属性

实际上上面定义的属性是不完整的，在 Java 中的属性定义还会涉及到 get() 和 set() 方法，那么在 Kotlin 怎么表示呢？

二、Getter()与Setter()
Kotlin 中 getter() 对应 Java 中的 get() 函数，setter() 对应 Java 中的 set() 函数，不过注意这仅仅是 Kotlin 的叫法而已，真正的写法还是 get() 和 set()。

2.1 完整语法
在 Kotlin 中普通类中一般不提供 get() 和 set() 函数，因为普通的类中基本用不到，这点和 Java 相同，但是 Java 在定义纯粹的数据类时，会用到 get() 和 set() 函数，但是 Kotlin 这种情况定义了数据类，已经为我们实现了 get() 和 set() 函数。

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

var [: ] [= ]
    []
    []

这是官方的标准语法，我们来翻译一下：

var <属性名> : <属性类型> = 初始化值
    
    

其中，初始化器(property_initializer)，getter 和 setter 都是可选的，如果可以从初始化器(或者 getter 返回类型)推断出属性的类型，那么属性类型(PropertyType)是可选的，如下所示：

//var weight: Int?//报错,需要初始化,默认getter和setter方法是隐藏的

var height = 172 //根据初始化值推断类型为Int,属性类型可以不需要显示，默认实现了getter和setter方法

只读属性声明与可变属性声明不同，它是 val 开始而不是 var，不允许设置 setter 函数，因为它只是只读。

val type: Int?//类型为Int，必需初始化,默认实现了getter方法

val cat = 10//类型为Int,默认实现getter方法

init {//初始化属性，也可以在构造函数中初始化
    type = 0
}

Kotlin 中属性的 getter 和 setter 函数是可以省略的，系统有默认实现，如下：

class Person {        
    //用var修饰时，必须为其赋初始化值，即使有getter()也必须初始化，不过获取的数值是getter()返回的值
    var name: String? = "Android"
        get() = field //默认实现方式，可省略
        set(value) { //默认实现方式，可省略
            field = value //value是setter()方法参数值，field是属性本身
        }
}

其中，field 表示属性本身，后端变量，下面会详细讲到，value 是 set() 的参数值，也可以修改你喜欢的名称。set(value){field = value} 的意思是 set() 方法将设置的参数 value 赋值给属性 field，上面的 getetter() 与 setter() 均为默认实现方式，可以省略。

2.2 自定义
上面的属性我们都省略了 getter 和 setter 方法。我们可以为属性定义访问器，自定义 getetter() 与 setter() 可以根据自身的实际情况来制定方法值的规则。好比如 Java 中自定义 get() 和 set() 方法。

（1）val 修饰的属性的 getter() 函数自定义

如果定义一个自定义 getter，那么 getter() 方法会在属性每次被访问时调用，下面是自定义 getter 的例子：

    //用val修饰时，用getter()函数属性指定其他值时可以不赋默认值，但是不能有setter()函数，等价 val id: String = "0"
    val id: String 
        get() = "0"   //为属性定义get方法

如果属性的类型可以从 getter 方法中推断出来，那么类型可以省略：

class Person {
    //color根据条件返回值
    val color = 0
        get() = if (field > 0) 100 else -1  //定义get方法
    
    //isEmpty属性是判断 color是否等于0
    val isEmpty get() = this.color == 0 //Boolean类型，getter方法中推断出来,可省
}

    //调用
    var person = Person()
    Log.e(TAG, "get()和set(): color == ${person.color} | isEmpty == ${person.isEmpty}")

color 默认为0，get() 的数据为-1，isEmpty 为 false，打印数据如下：

get()和set(): color == -1 | isEmpty == false
1
（2）var 修饰的属性的 getter() 和 setter() 函数自定义

自定义一个setter，将在每次为属性赋值的时候被调用，如下：

class Person {
    var hair: String = ""
        get() = field //定义get方法
        set(value) {//定义set方法
            field = if (value.isNotEmpty()) value else "" //如果为不为空则返回其值，否则返回""
        }

    var nose: String = ""
        get() = "Kotlin"//值一直是Kotlin，不会改变
        set(value) {
            field = if (value.isNotEmpty()) value else "" //如果为不为空则返回其值，否则返回""
        }
}

    var person = Person()
    person.hair = "Android"
    person.nose = "Android"
    Log.e(TAG, "get()和set(): hair == ${person.hair} | nose == ${person.nose}")

nose 中的 getter() 函数值已经固定了，不会再改变，打印数据如下：

get()和set(): hair == Android | nose == Kotlin
1
总结一下：
1.使用了 val 修饰的属性不能有 setter() 方法；
2.属性默认实现了 getter() 和 setter() 方法，如果不重写则可以省略。

2.3 可见性
如果你需要改变访问器的可见性或者注释它，但不需要改变默认实现，你可以定义访问器而不定义它的主体：

class Person {
    val tea: Int = 0
        //private set  报错，val修饰的属性不能有setter

    var soup: String = "Java"
        //@Inject set   用Inject注解去实现setter()

    var dish: String = "Android"
        //private get   报错，不能有getter()访问器的可见性

    var meal = "Kotlin"
        private set   //setter访问器私有化，并且它拥有kotlin的默认实现
}

    var person = Person()
    //person.meal = "HelloWord"    报错，setter已经声明为私有，不能重新赋值

如果属性访问器的可见性修改为 private 或者该属性直接使用 private 修饰时，只能手动提供一个公有的函数去改其属性，类似 Java 中的 Bean.setXXX()。

三、后备字段与属性
3.1 后备字段（Backing Fields）
后备字段相对 Java 来说是一种新的定义，不能在 Kotlin 类中直接声明字段，但是当属性需要后备字段时，Kotlin 有后端变量机制（Backing Fields）会自动提供，可以在访问器中使用后备字段标识符 field 来引用此字段，即 Kotlin 中的后备字段用 field 来表示。

为什么提供后备字段？

class Person {
    var name: String = ""
        get() = "HelloWord"//值一直是Kotlin，不会改变
}

    var person = Person()
    person.name = "HelloUniverse"
    Log.e(TAG, "后备字段: goose == ${person.name}")

注意，我们明明通过 person.name= "HelloUniverse" 赋值，但是打印的依然是默认的 “HelloWord” 值，打印数据如下：

后备字段: name == HelloUniverse
1
上面的问题显而易见，因为我们定义了 Person 中的 name 的 getter() 方法，每次读取 name 的值都会执行 get，而 get 只是返回了 “HelloWord”，那么是不是直接用 name 替换掉 “HelloWord” 就可以了呢？我们来改造一下：

class Person {
    var name: String = ""
        //get() = "HelloWord" 
        get() = name //为name定义了get方法，这里返回name
}

    var person = Person()
    person.name = "HelloUniverse"
    Log.e(TAG, "后备字段: name == ${person.name}")

那么上面代码执行后打印什么？ “HelloUniverse”？ 正确答案：不是。上面的写法是错误的，在运行时会造成无限递归，直到java.lang.StackOverflowError栈溢出异常，为什么？

因为在我们获取 person.name 这个值的时候，都会调用 get() 方法，而 get()方法访问了name 属性(即 return name)，这又会去调用 name 属性的 get() 方法，如此反复直到栈溢出。同样，set() 方法也是如此，通过自定义改变 name 的值：

 class Person {
    var name: String = ""
        set(value) {//为name定义了set方法
            name = value//为name赋值一个新值，即value
        }
}

    var person = Person()
    person.name = "HelloUniverse"
    Log.e(TAG, "后备字段: name == ${person.name}")

同理：上面的代码会抛出栈溢出异常，因为 name = value 会无限触发 name 的 set() 方法。

那么我们怎么在自定义属性的get和set方法的时候在外部修改其值呢？

这就是后备字段的作用了，通过 field 可以有效解决上面的问题，代码如下：

    var name: String? = "" //注意：初始化器直接分配后备字段
        get() = field//直接返回field
        set(value) {
            field = value//直接将value赋值给field
        }

    var person = Person()
    person.name = "HelloUniverse"
    Log.e(TAG, "后备字段: name == ${person.name}")

打印数据如下：

后备字段: name == HelloUniverse
1
如果属性至少使用一个访问器的默认实现，或者自定义访问器通过 field 标识符引用该属性，则将生成该属性支持的字段。也就是说只有使用了默认的 getter() 或 setter() 以及显示使用 field 字段的时候，后备字段 field 才会存在。下面这段代码就不存在后备字段：

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

这里定义了 get() 方法，但是没有通过后备字段 field 去引用。

注意：后备字段 field 只能用于属性的访问器。

3.2 后备属性（Backing Properties）
如果你想做一些不适合后备字段来操作的事情，那么你可以使用后备属性来操作：

    private var _table: Map? = null//后备属性
    public val table: Map
        get() {
            if (_table == null) {
                _table = HashMap()//初始化
            }
            //如果_table不为空则返回_table，否则抛出异常
            return _table ?: throw AssertionError("Set to null by another thread")
        }

_table 属性是私有的 private，我们不能直接使用，所以提供一个公有的后备属性 table 去初始化 _table 属性。这和 Java 定义 bean 属性的方式是一样的，因为访问私有属性的 get() 和 set() 方法，会被编译器优化成直接访问其实际字段，不会引入函数调用的开销。

四、编译时常量
所谓编译时常量，就是在编译时就能确定值的常量。

4.1 编译时常量与运行时常量的区别
与编译时常量对应的还有运行时常量，在运行时才能确定值，编译时无法确定其值，并放入运行常量池中。针对运行时常量，编译器只能确定其他代码段无法对其进行修改赋值。关于二者的区别，看下 Java 代码：

    private static final String mark = "HelloWord";
    private static final String mark2 = String.valueOf("HelloWord");

定义了两个常量：mark 和 mark2，那么你觉得他们有区别吗？大部分人认为没啥区别，都是常量。但是实际上是不一样的，来看看它们的字节码：

private final static Ljava/lang/String; mark = "HelloWord"
private final static Ljava/lang/String; mark2

我们发现，编译后的 mark 直接赋值了 “HelloWord”，而 mark2 却没有赋值，实际上 mark2 在类构造方法初始化的时候才进行赋值，也就是运行时才进行赋值。这就是编译时常量（mark）和运行时常量 （mark2）的区别！

4.2 编译时常量
在 Kotlin 中，编译时常量使用 const 修饰符修饰，它必须满足以下要求：

必须属于顶层Top-level，或对象声明或伴生对象的成员；
被基本数据类型或者String类型修饰的初始化变量；
没有自定义 getter() 方法；
只有 val 修饰的才能用 const 修饰。
//顶层top-level
const val CONST_STR = "" //正确，属于top-level级别的成员
//const val CONST_USER = User() //错误，const只能修饰基本类型以及String类型的值，Point是对象

class Person {
    //const val CONST_TYPE_A = 0  //编译错误，这里没有违背只能使用val修饰，但是这里的属性不属于top-level级别的，也不属于object里面的

    object Instance { //这里的Instance使用了object关键字修饰，表示Instance是个单例，Kotlin其实已经为我们内置了单例，无需向 Java那样手写单例
        //const var CONST_TYPE_B = 0 //编译错误，var修饰的变量无法使用const修饰
        const val CONST_TYPE_C = 0 //正确，属于object类
    }
}

这些属性还可以在注释中使用：

const val CONST_DEPRECATED: String = "This subsystem is deprecated"
@Deprecated(CONST_DEPRECATED) fun foo() {
    //TODO
}

这里基本包括了 const 的应用场景。但是有人会问，Kotlin 既然提供了 val 修饰符为什么还要提供 const 修饰符？ 按理来说 val 已经可以表示常量了，为什么提供 const ？

4.3 const 与 val 的区别
下面代码属于 Kotlin 代码，顶层的常量位于位于 kotlin 文件 Person.kt 中，属于 top-level 级别：

const val NAME = "HelloWord"
val age = 20

class Person {
}

下面这段代码是 Java 代码，用于测试，建立一个类，在 main 函数数据：

public class ConstCompare {
    public static void main(String[] args) {
        //注意下面两种的调用方式
        System.out.println(PersonKt.NAME);//这里注意：kotlin文件会默认生成kotlin文件名+Kt的java类文件
        System.out.println(PersonKt.getAge());

        //编译报错，PersonKt.age的调用方式是错误的
        //System.out.println(PersonKt.age);
    }
}

上面的代码证明了 const 修饰的字段和 val 修饰的字段的区别：使用 const 修饰的字段可以直接使用 类名+字段名来调用，类似于 Java 的 private static final 修饰，而 val 修饰的字段只能用get方法的形式调用。

那么 const 的作用仅仅是为了标识公有静态字段？

不是，实际是 const 修饰字段 NAME 才会变成公有字段（即public），这是 Kotlin 的实现机制，但不是因为 const 才产生的 static 变量，我们来查看 Person 类的字节码：

//PersonKt是 Kotlin 生成与之对应 的 Java 类文件
public final class com/suming/kotlindemo/blog/PersonKt {
  //注意下面两个字段 NAME 和 age 的字节码
  
  // access flags 0x19
  //Kotlin实际上为 NAME 生成了public final static修饰的 Java 字段
  public final static Ljava/lang/String; NAME = "HelloWord"
  @Lorg/jetbrains/annotations/NotNull;() // invisible

  // access flags 0x1A
  //Kotlin 实际上为 age 生成了private final static修饰的 Java 字段
  private final static I age = 20
    
  //注意：这里生成getAge()的方法
  // access flags 0x19
  public final static getAge()I
   L0
    LINENUMBER 14 L0
    GETSTATIC com/suming/kotlindemo/blog/PersonKt.age : I
    IRETURN
   L1
    MAXSTACK = 1
    MAXLOCALS = 0

  // access flags 0x8
  static ()V  //Kotlin生成静态构造方法
   L0
    LINENUMBER 14 L0
    BIPUSH 20
    PUTSTATIC com/suming/kotlindemo/blog/PersonKt.age : I
    RETURN
    MAXSTACK = 1
    MAXLOCALS = 0
  // compiled from: Person.kt
}

从上面的字节码中可以看出：

1.Kotlin为 NAME 和 age 两个字段都生成了 final static 标识，只不过NAME 是 public 的，age 是 private 的，所以可以通过类名来直接访问 NAME 而不能通过类名访问 age ；
2.Kotlin 为 age 生成了一个 public final static 修饰的 getAge() 方法，所以可以通过 getAge() 来访问 age 。
总之， const val 与 val 的总结如下：
const val与 val 都会生成对应 Java 的static final修饰的字段，而 const val 会以 public 修饰，而 val 会以 private 修饰。同时，编译器还会为 val 字段生成 get 方法，以便外部访问。

注意：通过 Android studio >Tools > Kotlin > Show Kotlin ByteCode 来查看字节码。

五、延迟初始化的属性和变量
  通常，声明为非空类型的属性必须（在构造函数中）初始化。然而，这通常很不方便。例如：在单元测试中，一般在setUp方法中初始化属性；在依赖注入框架时，只需要使用到定义的字段不需要立刻初始化等。

在这种情况下，不能在构造函数中提供一个非空初始化器，但是希望在引用类体中的属性时避免null检查。kotlin 针对这种场景设计了延迟初始化的机制，你可以使用 lateinit 修饰符来标记属性，延迟初始化，即不必立即进行初始化，也不必在构造方法中初始化，可以在后面某个适合的实际初始化。使用 lateinit 关键字修饰的变量需要满足以下几点：

不能修饰 val 类型的变量；
不能声明于可空变量，即类型后面加?，如String?；
修饰后，该变量必须在使用前初始化，否则会抛 UninitializedPropertyAccessException 异常；
不能修饰基本数据类型变量，例如：Int，Float，Double 等数据类型，String 类型是可以的；
不需额外进行空判断处理，访问时如果该属性还没初始化，则会抛出空指针异常；
只能修饰位于class body中的属性，不能修饰位于构造方法中的属性。
public class MyTest {
    lateinit var subject: TestSubject //非空类型

    @SetUp fun setup() {
        subject = TestSubject()//初始化TestSubject
    }

    @Test fun test() {
        subject.method()  //构造方法调用
    }
}

lateinit 修饰符可以用于类主体内声明的 var 属性（不在主构造函数中，并且只有当属性没有自定义getter和setter时才用）。自 Kotlin 1.2以来，可以用于顶级属性和局部变量。属性或变量的类型必须是非空的，而且不能是原始类型。在 lateinit 修饰的属性被初始化之前访问它会抛出异常，该异常清楚地标识被访问的属性以及没有被初始化的事实。

自 Kotlin 1.2以来，可以检查lateinit 修饰的变量是否被初始化，在属性引用使用 this::变量名.isInitialized，this可省：

    lateinit var person: Person //lateinit 表示延迟初始化，必须是非空

    fun method() {
        person = Person()
        if (this::person.isInitialized) {//如果已经赋值返回true，否则返回false
            //TODO
        }
        Log.e(TAG, "延迟初始化: person.isInitialized == ${::person.isInitialized}")
    }

打印数据如下：

延迟初始化: person.isInitialized == true
1
注意：这种检查只能对词法上可访问的属性可用，例如：在相同类型或外部类型声明的属性，或在同一个文件的顶层声明的属性。但是不能用于内联函数，为了避免二进制兼容性问题。

感谢你能够认真阅读完这篇文章，希望小编分享的“Kotlin中属性与字段的示例分析”这篇文章对大家有帮助，同时也希望大家多多支持创新互联，关注创新互联行业资讯频道，更多相关知识等着你来学习!