類宣告

Kotlin使用class關鍵字宣告類：

class Foo {
}

宣告分為宣告頭和宣告體。其中宣告體是可選的，如下：

class Bar

建構函式

Kotlin建構函式分為主建構函式(primary constructor)和輔助建構函式(secondary constructor)。

主建構函式

主建構函式在類頭中，緊跟類名之後。如果不修改主建構函式的可見性也不為主建構函式添加註解，那麼constructor關鍵字是可選的。主建構函式不包含任何程式碼，但是主建構函式將會執行init關鍵字標記的程式碼塊。並且主建構函式的形參可以在init程式碼塊中訪問，並用於初始化類成員變數:

class Person(name: String) {
    init {
        this.name = name.toUpperCase()
    }
}

// 帶有可見性宣告或者是註解的主建構函式,contructor 關鍵字不能省略！！！
class Person private @Inject constructor(name: String) {
    // ...
}

我們甚至可以直接在主建構函式中宣告並初始化類屬性（能做的也僅止於此了~）。如下：

class Person(val firstName: String, val lastName: String, var age: Int) {
    // ...
 

}

輔助建構函式

類可以在類體中定義若干個輔助建構函式。輔助建構函式使用constructor 標記：

class Person(name: String) {
    constructor(parent: Person, name: String): this(name) {
        parent.children.add(this)
    }
}

如上，如果函式定義了一個主建構函式，那麼所有的輔助建構函式必須使用this呼叫主建構函式（直接呼叫或者通過呼叫其他輔助建構函式間接呼叫）。

如果沒有主建構函式或者輔助建構函式被定義，編譯器將自動生成無參主建構函式。主建構函式的預設訪問許可權為public

class DontCreateMe private constructor() {
}

如果執行在JVM上，類的主建構函式的所有引數都有預設值，編譯器將會自動生成無參建構函式，並使用預設引數值初始化。這有益於Kotlin類用於某些Java庫中。

建立類的例項

Kotlin中沒有new 關鍵字。所以相對於Java，省略掉new就可以了~ 如下：

val apple = Apple()
val person = Person("Tom")

類繼承

類似於Java中的Object類，Any 類是Kotlin中所有其它類的預設基類。Any類不是Java中的Object類，Any 類只包含equals()、hashCode()和toString()方法。

描述繼承關係的方法與C++類似使用冒號，而不是使用Java中的“extend”或“implement”，Kotlin中沒有這倆關鍵字。

Koltin中的類預設是final不可以被繼承，對於需要被繼承的類，必須顯式地標記為open。

• 如果派生類有主建構函式，那麼必須在派生類主建構函式呼叫基類的建構函式完成基類初始化。
• 如果派生類沒有主建構函式，那麼就必須在派生類的每一個建構函式中都呼叫super()函式完成基類的初始化。

// 需要被繼承的基類，必須用open標記！
open class Base(p: Int)

// 派生類有主建構函式，必須在主建構函式之後呼叫基類的建構函式
class Derived_1(p: Int): Base(p)

// 派生類沒有主建構函式，必須在所有的輔助建構函式中呼叫基類的建構函式
class Derived_2 {
    constructor(p: Int): super(p)

    constructor(): super(0)
}

方法覆蓋(override)

不同於Java中可選的註解，Kotlin中方法覆蓋需要強制使用關鍵字open和override。

基類中被覆蓋的方法必須使用open關鍵字標記，而派生類中覆蓋基類方法的新方法必須使用override關鍵字標記：

open class Base {
    open fun f1() {}
    fun f2() {}
}

class Derived(): Base() {
    override fun f1() {}
}

如上，基類中只有f1()是可以被覆蓋的，並且在派生類中覆蓋f1()必須使用override關鍵字。

方法的標記總是不能和類的標記衝突，也即含有open函式的類必須也是open的！

如果派生類是open的，含有override標記的方法會預設成為open，這與之前的預設規則不同。如果不想讓派生類中覆蓋的方法進一步被覆蓋，那就需要新增final關鍵字。如下:

open AnotherDerived(): Base() {
    final override fun f1() {}
}

屬性覆蓋

屬性覆蓋和方法覆蓋差不多，同樣的open和override使用規則！

可以通過指定新的 get 方法，或提供初始值來覆蓋屬性。

可以使用var屬性覆蓋val屬性，這相當於在派生類中新增一個 set 方法；但是不能使用val 屬性覆蓋var屬性，這相當於繼承了基類的 set 方法卻無法再派生類中使用。

interface Foo {
    val count: Int
    val x: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
    override val x: Int get {...}
}

呼叫基類的方法

一句話！使用 super ~

如果是內部類需要訪問外部類的基類。假設外部類名為 Outer，那麼呼叫方法為[email protected]。如下：

class Bar : Foo() {
    override fun f() { /* ... */ }
    override val x: String get() = "..."

    inner class Baz {
        fun g() {
            super@Bar.f() // Calls Foo's implementation of f()
            println(super@Bar.x) // Uses Foo's implementation of x's getter
        }
    }
}

覆蓋規則

1. 如果繼承來的多個名稱（來自介面或者基類）衝突，派生類必須覆蓋這個方法；
2. 在派生類中訪問基類（或者介面）名稱的實現，如果存在多個實現那麼必須使用super<BaseType>語法指定基類。

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // interface members are 'open' by default
    fun b() { print("b") }
}

class C() : A(), B {
    // The compiler requires f() to be overridden:
    override fun f() {
        super<A>.f() // call to A.f()
        super<B>.f() // call to B.f()
    }
}

抽象類

包含抽象方法的類必須是抽象類。

抽象類和抽象方法都是用abstract關鍵字標記。

和介面一樣，抽象類和抽象介面預設為open！

可以用一個抽象方法覆蓋非抽象方法。