Kotlin定义其他类的实现详解

目录

• 1.嵌套类
• 2.数据类
• 3.定义数据类的必须满足的条件
• 4.解构声明
• 5.枚举类enum class
• 6.运算符重载

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)

到此这篇关于Kotlin定义其他类的实现详解的文章就介绍到这了,更多相关Kotlin定义其他类内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！