Kotlin學習（七）: 類和繼承、接口與實現

本文是學習Kotlin的類和繼承相關，嵌套類相關，接口相關。

類

Kotlin的類的聲明與Java一樣，使用class關鍵字

class Invoice {
}

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

class Empty

構造函數

Kotlin的類有兩種構造函數，一種是主構造函數，一種是二級構造函數。
主構造函數是寫在類名後面(可以有可選的類型參數)，使用constructor關鍵字聲明

class Person constructor(firstName: String) {
}

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

class DontCreateMe private constructor () {
}

如果主構造函數沒有任何註釋或可見性修飾符，則可以省略constructor關鍵字

class Person(firstName: String) {
}

主構造函數不包含任何代碼，初始化代碼應該放在以init做前綴的初始化塊中

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

主構造函數的參數既可以用在初始化塊中，也可以用在類的屬性初始化聲明處

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

一般用Java寫構造函數的時候，裏面是寫屬性的初始化，如下面

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有更簡潔的寫法，可以在主構造函數重聲明屬性並在主構造函數中初始化，同時可以設置屬性爲可變（var）或者設置爲只讀（val）

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

如果構造函數具有註解(@Inject)或可見性修飾符(public)，則constructor關鍵字必須寫上，並且寫在可見性和註解的後面

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

二級構造函數

二級構造函數同樣是以constructor關鍵字來聲明，與主構造函數不同的是，二級構造函數是寫在類裏面，同時，二級構造函數可以有多個。

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

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

如果該類有主構造函數，那麼聲明二級構造函數都要使用this關鍵字來代理(Delegation)主構造函數

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 虛擬機中，如果主構造函數的所有參數都有默認值，編譯器會生成一個附加的無參的構造函數，這個構造函數會直接使用默認值。

class Customer(val customerName: String = "")

創建類的實例

Kotlin創建類的實例不需要像Java一樣使用到new關鍵字，直接調用構造函數即可創建類的實例

val invoice = Invoice()

val customer = Customer("Joe Smith")

類成員

Kotlin的類裏面可以包含
- 構造函數和初始化塊(Constructors and initializer blocks)
- 函數(Functions)
- 屬性(Properties)
- 嵌套類和內部類(Nested and Inner Classes)
- 數據對象(Object Declarations)

繼承

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

class Example // 隱式繼承自Any

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

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

open class Base(p: Int)

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

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

同樣，如果父類有主構造函數，則子類必須在主構造函數中初始化

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

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

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

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

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

    }
}

下面這種情形中不同的二級構造函數可以調用父類不同的構造方法

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

重寫方法

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

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

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

同樣，如果類不是open的話，裏面的成員也不允許設置爲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()
    }
}

可以在子類的主構造函數中聲明override

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

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

使用`super`實現

子類中的代碼可以使用super關鍵字調用其父類的函數與屬性訪問器的實現：

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
}

在一個內部類中訪問外部類的父類，可以通過由外部類名限定的super關鍵字來實現：super@Outer：

class Bar : Foo() {
    override fun f() { /* …… */ }
    override val x: Int get() = 0

    inner class Baz {
        fun g() {
            super@Bar.f() // 調用 Foo 實現的 f()
            println(super@Bar.x) // 使用 Foo 實現的 x 的 getter
        }
    }
}

重寫規則

在Kotlin中，實現繼承通常遵循如下規則：如果一個類從它的直接父類繼承了同一個成員的多個實現，那麼它必須複寫這個成員並且提供自己的實現，要使用父類中提供的方法，用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()的實現沒有任何問題，因爲它們都只有一個實現。但是f()有兩個實現，所以要在C中必須複寫f()並且提供自己的實現。

抽象類

與Java類似，Kotlin的類或者成員都可以被聲明爲abstract，同時不需要添加open關鍵字。
可以用一個抽象成員去複寫一個帶 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)
}

匿名類

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

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

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

    TALKING {
        override fun signal() = WAITING
    };

    abstract fun signal(): ProtocolState
}

使用枚舉常量

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

EnumClass.valueOf(value: String): EnumClass

EnumClass.values(): Array<EnumClass>

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

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

val name: String

val ordinal: Int

密封類

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

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

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

使用密封類的最主要的的好處體現在使用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
    }
}

如何調用

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

內部類

內部類是使用inner關鍵字來聲明。

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

如何調用

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

嵌套類與內部類的區別是：嵌套類不能夠訪問外部成員，因爲內部類包含對外部類的對象的引用，所以能夠訪問外部類的成員；調用的時候，內部類需要使用外部類的實例來調用。

接口

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

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

實現接口

一個類或對象可以實現一個或多個接口

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"
}

解決重寫衝突

同類的重寫類似，接口也一樣，如果父類中聲明瞭許多類型，有可能出現一個方法的多種實現，必須複寫這個成員並且提供自己的實現，要使用父類中提供的方法，用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()函數，都實現了foo()方法，但只有B實現了bar()，bar()在A中並沒有聲明它是抽象的，C實體類需要重寫並實現bar()，而D類，不用重寫bar()方法，因爲繼承的B接口已經實現了。由於繼承了兩個foo()的實現，所以用super<Base>來區分。

Kotlin學習（七）: 類和繼承、接口與實現

類

構造函數

二級構造函數

創建類的實例

類成員

繼承

重寫方法

重寫屬性

使用`super`實現

重寫規則

抽象類

枚舉類

初始化

匿名類

使用枚舉常量

密封類

嵌套類

內部類

接口

實現接口

接口中的屬性

解決重寫衝突

Android 隱藏和顯示虛擬按鍵

Kotlin實戰（二）: 實現RecyclerView多種Item佈局

Kotlin學習（二）基本語法

Kotlin學習（九）: 擴展(Extensions)和This表達式

Android AIDL相關

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Kotlin學習（七）: 類和繼承、接口與實現

類

構造函數

二級構造函數

創建類的實例

類成員

繼承

重寫方法

重寫屬性

使用super實現

重寫規則

抽象類

枚舉類

初始化

匿名類

使用枚舉常量

密封類

嵌套類

內部類

接口

實現接口

接口中的屬性

解決重寫衝突

使用`super`實現