秒懂Kotlin之彻底弄懂属性(Property)Part1

阅读量：352 次

发布时间：2019-03-04

本文共 5709 字，大约阅读时间需要 19 分钟。

[版权申明] 非商业目的注明出处可自由转载
博文地址: https://blog.csdn.net/ShuSheng0007/article/details/109049970
出自：shusheng007

系列文章：

AD: 认准公众号《华北01学会》，带你装逼带你飞！——ShuSheng007

文章目录

俺默认你会Java

概述

接触过Kotlin的都知道，其增加了属性的语法（Properties），多年前我就在C#中见过了。可以说Kotlin把属性玩出了花，初识kotlin时不容易完全掌握，而属性又是在日常编程时大量使用的，所以我们应该彻底掌握这一利器，看完本文，相信你会对属性做到胸有成竹。

如何声明

要掌握一个知识，首先要能熟练的使用它。属性其实是kotlin的又一颗语法糖，对应Java的setter与getter方法，但又有些许不同。

最复杂的声明

完整的属性声明语法如下

var 
   <属性名称>
    [: 
    <属性类型>
     ] [= 
     <属性初始化器>
      ]    [
      
       ]    [
       
        ]

其中，初始化器、getter、setter都是可以省略的。我们来为Student类声明一个age属性，如下所示

class Student {    var age: Int = 18        set(value) {            if (value > 100) {                println("老而不死是为妖")            } else {                field = value            }        }        get() {            return field + 1        }        ...}

上面代码声明了一个可变属性age，初始化为18，当被赋值大于100时不合法，当获取年龄时返回当前值加1。

有几点注意的地方，set中的value可以随便命名，但推荐使用value。field是kotlin的一个关键字，代表编译器帮助生成的那个private字段。

我们来看看其对应的Java代码：

public final class Student{	private int age=18;    public final int getAge() {      return this.age + 1;   }   public final void setAge(int value) {      if (value > 100) {         String var2 = "老而不死是为妖";         System.out.println(var2);      } else {         this.age = value;      }   }}

是不是有似曾相识的感觉，就是个语法糖，实际上是使用字段加方法实现的。其中private int age 对应的就是kotlin中的field，back field 不一定每次都产生，因为其对我们是透明的，所以我们不用关心它，用的时候就在setter或者getter方法中使用field引用即可。

最简单的声明

上面那个是最复杂的属性声明，我们大部分时间用不上，平时都是用最简单的版本。

var gender: String = "人妖"

是不是感觉就像在Java中声明了一个public字段啊，其实编译器还是做了很多工作的，它为我们生成了默认的setter与getter方法，如下所示：

//Java @NotNull private String gender = "人妖";  @NotNull public final String getGender() {    return this.gender; } public final void setGender(@NotNull String var1) {    ...    this.gender = var1; }

省略初始化器的情形：

上面的例子中，在声明属性时都必须提供初始化器，就是那个为属性赋值的操作，那么什么情况下可以不用为属性赋初始值呢？如下几个情形初始化器就可以省略。

使用lateinit关键字声明的属性
```
lateinit var studyResult: String
```
但是要求在使用此属性前必须要完成初始化，不然会抛运行时异常。

在类的主构造函数中声明的属性

class Student (val clothes: String)

其初始化会在构造函数中完成，是对应的Java代码如下

@NotNullprivate final String clothes;public Student(@NotNull String clothes) {      ...      this.clothes = clothes;}@NotNullpublic final String getClothes() {  return this.clothes;}

最开始接触Kotlin时我对这个语法时还是比较懵逼的，会将其与参数不带val 版本混淆。

class Student (clothes: String)

上面代码的clothes仅仅是Student构造函数传入的一个参数，只能在init块中使用，相当于Java的构造函数{}。

class Student (clothes: String){    lateinit var studyResult: String    init {        studyResult = clothes    } }

只有getter方法的属性

val height: Int       get() {           return 180       }

Private属性

kotlin属性默认都是public的，如果你把属性声明为Private的话，那它就真的成为一个私有字段了，编译器不会产生任何额外代码

//kotlinprivate val _name: String = "ben"private var _name: String = "ben"//javaprivate final String _name="ben";private String _name="ben";

顶级属性

我们知道，在Java中一切都要基于类。像字段，方法都必须包含在类里面，但是Kotlin却允许将属性、方法、类直接写在文件当中。那么类里面的属性与文件中的属性有什么异同呢？

由于Kotlin/JVM最终是要编译成Java字节码的，所以它的这些属性其实也可以看做是语法糖。kotlin编译器会以 文件名称加上Kt后缀为类名生成一个新类，而其中的属性相应的会成为此类的成员，与直接写在类里面的属性不同的是他们都是static的。

例如一个叫KotlinFile文件，内容如下：一个属性，一个常量

package top.ss007.learn.kotlin.classesvar topProperty: String = ""    set(value) {        field = value    }    get() {        return "hello property"    }const val CONST="I AM A CONSTANT"

其对应的Java代码为

public final class KotlinFileKt {   @NotNull   private static String topProperty = "";   @NotNull   public static final String CONST = "I AM A CONSTANT";   @NotNull   public static final String getTopProperty() {      return "hello property";   }   public static final void setTopProperty(@NotNull String value) {      Intrinsics.checkNotNullParameter(value, "value");      topProperty = value;   }}

可以看到，kotlin编译器帮助生成了一个新类KotlinFileKt，属性相关的生成字段与方法都属于此类，而且是static的。

Override 属性

这个就比较颠覆Java程序员的认知了，在Java中字段是不支持override的。

例如我们有如代码

//javapublic class JAnimal {    public int weight = 100;}public class JDog extends JAnimal {    public int weight = 200;}//调用JAnimal animal = new JDog();System.out.println(String.format("The weight of Java animal is %d", animal.weight));

上面的代码执行后会输出什么呢？是100还是200呢？

输出结果：

The weight of Java animal is 100

输出结果是Animal类中字段的值100，可见Java不支持字段的override。所以上面是非常糟糕的代码，我们一定要避免在子类中定义与父类相同名称的字段。

同为JVM语言，那为什么Kotlin就可以呢？这其实又是一颗语法糖，实际上override的是属性的getter和setter方法，而不是生成的那个字段。

让我们看一下代码：

父类Animal和子类Dog中分别有两个签名一模一样的属性，只读属性weight与可变属性name，当name被设置时会打印一句log。

open class Animal {    open val weight: Int = 100    open var name: String = "animal"        set(value) {            field = value            println("Animal被设置为$value")        }}class Dog : Animal() {    override val weight: Int = 200    override var name: String = "dog"        set(value) {            field = value            println("Dog被设置为$value")        }}class Cat(override var weight: Int) : Animal() {}

注意父类Animal属性前面的open以及子类Dog属性前面的override

执行验证结果：

fun runPropertyDemo() {    val animal: Animal = Dog()        //如果weight被override了就会输出Dog里的值200，否则输出Animal里的值100    println("The weight of specific animal  is ${animal.weight}")    println("The name of dog is ${animal.name}")    //如果name被override了就会调用Dog里面的setter方法，否则调用Animal里的    animal.name = "藏獒"    println("The name of dog is ${animal.name}")}

输出结果：

The weight of specific animal  is 200The name of dog is dogDog被设置为藏獒The name of dog is 藏獒

从结果可以看出，在kotlin中属性确实被override了。其背后的原理我们已经讨论过了，就是因为编译器会为Dog与Aninmal产生签名一样的方法，最终转换为方法的重写了。

public class Animal {   private final int weight = 100;   public int getWeight() {      return this.weight;   }   ...}public final class Dog extends Animal {   private final int weight = 200;   public int getWeight() {      return this.weight;   }}

看看上面转换后的Java代码，就差给getWeight()方法加上一个@override注解了。