Kotlin 中的类和构造方法

橙子19911016

已于 2024-03-28 11:17:34 修改

阅读量1.2k

点赞数 16

文章标签： kotlin 微信开发语言

于 2024-03-27 17:35:04 首次发布

本文链接：https://blog.csdn.net/xingyu19911016/article/details/136868803

版权

Kotlin 中的类与接口和 Java 中的类与接口还是有区别的。例如，Koltin 中的接口可以包含属性声明，与 Java 不同的是。Kotlin 的声明默认是 final 和 public 的。此外，嵌套的类默认并不是内部类：它们并没有包含对其它外部类的隐式引用。

1 Kotlin 中的类以及接口

对象是什么？任何可以描述的事物都可以看作对象。我们以鸟为例，来分析它的组成：

形状、颜色等可以看作是鸟的静态属性；
年龄、大小等可以看作是鸟的动态属性；
飞行、进食等可以看作是鸟的行为；

1.1 Kotlin 中的类

对象是由状态和行为组成的，我们可以通过它描述一个事物。 下面就是用 Kotlin 来抽象一个 Bird 类：

class Bird {
    val weight: Double = 500.0
    val color: String = "blue"
    val age: Int = 1

    fun fly() { // 全局可见
    }
}

在 Kotlin 中我们仍然可以使用熟悉的 class 结构体来声明一个类。

但是，Kotlin 中的类和 Java 中的类也有很多不同，将 Kotlin 代码反编译成 Java 版本：

public final class Bird {
   private final double weight = 500.0;
   @NotNull
   private final String color = "blue";
   private final int age = 1;

   public final double getWeight() {
      return this.weight;
   }

   @NotNull
   public final String getColor() {
      return this.color;
   }

   public final int getAge() {
      return this.age;
   }

   public final void fly() {
   }
}

可以看出主要存在以下不同：

不可变属性成员：Kotlin 支持用 val 在类中声明引用不可变的属性成员，这是利用 Java 中的 final 修饰符来实现的，使用 var 声明的属性则反之引用可变；
默认属性值：因为 Java 中的属性都是默认值，比如 int 类型的默认值为 0，引用类型的默认值为 null，所以在声明属性的时候我们不需要指定默认值。而在 Kotlin 中，除非显式地声明延迟初始化，不然就需要指定属性的默认值；
不同的可访问修饰符：Kotlin 类中的成员默认是全局可见的，而 Java 的默认可见域是包作用域，因此在 Java 的版本中，我们必须采用 public 修饰才能达到相同的效果；

1.2 可带有属性和默认方法的接口

下面我们继续来看看 Kotlin 和 Java 中接口的差异。

以下是 Java 8 版本的接口：

public interface Flyer {
    public String kind();

    default public void fly(){
        System.out.println("I can fly");
    }
}

Java 8 引入了一个新特性 —— 接口方法支持默认实现。这使得我们在向接口中新增方法的时候，之前继承过该接口的类则可以不需要实现这个新方法。

Kotlin 的接口与 Java 8 中的相似：它们可以包含抽象方法的定义以及非抽象方法的实现（与 Java 8 中的默认方法类似），但它们不能包含任何状态。

接下来看在 Kotlin 中如何声明一个接口：

interface Flyer {
    val speed: Int
    fun kind()
    fun fly() {
        println("I can fly")
    }
}

同样，我们也可以用 Kotlin 定义一个带有方法实现的接口。同时，它还支持抽象属性（如上面的 speed）。然而，Kotlin 是基于 Java 6 的，那么它是如何支持这种行为的呢？

我们将上面的 Kotlin 声明的接口转换为 Java 代码，提取其中关键的代码：

public interface Flyer {
   int getSpeed();

   void kind();

   void fly();

   @Metadata(
      mv = {1, 8, 0},
      k = 3
   )
   public static final class DefaultImpls {
      public static void fly(@NotNull Flyer $this) {
         String var1 = "I can fly";
         System.out.println(var1);
      }
   }
}

通过以上的代码可以知道，Kotlin 编译器是通过定义了一个静态内部类 DefaultImpls 来提供 fly 方法的默认实现的。同时，虽然 Kotlin 接口支持属性声明，然而它在 Java 源码中是通过 get 方法来实现的。在接口中的属性并不能像 Java 接口那样，被直接赋值一个常量。 如以下这样做是错误的：

interface Flyer {
    val height = 1000 // error Property initializers are not allowed in interfaces
}

Kotlin 提供了另外一种方式来实现这种效果：

interface Flyer {
    val height
        get() = 1000
}

这种写法与 Kotlin 实现该机制的背景有关。Kotlin 接口中的属性背后其实是用方法来实现的。所以说如果我们要为变量赋值常量，那么就需要编译器原生就支持方法默认实现。但 Kotlin 是基于 Java 6 的，当时并不支持这种特性，所以我们并不能像 Java 那样给一个接口的属性直接赋值一个常量。

下面我们来看如何在 Kotlin 接口中定义一个普通属性：

interface Flyer {
    val height: Long
}

它同方法一样，若没有指定默认行为，则在实现该接口的类中必须对该属性进行初始化。

接下来看如何使用这个接口：

class Brid(override val speed: Int) : Flyer {
    override fun kind() {
        TODO("Not yet implemented")
    }
}

Kotlin 类名后面使用冒号来代替了 Java 中的 extends 和 implements 关键字。和 Java 一样，一个类后面可以实现任意接口，但是只能继承一个类。

另外，和 Java 中的 @Override 注解类似，override 修饰符用来标注被重写的父类或者接口的方法和属性。与 Java 不同的是，在 Kotlin 中使用 override 修饰符是强制要求的。这会避免先写出实现方法再添加抽象方法造成的意外重写：我们的代码将不能编译，除非我们显式地将这个方法标注为 override 或者重命名它。

总体来说，Kotlin 的类与接口的声明和 Java 很类似，但它的语法整体上要显得更加简洁。

2 更简洁地构造类的对象

Kotlin 中并没有 new 关键字，我们可以通过以下的代码来直接声明一个类的对象：

val bird = Bird()

当前没有给 Bird 传入任何参数。现实中，很有可能因为需要传入不同的参数组合，而在类中创建多个构造方法，在 Java 中这是利用构造方法重载来实现的。

public class Bird {
    private double weight;
    private int age;
    private String color;

    public Bird(double weight, int age, String color) {
        this.weight = weight;
        this.age = age;
        this.color = color;
    }

    public Bird(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public Bird(double weight) {
        this.weight = weight;
    }
  
  	...
}

Java 中的这种方式存在两个缺点：

如果要支持任意参数组合来创建对象，那么需要实现的构造方法将非常多；
每个构造方法中的代码会存在冗余，如前两个构造方法都对 age 和 color 进行了相同的赋值操作；

Kotlin 通过引入新的构造语法来解决这些问题。

2.1 构造方法默认参数

要解决构造方法过多的问题，似乎也很简单。在 Kotlin 中我们可以给构造方法的参数指定默认值，从而避免不必要的方法重载。 现在用 Kotlin 来改写上述的例子：

class Bird(val weight: Double = 0.00, val age: Int = 0, val color: String = "blue")

使用：

val bird = Bird(color = "black")
val bird2 = Bird(weight = 1000.00, color = "black")

需要注意的是，由于参数默认值的存在，我们在创建一个类对象时，最好指定参数的名称，否则必须按照实际的参数的顺序进行赋值。否则会出现以下错误：

类型不匹配

我们在 Bird 类中可以用 val 或者 var 来声明构造方法的参数。这一方面代表了参数的引用可变性，另一方面它也使得我们在构造类的语法上得到了简化。

为什么这么说呢？事实上，构造方法的参数名前当然可以没有 val 或者 var，然而带上它们之后就等价于在 Bird 类内部声明了一个同名的属性，我们可以用 this 来进行调用。

以下是 Bird 类反编译成 Java 代码：

public final class Bird {
   private final double weight;
   private final int age;
   @NotNull
   private final String color;

   public final double getWeight() {
      return this.weight;
   }

   public final int getAge() {
      return this.age;
   }

   @NotNull
   public final String getColor() {
      return this.color;
   }

   public Bird(double weight, int age, @NotNull String color) {
      Intrinsics.checkNotNullParameter(color, "color");
      super();
      this.weight = weight;
      this.age = age;
      this.color = color;
   }

   // $FF: synthetic method
   public Bird(double var1, int var3, String var4, int var5, DefaultConstructorMarker var6) {
      if ((var5 & 1) != 0) {
         var1 = 0.0;
      }

      if ((var5 & 2) != 0) {
         var3 = 0;
      }

      if ((var5 & 4) != 0) {
         var4 = "blue";
      }

      this(var1, var3, var4);
   }

   public Bird() {
      this(0.0, 0, (String)null, 7, (DefaultConstructorMarker)null);
   }
}

2.2 init 语句块

Kotlin 引入了一种叫做 init 语法块的语法，它属于上述构造方法的一部分，两者在表现形式上确是分离的。

Bird 类的构造方法在类的外部，它只能对参数进行复制。如果我们需要在初始化时进行其他的额外操作，那么我就可以使用 init 语句块来执行。比如：

class Bird(weight: Double, age: Int, color: String) {
    init {
        println("do some other things")
        println("the weight is ${weight}")
    }
}

反编译成 Java 代码：

public final class Bird {
   public Bird(double weight, int age, @NotNull String color) {
      Intrinsics.checkNotNullParameter(color, "color");
      super();
      String var5 = "do some other things";
      System.out.println(var5);
      var5 = "the weight is " + weight;
      System.out.println(var5);
   }
}

当没有使用 val 或者 var 的时候，构造方法的参数可以在 init 语句块中被直接调用。其实它们还可以用于初始化内部的属性成员的情况。 如：

class Bird(weight: Double = 0.00, age: Int = 0, color: String = "blue") {
    val weight: Double = weight // 在初始化属性成员时调用 weight
    val age: Int = age
    val color: String = color
}

反编译成 Java 代码：

public final class Bird {
   private final double weight;
   private final int age;
   @NotNull
   private final String color;

   public final double getWeight() {
      return this.weight;
   }

   public final int getAge() {
      return this.age;
   }

   @NotNull
   public final String getColor() {
      return this.color;
   }

   public Bird(double weight, int age, @NotNull String color) {
      Intrinsics.checkNotNullParameter(color, "color");
      super();
      this.weight = weight;
      this.age = age;
      this.color = color;
   }

   // $FF: synthetic method
   public Bird(double var1, int var3, String var4, int var5, DefaultConstructorMarker var6) {
      if ((var5 & 1) != 0) {
         var1 = 0.0;
      }

      if ((var5 & 2) != 0) {
         var3 = 0;
      }

      if ((var5 & 4) != 0) {
         var4 = "blue";
      }

      this(var1, var3, var4);
   }

   public Bird() {
      this(0.0, 0, (String)null, 7, (DefaultConstructorMarker)null);
   }
}

除此之外，我们并不能在其他地方使用。以下是一个错误的用法：

错误用法

事实上，我们的构造方法还可以拥有多个 init，它们会在对象被创建时按照类中从上到下的顺序先后执行。看看以下代码的执行结果：

class Bird(weight: Double, age: Int, color: String) {
    val weight: Double
    val age: Int
    val color: String

    init {
        this.weight = weight
        println("The bird's weight is ${this.weight}")
        this.age = age
        println("The bird's age is ${this.age}")
    }

    init {
        this.color = color
        println("The bird's color is ${this.color}")
    }
}

fun main() {
    val bird = Bird(1000.0, 2, "blue")
}


// The bird's weight is 1000.0
// The bird's age is 2
// The bird's color is blue

可以发现，多个 init 语句块有利于我们进一步对初始化的操作进行职能分离，这在复杂的业务开发（如 Android）中显得特别有用。

再来思考一种场景，现实中我们在创建一个类对象时，很可能不需要对所有的属性都进行传值。其中存在一些特殊的属性，比如鸟的性别，我们可以根据它的颜色来进行区分，所以它并不需要出现在构造方法的参数列表中。

有了 init 语句块的语法支持，我们很容易实现这一点。假设黄色的鸟儿都是雌性，剩余的都是雄鸟，我们就可以如此设计：

class Bird(val weight: Double, val age: Int, val color: String) {
    val sex: String

    init {
        this.sex = if (this.color == "yellow") "male" else "female"
    }
}

接下来继续修改需求。这一次我们并不想在 init 语句块中对 sex 直接赋值，而是调用一个专门的 printSex 方法来进行，如：

错误信息

报错了，主要由以下两个原因导致：

正常情况下，Kotlin 规定类中的所有非抽象属性成员都必须在对象创建时被初始化值；
由于 sex 必须被初始化值，上述的 printSex 方法中，sex 会被视为二次赋值，这对 val 声明的变量来说也是不允许的；

第 2 个问题比较容易解决，我们把 sex 变成用 var 声明，它就可以被重复修改。关于第 1 个问题，最直观的方法就是指定 sex 的默认值，但这可能是一种错误的性别含义；另一种方法是引用可空类型，即把 sex 声明为 String? 类型，则它的默认值为 null。这可以让程序正确运行，然而实际上也许我们又不想让 sex 具有可空性，而只是想稍后再进行赋值，所以这种方案也有局限性。

2.3 延迟初始化：by lazy 和 lateinit

更好的做法是让 sex 能够延迟初始化，即它可以不用在类对象初始化的时候就必须有值。 在 Kotlin 中，我们主要是使用 lateinit 和 by lazy 这两种语法来实现延迟初始化的效果。

下面来看如何使用它们？如果这是一个用 val 声明的变量，我们可以用 by lazy 来修饰：

class Bird(val weight: Double, val age: Int, val color: String) {
    val sex: String by lazy {
        if (color == "yellow") "male" else "female"
    }
}

by lazy 的语法特点如下所示：

该变量必须是引用不可变的，而不能用 var 来声明；
在被首次调用时，才会进行赋值操作。一旦被赋值，后续它将不能被更改；

lazy 背后是接受一个 lambda 并返回一个 Lazy<T> 实例的函数，第一次访问该属性的时候，会执行 lazy 对应的 Lambda 表达式并记录结果，后续访问该属性时只是返回记录的结果。

另外，系统会给 lazy 属性默认加上同步锁，也就是 LazyThreadSafetyMode.SYNCHRONIZED，它在同一时刻只允许一个线程对 lazy 属性进行初始化，所以它是线程安全的。但是如果能确认该属性可以并行执行，没有线程安全问题，那么可以给 lazy 传递 LazyThreadSafetyMode.PUBLICATION 参数。我们还可以给 lazy 传递 LazyThreadSafetyMode.NONE 参数，这将不会有任何线程方面的开销，当然也不会有任何线程安全的保证。比如：

val sex: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
    // 并行模式
    if (color == "yellow") "male" else "female"
}

val sex: String by lazy(LazyThreadSafetyMode.NONE) {
    // 不做任何线程保证也不会有任何线程开销
    if (color == "yellow") "male" else "female"
}

与 lazy 不同，lateinit 主要用于 var 声明的变量，然而它不能用于基本数据类型，如 Int、Long 等，我们需要用 Integer 这种包装类作为替代：

class Bird(val weight: Double, val age: Int, val color: String) {
    lateinit var sex: String // sex 可以延迟初始化

    fun printSex() {
        this.sex = if (this.color == "yellow") "male" else "female"
        println(this.sex)
    }
}

fun main() {
    val bird = Bird(1000.0, 2, "blue")
    bird.printSex()
}

// female

那么是如何让用 var 声明的基本数据类型变量也具有延迟初始化的效果，一种可参考的解决方案是通过 Delegates.notNull<T>，这是利用 Kotlin 中委托的语法来实现的。

var test by Delegates.notNull<Int>()

fun doSomething() {
    test = 1
    println("test value is $test")
    test = 2
}

总而言之，Kotlin 并不主张用 Java 中的构造方法来重载，来解决多个构造参数组合调用问题。取而代之的方案是利用构造参数默认值及用 val、var 来声明构造参数的语法，以便更简洁地构造一个类对象。

3 主从构造方法

有些时候，我们可能需要从一个特殊的数据中获取构造类的参数值，这时候如果可以定义一个额外的构造方法，接收一个自定义的参数会显得特别方便。

同样以鸟为例，先把之前的 Bird 类简化为：

class Bird(age: Int) {
    val age: Int

    init {
        this.age = age
    }
}

假设当前我们知道鸟的生日，希望可以通过生日来得到鸟的年龄，然后创建一个 Bird 类对象。如何实现？

第 1 种方案是在别处定义一个工厂方法，如：

fun Bird(birth: Date) = Bird(getAgeByBirth(birth))

应该在哪里声明这个工厂方法呢？这种方式的缺点在于，Bird 方法与 Bird 类的代码层面的分离显得不够直观。

另外，我们还可以像 Java 那样新增一个构造方法来解决这个问题。其实，Kotlin 也支持多构造方法的语法，然而与 Java 的区别在于，它在多构造方法之间建立了“主从”的关系。

我们下面来用 Kotlin 中的多构造方法实现这个例子：

class Bird(age: Int) {
    val age: Int

    init {
        this.age = age
    }

    constructor(birth: Date) : this(getAgeByBirth(birth)) {
       ... 
    }
}

下面来看看这个新的构造方法是如何运作的：

通过 constructor 方法定义了一个新的构造方法，它被称为从构造方法。相应地，我们熟悉的在类外部定义的构造方法被称为主构造方法；
- 每个类可最多存在一个主构造方法和多个从构造方法，如果主构造方法存在注解或可见性修饰符，也必须像从构造方法一样加上 constructor 关键字：internal public Bird @inject constructor(age: Int) { }
每个从构造方法由两部分组成。一部分是对其他构造方法委托，另一部分是由花括号包裹的代码块。执行顺序上会先执行委托的方法，然后执行自身代码块的逻辑。

通过 this 关键字来调用要委托的构造方法。如果一个类存在主构造方法，那么每个从构造方法都要直接或者间接的委托给它。比如，可以把从构造方法 A 委托给从构造方法 B，再将从构造方法 B 委托给主构造方法。举个例子：

class Bird(age: Int) {
    val age: Int

    init {
        this.age = age
    }

    constructor(timestamp: Long) : this(DateTime(timestamp)) // 构造函数 A
    constructor(birth: DateTime) : this(getAgeByByBirth(birth)) // 构造函数 B

    fun getAgeByByBirth(birth: DateTime): Int {
        return Year.yearsBetween(birth, DateTime.now()).years
    }

}

其实，从构造方法的设计除了解决我们以上的场景之外，还有一个很大的作用就是可以对某些 Java 类库进行很好的扩展，因为我们经常要基于第三方 Java 库中的类，扩展自定义的构造方法。典型的例子就是定制业务中特殊的 View 类。

比如以下代码：

class KotlinView : View {
    constructor(context: Context) : this(context, null)
    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(
        context,
        attrs,
        defStyleAttr
    )

}