官方文檔: http://kotlinlang.org/docs/reference/classes.html

1.定義類

和java一樣，Kotlin 中使用關鍵字 class 聲明/定義類
    class MyClass(param: type) {
    }
類聲明由類名、類頭(主構造函數參數)和類體構成, 類頭和類體都是可選的    
如果沒有類體，可以省略花括號:
    class MyClass

2.構造函數

1.主構造函數

在 Kotlin 中的一個類可以有一個主構造函數、多個次構造函數！
主構造函數是類頭的一部分，由類名(可選參數)構成
    class Person constructor(name: String) {
    }

1.省略 constructor 關鍵字
    如果主構造函數沒有注解或者可見性修飾符(public/private等)，可以省略 constructor 關鍵字
    class Person(name: String) {
    }
    如果構造函數有注解或可見性修飾符，必需要 constructor 關鍵字:
    class Person public @Inject constructor(name: String) {
    }

2.主構造函數的初始化代碼可放到 init 初始化塊中：
    class Person(name: String) {
        init {
            // 主構造函數參數可以在初始化塊中使用
            logger.info("value: ${name}")
        }
        // 主構造函數參數也可以在屬性初始化器中使用
        val key = name.toUpperCase()
    }

3.在主構造函數中聲明類屬性(類成員變量/字段)以及初始化屬性：
    class Person(val firstName: String, val lastName: String, var age: Int) {
    }
    與普通變量一樣，主構造函數中聲明的類屬性可以是可變(var)或只讀(val)

2.次構造函數

在類體中也可以聲明前綴有 constructor 的次構造函數:
    class Person {
        constructor(parent: Person) {
            parent.children.add(this)
        }
    }
    
1.如果類有一個主構造函數，每個次構造函數需要委托給主構造函數，可以直接委托或者通過別的次構造函數間接委托
委托到同一個類的另一個構造函數用 this 關鍵字即可:
    class Person(val name: String) {
        constructor(name: String, parent: Person) : this(name) {
            parent.children.add(this)
        }
    }

2.如果非抽象類沒有聲明任何構造函數, 會自動生成無參數的主構造函數, 可見性是public
如果不想構造函數是public，需添加 private constructor：
    class DontCreateMe private constructor () {
    }

3.創建類的實例對象

和java不同，Kotlin沒有new關鍵字, 創建一個類的實例對象：
    val person = Person("lioil")    

3.繼承

1.定義

和java類似，在 Kotlin 中所有類都有一個共同的超類(基類/父類) Any
    class Example // 從 Any 隱式繼承
    Any 不是 java.lang.Objec, Any除了equals()、hashCode()和toString()外沒有其它任何成員!

1.聲明一個顯式超類(基類/父類):
open表示允許其它類繼承, 和Java中final相反, 默認情況下，Kotlin所有類都是final
    open class Base(p: Int)
    class Derived(p: Int) : Base(p)

2.初始化超類(基類/父類)的構造函數
如果類具有主構造函數，則用主構造函數的參數(并且必須)初始化基類構造函數
如果類沒有主構造函數，則每個次構造函數必須使用super關鍵字初始化基類型，或委托給另一構造函數
    class MyView : View {
        constructor(ctx: Context) : super(ctx)
        constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
    }

2.覆蓋父類方法

與Java不同，Kotlin需顯式標注可覆蓋的成員(open)和覆蓋后的成員(override)
    open class Base {
        open fun v() {} // 如果沒標注open, 則子類不允許定義相同名函數
        fun nv() {}
    }

    class Derived() : Base() {
        // 如果沒標注override, 則編譯器將會報錯            
        override fun v() {}  
    }
    
標記 override 相當于open，可在子類中覆蓋, 如果要禁止再次覆蓋，要final 關鍵字：
    open class AnotherDerived() : Base() {
        final override fun v() {}
    }

3.覆蓋父類屬性

覆蓋屬性與覆蓋方法類似,
在父類的屬性必須以 override 開頭，并且父子類必須具有兼容的類型
每個聲明的屬性可由具有初始化器的屬性或者具有getter方法的屬性覆蓋
    open class Foo {
        open val x: Int get { …… }
    }

    class Bar1 : Foo() {
        override val x: Int = ……
    }

可用var屬性覆蓋val屬性，但反之則不行,
因為val屬性本質是只聲明一個getter方法,而將其覆蓋為var,只是在子類中添加一個setter方法

可在主構造函數中使用 override 關鍵字覆蓋父類的屬性:
    interface Foo {
        val count: Int
    }

    class Bar1(override var count: Int) : Foo

4.覆蓋規則

在 Kotlin 中，實現繼承由下述規則規定：
如果類從直接超類繼承相同成員的多個實現,它必須覆蓋這個成員并提供其自己的實現:
    open class A {
        open fun f() { print("A") }
    }

    interface B {
        fun f() { print("B") } // 接口默認是open
    }

    class C() : A(), B {       
        override fun f() {
            super<A>.f() // 調用 A.f()
            super<B>.f() // 調用 B.f()
        }
    }

簡書: http://www.lxweimin.com/p/2f9554932f74
CSDN博客: http://blog.csdn.net/qq_32115439/article/details/73442373
GitHub博客：http://lioil.win/2017/06/18/Kotlin-classes.html
Coding博客：http://c.lioil.win/2017/06/18/Kotlin-classes.html