天天看点

Kotlin——继承

Kotlin——继承

kotlin中所有的类都有一个公有的超类:any,这是所有没有声明超类的类的默认父类。

class example //隐式继承自any 

any!=java.lang.object。尤其,除了equals()、hashcode()和tostring()三个方法外,没有任何成员。

为了显式地声明超类,语法如下:

open class base(p:int) 

class derived(p:int):base(p) 

如果类具有主构造器,则可以使用主构造器的参数(并且必须)初始化父类。

如果类没有主构造器,那么每个辅助构造器初始化时需要使用super关键字,或者将其委托给其他构造器。需要注意的是,在这种情况下,不同的辅助构造器可以调用基类的不同构造器。

class myview:view{ 

constructor(ctx:context):super(ctx) 

constructor(ctx:context,attrs:attributeset):super(ctx,attrs) 

open注解和java的final相反:它允许其他类继承自该类。默认的,kotlin中所有的类是final的,也就是说不能继承的。

覆写方法

kotlin总是做一些明确的事情,不像java,kotlin要求复写方法时需要显式的注解和重写:

open class base { 

    open fun v() { 

        println("base.v()") 

    } 

    fun nv() { 

        println("base.nv") 

class derived() : base() { 

    override fun v() { 

        println("derived.v()") 

复写derived的v()时,ovverride注解是必须的,否则编译器会报错。如果没有open注解,比如base的nv(),那么在子类中是不能覆写该方法的。在一个final类中(没有open注解声明),open成员是禁止的。也就是说final类的每个成员也都是final的。

一个标记为override的成员自身就是open的,子类仍然可以覆写它。如果你想禁止覆写,那么使用final

open class anotherderived() : base() { 

    final override fun v() { 

        println("anotherderived.v") 

最后,main()验证多态性:

fun main(args: array<string>) { 

    var base1: base = base() 

    var base2: base = derived() 

    var base3: base = anotherderived() 

    base1.v() 

    base2.v() 

    base3.v() 

覆写属性

覆写属性和覆写方法基本类似;如果子类要重新声明父类中已经声明过的属性,那么需要使用override,并且类型要兼容。每个声明的属性可以被具有初始化器的属性或具有getter方法的属性覆盖。

open class foo { 

    open val x: int 

        get() { 

            println("foo") 

            return 3 

        } 

class bar1 : foo() { 

    override val x: int = 2 

可以使用var属性覆盖val属性,反之不可以。因为val属性基本上声明一个getter方法,并将其替换为var,另外在派生类中声明一个setter方法。

可以在主构造器使用override覆盖属性

interface aoo { 

    val count: int 

class aoo1(override val count: int) : aoo 

class aoo2 : aoo { 

    override var count: int = 0 

覆写准则

在kotlin中,实现继承由以下规则控制:如果类从其直接超类继承同一成员的多个实现,则它必须覆盖该成员并提供自己的实现(可能使用其中一个继承)。 要表示从其继承的实现的超类型,可在尖括号中使用超类型名称超级限定,例如,super。

open class a { 

    open fun f() { 

        println("a") 

    fun a() { 

//接口的方法默认open 

interface b { 

    fun f() { 

        println("b") 

    fun b() { 

class c() : a(), b { 

    override fun f() { 

        super<a>.f() 

        super<b>.f() 

        println("c") 

上面的代码继承自a和b是没有问题的,a()和b()因为c知道继承自哪一个类。但是对于f(),我们有两个继承,所以我们需要覆写f(),并且需要提供我们的实现来消除歧义。

总结

kotlin中的类默认是final的,如果需要子类继承,需要使用open修饰;

kotlin中的方法默认是不允许复写的,只有用open修饰时,子类才可以进行覆写,并且需要使用override进行显示标注

属性也支持覆写

作者:佚名

来源:51cto