【Kotlin】详解数据类

创建数据类

上节我们了解的数据类的创建，复习一下也就是通过 data class来定义一个类，然后添加对应的属性即可，我们还是以 Student 为例

data class Student(var age:Int,var height:Double,val sex:String)

这里的代码就不做多解释了，我们都知道 Kotlin 也是 基于 jvm 的语言，那么我们看下 Kotlin 的代码编译成的 Java 代码是什么样

反编译

通过 IDEA 的 Kotlin 插件，转换为字节码，然后再转换为 Java 代码，如图

生成的字节码如下，之后点击Decompile 按钮，即可生成 Java 代码：

转换后的代码：

public final class Student {
   private int age;
   private double height;
   @NotNull
   private final String sex;

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

   public final void setAge(int var1) {
      this.age = var1;
   }

   public final double getHeight() {
      return this.height;
   }

   public final void setHeight(double var1) {
      this.height = var1;
   }

   @NotNull
   public final String getSex() {
      return this.sex;
   }

   public Student(int age, double height, @NotNull String sex) {
      Intrinsics.checkNotNullParameter(sex, "sex");
      super();
      this.age = age;
      this.height = height;
      this.sex = sex;
   }

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

   public final double component2() {
      return this.height;
   }

   @NotNull
   public final String component3() {
      return this.sex;
   }

   @NotNull
   public final Student copy(int age, double height, @NotNull String sex) {
      Intrinsics.checkNotNullParameter(sex, "sex");
      return new Student(age, height, sex);
   }

   // $FF: synthetic method
   public static Student copy$default(Student var0, int var1, double var2, String var4, int var5, Object var6) {
      if ((var5 & 1) != 0) {
         var1 = var0.age;
      }

      if ((var5 & 2) != 0) {
         var2 = var0.height;
      }

      if ((var5 & 4) != 0) {
         var4 = var0.sex;
      }

      return var0.copy(var1, var2, var4);
   }

   @NotNull
   public String toString() {
      return "Student(age=" + this.age + ", height=" + this.height + ", sex=" + this.sex + ")";
   }

   public int hashCode() {
      int var10000 = (Integer.hashCode(this.age) * 31 + Double.hashCode(this.height)) * 31;
      String var10001 = this.sex;
      return var10000 + (var10001 != null ? var10001.hashCode() : 0);
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof Student) {
            Student var2 = (Student)var1;
            if (this.age == var2.age && Double.compare(this.height, var2.height) == 0 && Intrinsics.areEqual(this.sex, var2.sex)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}

和我们之前了解到的差不多，和 JavaBean 一样，有 getter/setter 方法。重写了 equals/hashCode/toString 方法，同样有构造函数。看 equals 方法的定义，我们可以知道，通过 data class 创建的对象，也是可以通过 == 来判断对象是否相等。

fun main() {
    val student:Student = Student(12,145.00,"female")
    val student2:Student = Student(12,145.00,"female")

    println("equals ： ${student.equals(student2)}")
    println("== : ${student == student2}")
}

===========
equals ： true
== : true

仔细观察我们还会发现有几个方法，在我们定义 JavaBean 的时候是没有遇到的copy/component1/component2…componentN

copy 方法

我们先看 copy：

   @NotNull
   public final Student copy(int age, double height, @NotNull String sex) {
      Intrinsics.checkNotNullParameter(sex, "sex");
      return new Student(age, height, sex);
   }

   // $FF: synthetic method
   public static Student copy$default(Student var0, int var1, double var2, String var4, int var5, Object var6) {
      if ((var5 & 1) != 0) {
         var1 = var0.age;
      }

      if ((var5 & 2) != 0) {
         var2 = var0.height;
      }

      if ((var5 & 4) != 0) {
         var4 = var0.sex;
      }

      return var0.copy(var1, var2, var4);
   }

通过代码我们发现，这两个方法中 copy 方法是根据传进来的参数创建新的 Student 对象，从方法名来看也就是复制了一个对象，而copy$default方法复制的是传进来的 student 的属性（如果对应的属性没有设值）。这么做有什么好处呢？我们在 Java 中如果想要复制一个对象会这样写

Student s1 = new Student(12,145.0,"female");
Student s2 = s1;
s2.setAge(15);

这里的修改 s2，会导致 s1 的 age 也变了，因为他们的引用的地址是同一个。

如果是复制后创建一个新的对象是这样的

Student s1 = new Student(12,145.0,"female");
Student s2 = new Studetn(s1.getAge(),s2..getHeight(),s1.getSex());
s2.setAge(15);

在 Kotlin 中使用 copy 方法却不会修改 s1 的属性。

val s1:Student = Student(12,145.00,"female")
val s2 = s1.copy()
s2.age = 15
println("s1 is : ${s1}   s2 is : ${s2}")

输出 ======
s1 is : Student(age=12, height=145.0, sex=female)   s2 is : Student(age=15, height=145.0, sex=female)

同样的，因为 copy 函数也是可以传递参数的，我们也可以这么写

val s1:Student = Student(12,145.00,"female")
val s2 = s1.copy(sex = "male")
s2.age = 15
println("s1 is : ${s1}   s2 is : ${s2}")

输出====
s1 is : Student(age=12, height=145.0, sex=female)   s2 is : Student(age=15, height=145.0, sex=male)

componentN

接着看下 component 代码：

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

   public final double component2() {
      return this.height;
   }

   @NotNull
   public final String component3() {
      return this.sex;
   }

可以看出，这边都是 Student 对象的属性值，而且是按照顺序编号的，所以 componentN 中的 N 也就是有多少个属性参数就会到几。这么做有什么用呢？我们简单想一下，在 Java 中我们拿出对象的值是不是如下操作：

Student student = new Student(12,145.0,"female");
int age = student.getAge();
double height = student.getHeight();
String sex = student.getSex();

在 Kotlin 中我们常规操作是不是这样：

val student = Student(12,145.00,"female")
val age = student.age
val height = student.height
val sex = student.sex

println("age : $age, height : $height, sex : $sex")

但是在在 Kotlin 的代码中，还有一种更简单的方式

val student = Student(12,145.00,"female")
val (age,height,sex) = student

println("age : $age, height : $height, sex : $sex")

这就是 Kotlin 的解构，而解构就依赖 componentN 方法。除了IDEA 自动生成的 component 方法外，我们也可以自己写 component 方法例如：

data class Student(var age: Int, var height: Double, val sex: String){
    var name:String = "" //新增 name 属性

    constructor(age: Int,height: Double,sex: String,name:String):this(age,height, sex){
        this.name = name //name 属性赋值
    }

    operator fun component4():String{ //使用 operator 修饰
        return this.name
    }
}

我们的使用方式如下：

    val student: Student = Student(12, 145.00, "female","lihua")
    val (age, height, sex, name) = student //解构增加 name 属性
    println("age : $age, height : $height, sex : $sex , name : $name")