Kotlin藝術探索之類和接口

類

1.基本用法

Kotlin的類的普通寫法和Java同樣

class Invoice { ... }
複製代碼

若是類裏面內容是空的，能夠把括號省略

class Empty
複製代碼

2.類的構造方法

構造方法的參數能夠直接寫在類名以後

class InitOrderDemo(name: String) {

    var firstProperty = "First property: $name".also (::println)
    init {
        println("First initializer block that prints ${name}")
    }

}
複製代碼

能夠在init方法裏面初始化數據

固然也能夠在構造器方法constructor方法裏初始化

class Constructors {
    init {
        println("Init block")
    }

    constructor(i: Int) {
        println("Constructor")
    }
}
複製代碼

它們的不一樣在於，init方法不能夠傳參數，而constructor能夠設置參數。

要注意的是，init方法必定是在constructor方法前執行。

3.類的繼承

若是某個類須要被繼承，那麼須要使用open關鍵字，表示該類能夠被繼承

open class Base(p: Int)
class Derived(p: Int) : Base(p)
複製代碼

類方法的重寫

被繼承的父類中方法若是須要被重寫，也須要加上open關鍵字，而且子類重寫的方法中要加上override關鍵字

open class Base {
    open fun v() {  }
    fun nv() { }
}
class Derived() : Base() {
    override fun v() { }
}
複製代碼

4.類屬性的重寫

類的屬性重寫和方法類似，屬性的賦值能夠用get方法

open class Foo {
    open val x: Int get() = 1
}

class Bar1 : Foo() {
    override val x: Int get() = 2
}
複製代碼

固然也能夠在子類的構造方法中進行重寫，這也須要用override關鍵字

class Bar2(override val x: Int) : Foo()
複製代碼

5.調用父類的屬性和方法

子類能夠經過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() // Calls Foo's implementation of f() println(super@Bar.x) // Uses Foo's implementation of x's getter } } } 複製代碼

6.抽象類的表示

抽象類的表示要用abstract關鍵字

abstract class abstractClass {
    abstract fun f()
}
複製代碼

抽象類自己和抽象方法不須要加open來代表能夠被繼承，由於抽象類的本意就是用來被繼承的

接口

1.接口的基本實現

Kotlin的接口和Java8的特性差很少

它們均可以書寫抽象方法的聲明和方法的具體實現

定義一個接口 MyInterface

interface MyInterface {
    val prop: Int // abstract
    val propertyWithImplementation: String
        get() = "foo"
    fun foo() {
        print(prop)
    }
}
複製代碼

定義一個類實現MyInterface接口，因爲在接口中並無初始化變量prop，因此實現類中必需要重寫該變量

class Child : MyInterface {
    override val prop: Int = 29
}
複製代碼

那麼在接口中如何初始化變量呢？

可使用get方法來初始化name這個變量

interface Named {
    val name: String
}

//繼承Named接口
interface Person : Named {
    val firstName: String
    val lastName: String
    override val name: String
        get() = "$firstName $lastName"
}
複製代碼

2.解決接口方法衝突

定義兩個接口A，B

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

interface B {
    fun foo() { println("B") }
    fun bar() { println("B of bar") }
}
複製代碼

A，B這兩個接口有重合的方法，而且類D實現這兩個接口，那麼若是區分調用這兩個接口的方法呢？

class D: A,B{

    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }

    override fun bar() {
        super<B>.bar()
    }

}
複製代碼

接口衝突的解決方法很簡單，經過<接口>方式調用須要的接口方法

注意：接口方法衝突的解決有兩種要求： 1.接口方法的簽名（方法名和參數）一致且返回值類型相同 2.接口方法有默認的實現