class Computer {
    class Mouse(val name:String){
        fun showDescribe(){
            println("mouse name is $name")
        }
    }
}
fun main() {
    val mouse = Computer.Mouse("Logitech")
    //可以通過嵌套類的實例，訪問其定義的屬性和函數(shù)
    mouse.showDescribe()
    println(mouse.name)
}

2.數(shù)據(jù)類

顧名思義，數(shù)據(jù)類是專門用來存儲數(shù)據(jù)的。

1）數(shù)據(jù)類的聲明，通過在class前加data修飾，就可以將一個普通類定義為一個數(shù)據(jù)類。

2）數(shù)據(jù)類提供了toString，equals和hashCode的自定義實現(xiàn)。

3）==默認比較的是對象的引用。但是==用來比較數(shù)據(jù)類，比較的是他們的內容。

4）數(shù)據(jù)類默認支持解構。因為kotlin編譯器實現(xiàn)了解構聲明。

//用data關鍵字修飾class，就可以定義一個數(shù)據(jù)類
data class MotionEvent(var x: Int, var y: Int) {
}
fun main() {
    //打印數(shù)據(jù)類對象，默認會調用toString方法。
    val e1 = MotionEvent(10, 10)
    val e2 = MotionEvent(10, 10)
    println(e1)
    println(e1.toString())
    //數(shù)據(jù)類的==是判斷的equals方法，比較的是內容，而不是對象引用。
    println(e1 == e2)
    //數(shù)據(jù)類支持解構
    val (x, y) = e1
    println("$x,$y")
}

打印結果:

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

通過反編，看下kotlin對數(shù)據(jù)類的默認實現(xiàn)。

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;
   }
    //默認實現(xiàn)了toString
   public String toString() {
      return "MotionEvent(x=" + this.x + ", y=" + this.y + ")";
   }
    //默認實現(xiàn)了hashCode
    public int hashCode() {
      return Integer.hashCode(this.x) * 31 + Integer.hashCode(this.y);
   }
   //默認實現(xiàn)了equals方法，比較的是兩個對象數(shù)據(jù)的值。
   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.定義數(shù)據(jù)類的必須滿足的條件

1）數(shù)據(jù)類必須至少有一個參數(shù)的主構造函數(shù)。

2）數(shù)據(jù)類的主構造函數(shù)定義的參數(shù)必須是val或var修飾。

3）數(shù)據(jù)類用data關鍵字修飾，但是不能使用abstract、open、sealed、inner修飾。

4.解構聲明

解構聲明的實現(xiàn)原理，就是聲明Component1、Component2等若干個組件函數(shù)，讓每個函數(shù)返回一個熟悉數(shù)據(jù)。如果定義的是一個數(shù)據(jù)類，kotlin編譯器會自動為每個屬性聲明Component函數(shù)。

自定義解構聲明：

通過operator fun component1() 。從定義可以看出來解構聲明，是一種特殊的函數(shù)。

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