kotlin入门潜修之类和对象篇—继承

本文收录于 kotlin入门潜修专题系列,欢迎学习交流。

创作不易,如有转载,还请备注。

写在前面

用平常心来生活,用惭愧心来待人,用心来处事,用菩提心契佛心。——与君共勉。

继承

面向对象的三大基石:继承、多态与封装。这三个特性构成了绚丽多彩的编程世界,也衍生出了诸多优雅的设计。本篇文章将会解析kotlin中的继承机制。

众所周知,java中所有的类都会默认继承java.lang.Object类,同样,kotlin中所有的类也默认继承了一个叫做Any的类,其作用同java的Object类,是kotlin里面所有类的基类。

需要注意的是,Any类虽然同java中的Object类一样作为所有类的基类存在,但是Any类并不等同于java的Object类,因为Any类中只有equals、hasCode、toString三个方法,而java中的Object类还有诸如getClass、notifyAll、wait、clone等方法,所以二者并不是一个类。

kotlin中的继承写法也和java完全不一样了,kotlin中不再有extends、implements关键字,取而代之的是冒号“ : ”,其定义如下:

open class Person constructor(name: String) {//基类,注意有open关键字修饰
}
class Student(name: String) : Person(name) {//子类,子类必须要实现父类中的一个构造方法
}

有几点需要注意:

  1. kotlin中的类默认是final的,即是无法继承的,这与java不同,java中默认都是可继承的。kotlin中所有的设计都是要显示提供,其实这也正是kotlin的设计理念,只有在真正需要的时候才暴露。kotlin提供了open关键字用于显示表明该类是可继承的。
  2. 子类必须要实现父类中的一个构造方法。可以通过子类的主构造方法去初始化父类构造方法,也可以通过第二构造方法初始化父类的构造方法。上面的例子就是通过主构造方法初始化了父类。第二构造方法初始化示例如下:
//父类People,注意,这里提供了一个主构造方法和一个第二构造方法
open class People constructor(name: String) {
    public constructor(name: String, age: Int) : this(name)
}
//下面是几种不同的初始化父类的写法
//1. 通过第二构造方法初始化,这里调用了父类People的主构造方法
class Teacher : People {
    constructor() : super("张三")
}
//2. 通过第二构造方法初始化,这里调用了父类People的第二构造方法
class Teacher : People {
    constructor() : super("张三", 10)
}
//3.通过主构造方法初始化,这里调用了父类People的主构造方法
class Teacher(name: String) : People (name){
}
//4.通过主构造方法初始化,这里调用了父类People的第二构造方法
class Teacher(name: String) : People (name, 20){
}

在实际编码中,具体采用上面哪种写法可以根据场景自行选择。主要能够保证初始化父类的任意构造方法即可。

复写方法(Overriding Methods)

kotlin中方法的复写和类的设计理念一样(类必须显示定义为open才能被继承),必须要显示指定该方法可以复写,子类才能进行复写(当然前提是父类也必须定义为可继承的,即要open修饰),其显示指定的关键字依然是open。示例如下:

//父类,open修饰,表示可继承
open class Person {
    fun getAge(){}//注意这里没有open关键字
    open fun getName(){}//这里有open关键字
}
class Student() : Person() {
    override fun getName() {//这里override是合法的,因为父类该方法使用了open修饰,表示可以被复写
        super.getName()
    }
    override fun getAge(){}//!!! 这是不合法的,编译不通过!因为父类中的getAge()并没有显示指定为open
    fun getAge(){}//!!! 这也是不合法的,编译不通过!因为父类中已经存在getAge(),只能override。在这个例子中即使override也是不合法的,上面已经阐述。
}

一个方法一旦被标记为open方法,那么该方法就一直能被override(即其子类的子类的子类...等等都可以复写),那么如果子类不想再让其子类override方法怎么办?比如上个例子中,Person中的getName是可被override的,所以子类Student可以通过override fun getName来复写,但是现在Student不在期望其子类再override getName方法,该怎么办?很简单,在其方法前加final关键字即可:

open  class Student() : Person() {
    final override fun getName() {//注意这里加了final关键字,表示其子类不再能复写该方法。
        super.getName()
    }
}

复写属性(overriding properties)

复写属性和复写方法一样,要用open显示标明可复写。属性的继承有几点需要注意的,示例如下

//父类,该类设置为了可继承,即open修饰
open class Person {
    var age : Int = 20
    var height: Int = 170
    open var address : String = "address"
    val name : String = "name"
    open val email : String = "email"
    open val phoneNum : Int = 1234567
    open var score: Int = 80
    open val sex : String get() {return "男"}
}
//子类,继承Person,分析的重点就在这里。
class Student : Person() {
    //首先看var变量
    var age: Int = 20//!!!编译不通过,父类已经存在该字段。
    override var height: Int = 180//!!!编译不通过,因为父类中没有显示定义为open,故不能复写。
    override var address: String = "address"//正确,因为父类中显示定义为了open
    //下面是val变量
    val name: String = "name"//!!!编译不通过,父类已经存在该字段。
    override val email: String = "email"//正确,因为父类中显示定义为了open
    override var phoneNum : Int = 1234567//正确,注意,这里父类中的phoneNum是val不可变的,但这里复写为了var可变的,kotlin是允许这么做的。
    override val score: Int = 80//!!!编译错误,注意,这里父类中的score是var可变的,而这里复写为了val不可变的,kotlin中是不允许这么做的。
    override val sex: String get() {//正确,这里只是演示了属性变量另一种初始化方法,即使用get方法。
        return "男"
    }
}

上面基本分析了复写属性的各种情况,唯一需要注意的是父类中的val是可以在子类中被复写为var的,反之则不行。这是为什么?

是这样的,kotlin中的val属性都默认定义了一个getter方法,子类复写为var的时候实际上是为该变量额外增加了一个setter方法,所以可以这么做。

此外,kotlin也可以在主构造方法中复写属性,如下所示:

open class Person constructor(open val name: String) {
}
//注意,子类在主构造方法中复写了name属性
open class Student(override val name: String) : Person(name) {
}

派生类的初始化顺序

所谓派生类即是继承父类的子类。那么派生类的执行顺序是怎么样的?先看下面一个例子:

//父类
open class Person(name: String) {
    init {
        println("initializing person")
    }

//这里运用了let方法,会在后续文章中分析
    open val nameLength: Int = name.length.let {
        println("initializing name length in person:".plus(it))
        it
    }
}
//子类
class Student(name: String, lastName: String) : Person(name.let { println("argument for person $it")
            it }) {
    init {
        println("initializing student")
    }//注意,这里看着比较绕,但是实际完成功能就是打印基类的入参

    override val nameLength: Int = lastName.length.let {
        (super.nameLength + it).let {
            println("initializing name length in student:".plus(it))
            it
        }
    }
}
   //程序执行入口
    @JvmStatic fun main(args: Array) {
            var student = Student("name", "lastName")//生成student对象
     }

上面代码执行main方法后,会打印一下日志:

argument for person name
initializing person
initializing name length in person:4
initializing student
initializing name length in student:12

通过日志打印可以看出,kotlin会首先初始化父类,父类先执行构造方法,然后按编码顺序先后执行init块、属性初始化等,接着会执行子类构造方法、init块、属性初始化等。

由此可知,在父类执行构造方法的时候,子类的属性或者复写父类的属性都还没有初始化,所以父类中一定不能使用这些属性,否则会造成未知的错误,甚至会造成运行时异常。

因此,在设计父类的时候,一定要避免在构造方法、属性初始化以及init块中使用open类型的成员变量(因为这些晚些时候可能会被子类复写)。

调用父类中的实现

kotlin同java一样,子类要调用父类的实现可以通过super关键字完成,示例如下:

//父类
open class Person() {
    open fun printSex() {
        println("默认性别:男")
    }
    var defaultName = ""
    open val age = 20
}
//子类
class Student() : Person() {
    override fun printSex() {//复写父类printSex方法
        super.printSex()//这里通过super调用父类中方法
        println("the student age: 18")
    }
   fun printName(){//子类自定义打印姓名的方法
        println(super.defaultName)//这里直接调用了父类中的非open属性。
    }
    override val age: Int
        get() = super.age + 2//这里通过super调用父类中的open属性
}

kotlin中,只要父类中的实现(属性或者方法)不是private的,子类都可以通过super来调用父类的实现。

复写规则

这里的复写规则讲的是,当一个子类实现多个父实现的时候,会存在多个父实现含有相同实现的情形(如含有相同的方法签名或者相同的属性)。注意,kotlin同java一样,依然是单继承体系,即一个子类一次只能继承一个父类,这里所说的父实现是指,子类可能会在继承父类的同时实现了一个或者多个接口。具体示例如下:

//父类A,有m1和m2两个方法
open class A {
    open fun m1() {
        print("m1 in A")
    }

    open fun m2() {
        print("m2 in A")
    }
}
//接口B,有m1和m3两个方法,注意m1方法和A中的签名一样。
interface B {//kotlin中接口的写法,使用关键字interface修饰
    fun m1() {//接口中的方法默认都是open的,所以不需要使用open修饰
        print("m1 in B")
    }

    fun m3() {
        print("m3 in B")
    }
}
//实现类C,继承了A同时实现了B接口
class C : A(), B {//多个实现的写法使用英文逗号(,)隔开
        //注意这里,因为A类中有方法m1,B接口中也有方法m1,所以子类就不知道该默认实现哪个父实现中的方法。因此,在这种情形下,kotlin会强制子类明确复写该方法。如果子类还想调用父类的实现,那么可以通过super<父类型>这种方法来指定调用父类的实现,
        override fun m1() {//该方法必须要复写
        super.m1()//这里调用A类中m1的实现,非强制,可选择性调用
        super.m1()//调用B接口中m1的实现
    }
}

上面代码中,由于m1存在实现冲突(两个父实现都有该方法),所以子类必须要复写该方法,而m2、m3不存在冲突,故kotlin不强制复写。

抽象类

kotlin中的抽象类同java一样,都是使用abstract关键字来修饰。kotlin中的抽象类,默认都是open的,所以不需要再显示使用open关键字进行修饰。如果一个类的任意一个成员被定义为abstract,那么该类必须要定义为抽象类。

示例如下:

abstract class A {//抽象类使用abstract修饰
    abstract fun m1()//抽象方法不能有任何实现,即不能有方法体{}
    open fun m3() {//抽象类可以包含普通的方法实现
        print("m3 in A")
    }
}
//子类C,继承抽象类A
class C : A() {
   //子类必须要实现抽象类中的抽象方法。普通方法则不强制实现。
    override fun m1() {
    }
}

伴随对象

伴随对象是kotlin中特有的存在。kotlin不像java、c#,它没有static方法,而是推荐使用包级别(package-level)的方法替代,示例如下:

package com.test//com.test包
fun staticM1(){//直接定义了一个staticM1方法,注意这里并没有定义任何类
    println("staticM1")
}
//在Main类中调用该包级别方法
import com.test.staticM1//导入了staticM1方法
class Main {
    companion object {//这个是个伴随对象,下面会分析
        @JvmStatic fun main(args: Array) {
            staticM1()//这里调用了staticM1,使用方法如同java中的static,没有生成任何类对象
        }

    }
}

上面的写法即是包级别的方法,大部分都可以满足要使用“静态方法”的需求。从代码也可以看出,包级别的方法不依附于任何类,也就是不属于任何类。但是假如有个方法需要在一个类中定义,而我们确实又需要在不生成该类实例的情况下使用该方法,该怎么办呢(如工厂方法模式)?

针对这种情况,kotlin提供了另一个实现机制:伴随对象。有了伴随对象,就可以想调用静态方法一样使用了,如下所示:

class A {
    companion object {//伴随对象的写法,两个关键字companion object
        fun m1() {//这里定义了一个m1方法,注意下面B类中的调用方式
            println("method m1 in A's companion object")
        }
    }
}

class B {
    fun test() {
        A.m1()//注意这里,通过A类名调用了m1方法,而没有生成A类实例
    }
}

实际上,我们前面已经多次用到伴随对象了,比如程序的执行入口Main类中main方法的实现。我们都知道java中的执行入口是静态方法,那么kotlin中的执行入口该怎么写呢?示例如下:

class Main {
    companion object {//伴随对象
        @JvmStatic fun main(args: Array) {//main方法执行入口
        }
    }
}

当然,也可以提供包级别的main方法,如下所示:

class Main {
//作为对比,这里暂时注释掉了伴随对象
//    companion object {
//        @JvmStatic fun main(args: Array) {
//
//        }
//
//    }
}
//这里提供了package-level的main入口方法,作用同上面注释掉的伴随对象写法。
fun main(args: Array) {
}

你可能感兴趣的:(kotlin入门潜修之类和对象篇—继承)