一、类的定义和属性的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变量是否完成初始化，可以执行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) {
    //属性被调用的时候执行
    private val subject:String by lazy{
        initSubject()
    }

    //调用构造函数的时候执行
    private val subject2:String = initSubject()

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

}

六、object关键字

1.定义一个静态类
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")
    }
}

Kotlin中类的定义