一、類的定義和屬性的getter姚垃、setter方法

1.類的定義使用class關鍵字
2.類中的屬性默認實現了getter和setter方法(eg:Person中的age屬性),如果要修改類中屬性的getter和setter方法虱朵，參考Person類中name屬性
3.只有可變屬性才會有setting

class Person() {
    var age:Int=0
    var name: String = "unknow"
        get() = field.capitalize()
        set(value) {
            field = value.trim()
        }
}

二、構造函數

三碴犬、初始化順序

1.主構造函數聲明的屬性
2.類級別的屬性按聲明屬性依次賦值
3.init初始化代碼塊里的屬性賦值和函數調用
4.次構造函數里的屬性賦值和函數調用
注意：init代碼塊中用到的屬性需要再init代碼塊之前聲明服协，因為kotlin的編譯時自上而下的

class Student(_name:String,val age:Int){

    var name = _name
    var score = 10
    private val hobby="music"
    val subject:String
    init {
        println("initializing student")
        subject ="math"
    }

    constructor(_name:String):this(_name,10){
        score = 20
    }
}


//編譯成java代碼
 public Student(@NotNull String _name, int age) {
      Intrinsics.checkNotNullParameter(_name, "_name");
      super();
      //柱構造函數的屬性
      this.age = age;
//類級別的屬性賦值
      this.name = _name;
      this.score = 10;
      this.hobby = "music";
//init{}代碼塊
      String var3 = "initializing student";
      boolean var4 = false;
      System.out.println(var3);
//init代碼塊中的屬性賦值
      this.subject = "math";
   }

   public Student(@NotNull String _name) {
      Intrinsics.checkNotNullParameter(_name, "_name");
      this(_name, 10);
//次構造函數中的屬性賦值
      this.score = 20;
   }

在次構造函數Student(@NotNull String _name)中又調用了主構造函數this(_name, 10)

四偿荷、延遲初始化lateinit

1.lalteinit約定在使用該變量之前初始化
2.只要無法確認lateinit變量是否完成初始化，可以執(zhí)行isInitialized檢查

class Student(val age: Int) {
    lateinit var subject: String
    fun ready(){
        subject = "math"
    }

    fun battle(){
        if (::subject.isInitialized){
            println(subject)
        }
    }
}

五跳纳、惰性初始化 lazy

class Student(val name:String) {
    //屬性被調用的時候執(zhí)行
    private val subject:String by lazy{
        initSubject()
    }

    //調用構造函數的時候執(zhí)行
    private val subject2:String = initSubject()

    fun initSubject():String{
        Log.i("AAA","loading init subject")
        return "Math"
    }

}

六贪嫂、object關鍵字

1.定義一個靜態(tài)類
2.定義一個匿名類
3.定義一個伴生對象

七、嵌套類

在其他類中調用的時候如下

  fun testJunior(){
        val juniorStudent = Student.JuniorStudent("Jack")
    }

class Student(val name:String) {
    class JuniorStudent(val name:String)
}

八斗塘、數據類

1.數據類 是專門設計用來存儲數據的類
2.數據類提供了toString()的個性化實現
3.==符號默認情況下，比較對象就是比較他們的引用值
4于置、copy函數調用的是主構造函數，在次構造函數中賦值的屬性值實際并沒有賦值八毯，需要主動賦值

data class Teacher(val name:String)

轉義為Java代碼如下瞄桨，默認實現了toString()、equals()讲婚、hashCode()、copy()方法,同時實現了component1()用于結構語法

public final class Teacher {
   @NotNull
   private final String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public Teacher(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      super();
      this.name = name;
   }

   @NotNull
   public final String component1() {
      return this.name;
   }

   @NotNull
   public final Teacher copy(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      return new Teacher(name);
   }

   // $FF: synthetic method
   public static Teacher copy$default(Teacher var0, String var1, int var2, Object var3) {
      if ((var2 & 1) != 0) {
         var1 = var0.name;
      }

      return var0.copy(var1);
   }

   @NotNull
   public String toString() {
      return "Teacher(name=" + this.name + ")";
   }

   public int hashCode() {
      String var10000 = this.name;
      return var10000 != null ? var10000.hashCode() : 0;
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof Teacher) {
            Teacher var2 = (Teacher)var1;
            if (Intrinsics.areEqual(this.name, var2.name)) {
               return true;
            }
         }

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

九活合、結構聲明

1.數據類直接支持結構語法

fun main() {
    val (name, age, subject) = Teacher("Jack", 28, "Math")
    println("$name--$age--$subject")
}

class Teacher(private val name: String, private val age: Int, private val subject: String) {
    operator fun component1() = name
    operator fun component2() = age
    operator fun component3() = subject
}

十白指、枚舉類 emun class

enum class LicenseStatus(){
    UnQualified,
    Learning,
    Qualified;
    var licenseId:String=""
}

十一、密封類 sealed class

密封類可以定義一個類似于枚舉類的ADT,可以有若干個子類告嘲，要繼承密封類奖地，這些子類必須和它定義在用一個文件中。相對枚舉類参歹，密封類可以更加靈活的控制子類的特殊性。

sealed class LicenseStatus{
    object UnQualified:LicenseStatus()
    object Learning:LicenseStatus()
//特殊屬性 licenseId
    class Qualified(val licenseId:String):LicenseStatus()
}

十二僧界、接口

interface OnItemClickListener {
    fun onItemClick(view: View)
}

十三、抽象類abstract

abstract class Human(val age:Int){
    abstract fun eat()
}
class American(val name:String, age:Int):Human(age) {
    override fun eat() {
        Log.i("AAA","I have hamburger")
    }
}