Kotlin定义其他类的实现详解

2024-04-02 19:04:59 907人浏览独家记忆

摘要

目录1.嵌套类2.数据类3.定义数据类的必须满足的条件4.解构声明5.枚举类enum class6.运算符重载1.嵌套类如果一个类只对另外一个类有作用，那么可以将其嵌入到该类中，使

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)
}