Kotlin 中所有類都繼承該 Any 類,它是所有類的超類,對于沒有超類型聲明的類是默認(rèn)超類:
class Example // 從 Any 隱式繼承
Any 默認(rèn)提供了三個函數(shù):
equals()
hashCode()
toString()
注意:Any 不是 java.lang.Object。
如果一個類要被繼承,可以使用 open 關(guān)鍵字進(jìn)行修飾。
open class Base(p: Int) // 定義基類
class Derived(p: Int) : Base(p)
如果子類有主構(gòu)造函數(shù), 則基類必須在主構(gòu)造函數(shù)中立即初始化。
open class Person(var name : String, var age : Int){// 基類
}
class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {
}
// 測試
fun main(args: Array<String>) {
val s = Student("W3cschool", 18, "S12346", 89)
println("學(xué)生名: ${s.name}")
println("年齡: ${s.age}")
println("學(xué)生號: ${s.no}")
println("成績: ${s.score}")
}
輸出結(jié)果:
學(xué)生名: W3cschool
年齡: 18
學(xué)生號: S12346
成績: 89
如果子類沒有主構(gòu)造函數(shù),則必須在每一個二級構(gòu)造函數(shù)中用 super 關(guān)鍵字初始化基類,或者在代理另一個構(gòu)造函數(shù)。初始化基類時,可以調(diào)用基類的不同構(gòu)造方法。
class Student : Person {
constructor(ctx: Context) : super(ctx) {
}
constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
}
}
/**用戶基類**/
open class Person(name:String){
/**次級構(gòu)造函數(shù)**/
constructor(name:String,age:Int):this(name){
//初始化
println("-------基類次級構(gòu)造函數(shù)---------")
}
}
/**子類繼承 Person 類**/
class Student:Person{
/**次級構(gòu)造函數(shù)**/
constructor(name:String,age:Int,no:String,score:Int):super(name,age){
println("-------繼承類次級構(gòu)造函數(shù)---------")
println("學(xué)生名: ${name}")
println("年齡: ${age}")
println("學(xué)生號: ${no}")
println("成績: ${score}")
}
}
fun main(args: Array<String>) {
var s = Student("W3cschool", 18, "S12345", 89)
}
輸出結(jié)果:
-------基類次級構(gòu)造函數(shù)---------
-------繼承類次級構(gòu)造函數(shù)---------
學(xué)生名: W3cschool
年齡: 18
學(xué)生號: S12345
成績: 89
在基類中,使用fun聲明函數(shù)時,此函數(shù)默認(rèn)為final修飾,不能被子類重寫。如果允許子類重寫該函數(shù),那么就要手動添加 open 修飾它, 子類重寫方法使用 override 關(guān)鍵詞:
/**用戶基類**/
open class Person{
open fun study(){ // 允許子類重寫
println("我畢業(yè)了")
}
}
/**子類繼承 Person 類**/
class Student : Person() {
override fun study(){ // 重寫方法
println("我在讀大學(xué)")
}
}
fun main(args: Array<String>) {
val s = Student()
s.study();
}
輸出結(jié)果為:
我在讀大學(xué)
如果有多個相同的方法(繼承或者實(shí)現(xiàn)自其他類,如A、B類),則必須要重寫該方法,使用super范型去選擇性地調(diào)用父類的實(shí)現(xiàn)。
open class A {
open fun f () { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } //接口的成員變量默認(rèn)是 open 的
fun b() { print("b") }
}
class C() : A() , B{
override fun f() {
super<A>.f()//調(diào)用 A.f()
super<B>.f()//調(diào)用 B.f()
}
}
fun main(args: Array<String>) {
val c = C()
c.f();
}
C 繼承自 a() 或 b(), C 不僅可以從 A 或則 B 中繼承函數(shù),而且 C 可以繼承 A()、B() 中共有的函數(shù)。此時該函數(shù)在中只有一個實(shí)現(xiàn),為了消除歧義,該函數(shù)必須調(diào)用A()和B()中該函數(shù)的實(shí)現(xiàn),并提供自己的實(shí)現(xiàn)。
輸出結(jié)果為:
AB
屬性重寫使用 override 關(guān)鍵字,屬性必須具有兼容類型,每一個聲明的屬性都可以通過初始化程序或者getter方法被重寫:
open class Foo {
open val x: Int get { …… }
}
class Bar1 : Foo() {
override val x: Int = ……
}
你可以用一個var屬性重寫一個val屬性,但是反過來不行。因?yàn)関al屬性本身定義了getter方法,重寫為var屬性會在衍生類中額外聲明一個setter方法
你可以在主構(gòu)造函數(shù)中使用 override 關(guān)鍵字作為屬性聲明的一部分:
interface Foo {
val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
override var count: Int = 0
}
更多建議: