Kotlin定义其他类的实现详解

1.嵌套类

如果一个类只对另外一个类有作用，那么可以将其嵌入到该类中，使两个类在一起。和Java中定义的内部类很像。

class Computer {
   class Mouse(val name:String){
       fun showDescribe(){
           println("mouse name is $name")
       }
   }
}
fun main() {
   val mouse = Computer.Mouse("Logitech")
   //可以通过嵌套类的实例，访问其定义的属性和函数
   mouse.showDescribe()
   println(mouse.name)
}

2.数据类

顾名思义，数据类是专门用来存储数据的。

1）数据类的声明，通过在class前加data修饰，就可以将一个普通类定义为一个数据类。

2）数据类提供了toString，equals和hashCode的自定义实现。

3）==默认比较的是对象的引用。但是==用来比较数据类，比较的是他们的内容。

4）数据类默认支持解构。因为kotlin编译器实现了解构声明。

//用data关键字修饰class，就可以定义一个数据类
data class MotionEvent(var x: Int, var y: Int) {
}
fun main() {
   //打印数据类对象，默认会调用toString方法。
   val e1 = MotionEvent(10, 10)
   val e2 = MotionEvent(10, 10)
   println(e1)
   println(e1.toString())
   //数据类的==是判断的equals方法，比较的是内容，而不是对象引用。
   println(e1 == e2)
   //数据类支持解构
   val (x, y) = e1
   println("$x,$y")
}

打印结果:

10
MotionEvent(x=10, y=10)
MotionEvent(x=10, y=10)
true
10,10

通过反编，看下kotlin对数据类的默认实现。

public final class MotionEvent {
  private int x;
  private int y;
  public final int getX() {
     return this.x;
  }
  public final void setX(int var1) {
     this.x = var1;
  }
  public final int getY() {
     return this.y;
  }
  public final void setY(int var1) {
     this.y = var1;
  }
  public MotionEvent(int x, int y) {
     this.x = x;
     this.y = y;
  }
  //解构声明
  public final int component1() {
     return this.x;
  }
  //解构声明
  public final int component2() {
     return this.y;
  }
   //默认实现了toString
  public String toString() {
     return "MotionEvent(x=" + this.x + ", y=" + this.y + ")";
  }
   //默认实现了hashCode
   public int hashCode() {
     return Integer.hashCode(this.x) * 31 + Integer.hashCode(this.y);
  }
  //默认实现了equals方法，比较的是两个对象数据的值。
  public boolean equals(@Nullable Object var1) {
     if (this != var1) {
        if (var1 instanceof MotionEvent) {
           MotionEvent var2 = (MotionEvent)var1;
           if (this.x == var2.x && this.y == var2.y) {
              return true;
           }
        }
        return false;
     } else {
        return true;
     }
  }
}

3.定义数据类的必须满足的条件

1）数据类必须至少有一个参数的主构造函数。

2）数据类的主构造函数定义的参数必须是val或var修饰。

3）数据类用data关键字修饰，但是不能使用abstract、open、sealed、inner修饰。

4.解构声明

解构声明的实现原理，就是声明Component1、Component2等若干个组件函数，让每个函数返回一个熟悉数据。如果定义的是一个数据类，kotlin编译器会自动为每个属性声明Component函数。

自定 * 构声明：

通过operator fun component1() 。从定义可以看出来解构声明，是一种特殊的函数。

class Student(val name: String,val age:Int){
   operator fun component1() = name
   operator fun component2() = age
}
fun main() {
   val student = Student("HanMei",18)
   val (name: String, age: kotlin.Int) = student
   println("$name,$age")
}

5.枚举类enum class

其实枚举就是一个类，kotlin定义的枚举用enum class，来强调枚举也是一个类。而java中只用enum修饰，就可以定义一个类。所以，在java中，枚举是一个类的概念就不太深入。

enum class Week() {
   SUNDAY,
   MONDAY,
   TUESDAY,
   WEDNESDAY,
   THURSDAY,
   FRIDAY,
   SATURDAY;
   fun getDay(): String {
       return when (this) {
           SUNDAY -> "星期天"
           MONDAY -> "星期一"
           TUESDAY -> "星期二"
           WEDNESDAY -> "星期三"
           THURSDAY -> "星期四"
           FRIDAY -> "星期五"
           SATURDAY -> "星期六"
       }
   }
}
fun main() {
   println(Week.SUNDAY)
   println(Week.SUNDAY.getDay())
}

6.运算符重载

可以通过operator fun plus 对“+”运算符进行重载。

data class MotionEvent(var x: Int, var y: Int) {
   operator fun plus(e1: MotionEvent) = MotionEvent(x + e1.x, y + e1.y)
}
fun main() {
   val e1 = MotionEvent(10, 10)
   val e2 = MotionEvent(10, 10)
   println(e1+e2)
}

打印结果：
MotionEvent(x=20, y=20)

来源：https://blog.csdn.net/niuyongzhi/article/details/126632526