Safe

本文是學(xué)習(xí)Kotlin的類和繼承相關(guān)，嵌套類相關(guān)，接口相關(guān)。

類

Kotlin的類的聲明與Java一樣，使用class關(guān)鍵字

class Invoice {
}

類的聲明包含類名，類頭(指定類型參數(shù)，主構(gòu)造函數(shù)等等)，以及類主體，用大括號包裹。類頭和類體是可選的；如果沒有類體可以省略大括號。

class Empty

構(gòu)造函數(shù)

Kotlin的類有兩種構(gòu)造函數(shù)，一種是主構(gòu)造函數(shù)，一種是二級構(gòu)造函數(shù)。
主構(gòu)造函數(shù)是寫在類名后面(可以有可選的類型參數(shù))，使用constructor關(guān)鍵字聲明

class Person constructor(firstName: String) {
}

如果一個非抽象類沒有聲明構(gòu)造函數(shù)(主構(gòu)造函數(shù)或二級構(gòu)造函數(shù))，它會產(chǎn)生一個沒有參數(shù)的構(gòu)造函數(shù)。構(gòu)造函數(shù)是 public 。如果你不想類有公共的構(gòu)造函數(shù)，就得聲明一個空的主構(gòu)造函數(shù)

class DontCreateMe private constructor () {
}

如果主構(gòu)造函數(shù)沒有任何注釋或可見性修飾符，則可以省略constructor關(guān)鍵字

class Person(firstName: String) {
}

主構(gòu)造函數(shù)不包含任何代碼，初始化代碼應(yīng)該放在以init做前綴的初始化塊中

class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}

主構(gòu)造函數(shù)的參數(shù)既可以用在初始化塊中，也可以用在類的屬性初始化聲明處

class Customer(name: String) {
    val customerKry = name.toUpperCase()
}

一般用Java寫構(gòu)造函數(shù)的時候，里面是寫屬性的初始化，如下面

class Person {
    private String firstName;
    private String lastName;
    private int age;
    Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
}

Kotlin有更簡潔的寫法，可以在主構(gòu)造函數(shù)重聲明屬性并在主構(gòu)造函數(shù)中初始化，同時可以設(shè)置屬性為可變（var）或者設(shè)置為只讀（val）

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

如果構(gòu)造函數(shù)具有注解(@Inject)或可見性修飾符(public)，則constructor關(guān)鍵字必須寫上，并且寫在可見性和注解的后面

class Customer public @Inject constructor(name: String) {  }

二級構(gòu)造函數(shù)

二級構(gòu)造函數(shù)同樣是以constructor關(guān)鍵字來聲明，與主構(gòu)造函數(shù)不同的是，二級構(gòu)造函數(shù)是寫在類里面，同時，二級構(gòu)造函數(shù)可以有多個。

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

    constructor(parent: Person, count: Int) {
        parent.children.add(this)
    }
}

如果該類有主構(gòu)造函數(shù)，那么聲明二級構(gòu)造函數(shù)都要使用this關(guān)鍵字來代理(Delegation)主構(gòu)造函數(shù)

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

注意：在 JVM 虛擬機中，如果主構(gòu)造函數(shù)的所有參數(shù)都有默認值，編譯器會生成一個附加的無參的構(gòu)造函數(shù)，這個構(gòu)造函數(shù)會直接使用默認值。

class Customer(val customerName: String = "")

創(chuàng)建類的實例

Kotlin創(chuàng)建類的實例不需要像Java一樣使用到new關(guān)鍵字，直接調(diào)用構(gòu)造函數(shù)即可創(chuàng)建類的實例

val invoice = Invoice()

val customer = Customer("Joe Smith")

類成員

Kotlin的類里面可以包含

• 構(gòu)造函數(shù)和初始化塊(Constructors and initializer blocks)
• 函數(shù)(Functions)
• 屬性(Properties)
• 嵌套類和內(nèi)部類(Nested and Inner Classes)
• 數(shù)據(jù)對象(Object Declarations)

繼承

Kotlin中的所有類都有一個公共的父類Any

class Example // 隱式繼承自Any

Any不是java.lang.Object，Any只包含equals(),hashCode()以及toString()三個成員

Any

Object

如何繼承一個類，聲明一個類的父類呢，在類后面加冒號然后再加父類

open class Base(p: Int)

class Derived(p: Int) : Base(p)

注意一個類如果要被別的類繼承，要加上open關(guān)鍵字，在類名的最前面，默認情況下，Kotlin中的所有類都是final的，Kotlin的接口以及成員默認都是open。

同樣，如果父類有主構(gòu)造函數(shù)，則子類必須在主構(gòu)造函數(shù)中初始化

/**
* 父類
*/
open class BaseKot(name: String) {
}

/**
* 子類
*/
class Kot(name: String) : BaseKot(name) {
}

如果子類沒有主構(gòu)造函數(shù)，則可以在二級構(gòu)造函數(shù)中使用super關(guān)鍵字初始化或者在代理(Delegation)另一個構(gòu)造函數(shù)。

/**
* 父類
*/
open class BaseKot(name: String) {
}

/**
* 子類
*/
class Kot : BaseKot {
    constructor(name: String) : super(name) {

    }
}

下面這種情形中不同的二級構(gòu)造函數(shù)可以調(diào)用父類不同的構(gòu)造方法

class MyView : View {
    constructor(ctx: Context) : super(ctx) {
    }
    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
    }
}

重寫方法

上面說了，如果一個類要被繼承需要在父類的類名前面加上open關(guān)鍵字，該類才能被繼承，同樣，一個父類的方法如果要能被重寫，也需要加上open關(guān)鍵字，如果沒有加的話，子類是不能重寫改方法的。

/**
* 父類
*/
open class BaseKot {
    open fun v() {}
    fun nv() {}
}

/**
* 子類
*/
class Kot : BaseKot() {
    // 加final可以設(shè)置不被重寫
    override fun v() {
        super.v()
    }
    // 重寫nv方法會報錯，加override也不行，只有父類的nv方法設(shè)置為open才行
    // fun nv() { }
}

同樣，如果類不是open的話，里面的成員也不允許設(shè)置為open

重寫屬性

重寫屬性與重寫方法類似，并且屬性必須具有兼容類型，可以將val屬性重寫成var，也可以將var屬性重寫成val

/**
* 父類
*/
open class BaseKot {
    open val age: Int get() = 0 // get() = 0 與 = 0相同
    open fun v() {}
}

/**
* 子類
*/
class Kot : BaseKot() {
    override var age: Int = 5 // 重寫為var類型

    override fun v() {
        super.v()
    }
}

可以在子類的主構(gòu)造函數(shù)中聲明override

class Kot(override var age: Int) : BaseKot() {

    override fun v() {
        super.v()
    }
}

使用super實現(xiàn)

子類中的代碼可以使用super關(guān)鍵字調(diào)用其父類的函數(shù)與屬性訪問器的實現(xiàn)：

open class Foo {
    open fun f() { println("Foo.f()") }
    open val x: Int get() = 1
}

class Bar : Foo() {
    override fun f() { 
        super.f()
        println("Bar.f()") 
    }
    
    override val x: Int get() = super.x + 1
}

在一個內(nèi)部類中訪問外部類的父類，可以通過由外部類名限定的super關(guān)鍵字來實現(xiàn)：super@Outer：

class Bar : Foo() {
    override fun f() { /* …… */ }
    override val x: Int get() = 0
    
    inner class Baz {
        fun g() {
            super@Bar.f() // 調(diào)用 Foo 實現(xiàn)的 f()
            println(super@Bar.x) // 使用 Foo 實現(xiàn)的 x 的 getter
        }
    }
}

重寫規(guī)則

在Kotlin中，實現(xiàn)繼承通常遵循如下規(guī)則：如果一個類從它的直接父類繼承了同一個成員的多個實現(xiàn)，那么它必須復(fù)寫這個成員并且提供自己的實現(xiàn)，要使用父類中提供的方法，用super<Base>來表示

open class A {
    open fun f() { print("A") }
    fun a() { print("a") } // 不會被重寫
}

interface B {
    fun f() { print("B") } // 接口成員默認是open的
    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()
    }
}

可以同時從A B中繼承方法，而且C繼承a()或b()的實現(xiàn)沒有任何問題，因為它們都只有一個實現(xiàn)。但是f()有兩個實現(xiàn)，所以要在C中必須復(fù)寫f()并且提供自己的實現(xiàn)。

抽象類

與Java類似，Kotlin的類或者成員都可以被聲明為abstract，同時不需要添加open關(guān)鍵字。
可以用一個抽象成員去復(fù)寫一個帶 open 注解的非抽象方法

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

枚舉類

Kotlin也支持枚舉，每個枚舉常量都是一個對象。

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}

初始化

由于每個枚舉都是枚舉類的實例，因此可以進行初始化

enum class Color(val rgb: Int) {
        RED(0xFF0000),
        GREEN(0x00FF00),
        BLUE(0x0000FF)
}

匿名類

枚舉常量也可以使用對應(yīng)的方法聲明自己的匿名類，以及覆蓋基本方法。

注意，與Java一樣，如果枚舉類定義了任何成員，則需要使用分號將成員定義中的枚舉常量定義分隔開。

enum class ProtocolState {
    WAITING {
        override fun signal() = TALKING
    },

    TALKING {
        override fun signal() = WAITING
    };

    abstract fun signal(): ProtocolState
}

使用枚舉常量

就像在Java中一樣，Kotlin中的枚舉類有合成方法，允許列出定義的枚舉常量，并通過名稱獲取枚舉常量。這些方法的簽名如下（假設(shè)枚舉類的名稱是EnumClass）：

EnumClass.valueOf(value: String): EnumClass

EnumClass.values(): Array<EnumClass>

如果指定的名稱與類中定義的任何枚舉常量不匹配，該valueOf()方法將拋出IllegalArgumentException。

每個枚舉常量都具有在枚舉類聲明中獲取其名稱和位置的屬性：

val name: String

val ordinal: Int

密封類

密封類是用來表示受限的類層次結(jié)構(gòu)。例如當一個值為有限集中的 類型、而不能有任何其他類型時。在某種意義上,他們是枚舉類的擴展:枚舉類型的值集合也是受限的，但每個枚舉常量只存在一個實例,而密封類的一個子類可以有可包含狀態(tài)的多個實例。
密封類是類名前加sealed關(guān)鍵字來聲明

sealed class Expr {
    class Const(val number: Double) : Expr()
    class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}

密封類子類的擴展可以在任何地方，不必在密封類聲明內(nèi)部進行

使用密封類的最主要的的好處體現(xiàn)在使用when表達式。可以確保聲明可以覆蓋到所有的情形，不需要再使用 else情形。

fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // 前面說過，使用when的時候除非能把所有可能的情況都列舉出來，不然一定要加上else
    // 這里就不需要，因為列舉了所有的情況
}

嵌套類

與Java一樣，一個類中可以嵌套其他的類

class Outer {
    private val bar: Int = 1
    class Nested {
        fun foo() = 2
    }
}

如何調(diào)用

val demo = Outer.Nested().foo() //==2

內(nèi)部類

內(nèi)部類是使用inner關(guān)鍵字來聲明。

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() = bar
    }
}

如何調(diào)用

val demo = Outer().Inner().foo() // == 1

嵌套類與內(nèi)部類的區(qū)別是：嵌套類不能夠訪問外部成員，因為內(nèi)部類包含對外部類的對象的引用，所以能夠訪問外部類的成員；調(diào)用的時候，內(nèi)部類需要使用外部類的實例來調(diào)用。

接口

Kotlin的接口類似與Java 8，都可以包含抽象方法，以及方法的實現(xiàn)。和抽象類不同的是，接口不能保存狀態(tài)。可以有屬性但必須是抽象的，或者提供訪問器(getter)的實現(xiàn)。
接口的定義同樣是使用interface關(guān)鍵字

interface MyInterface {
    fun bar()
    fun foo() {
      // 函數(shù)體是可選的，自己實現(xiàn)方法
    }
}

實現(xiàn)接口

一個類或?qū)ο罂梢詫崿F(xiàn)一個或多個接口

class Child : MyInterface, YouInterface {
    override fun bar() {
        // body
    }
}

接口中的屬性

interface MyInterface {
    val prop: Int // abstract

    val propertyWithImplementation: String
        get() = "foo" // 提供訪問器getter，可以直接獲取propertyWithImplementation的值foo

    fun foo() {
        print(prop)
    }
}

class Child : MyInterface {
    override val prop: Int = 29
    override val propertyWithImplementation: String = "123"
}

解決重寫沖突

同類的重寫類似，接口也一樣，如果父類中聲明了許多類型，有可能出現(xiàn)一個方法的多種實現(xiàn)，必須復(fù)寫這個成員并且提供自己的實現(xiàn)，要使用父類中提供的方法，用super<Base>來表示

interface A {
    fun foo() { print("A") }
    fun bar()
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }
}

上面的代碼是A，B接口都有聲明了foo()，bar()函數(shù)，都實現(xiàn)了foo()方法，但只有B實現(xiàn)了bar()，bar()在A中并沒有聲明它是抽象的，C實體類需要重寫并實現(xiàn)bar()，而D類，不用重寫bar()方法，因為繼承的B接口已經(jīng)實現(xiàn)了。由于繼承了兩個foo()的實現(xiàn)，所以用super<Base>來區(qū)分。