文章目录
前言
Kotlin的继承和Java的继承一样都是单继承，区别在于Kotlin用:来代替了extends
一. 类的继承
Kotlin用:表示继承，Java用exteds表示继承。
// 父类Person
open class Person()
// 子类Man
class Man() : Person()
上面是最简单的Kotlin继承的例子。这里还需要注意的是在Kotlin中类默认都是final的(代表该类不让继承)，需要在class关键词前面加上open，表示该类可以被其他类继承。和Java一样Kotlin也是单继承的。
和Java的继承一样，子类可以使用父类的属性和方法：
open class Person {
var name: String = ""
var age: Int = -1
fun eat(){
println("eat food!")
}
}
class Man() : Person()
fun main() {
val man = Man()
man.age = 22
man.name = "Tom"
println("age is ${
man.age}")
println("name is ${
man.name}")
man.eat()
}
输出结果：
age is 22
name is Tom
eat food!
从上面的代码可以看出，子类Man可以使用父类Person的属性和方法。
二. 继承中的构造函数
Kotlin在继承情况的下，构造函数的语法是怎么样的？首先来看看Java是如何处理的。
2.1 继承中Java的构造函数
Java是通过super来实现对父类构造函数的访问和传值，类似如下代码：
// Person类(父类)
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
// Man类(子类)
public class Man extends Person{
public Man(String name, int age) {
super(name, age);
}
}
通过关键字super可以将参数传递给父类，AndroidStudio中可以通过点击Create constructor matching super自动生成构造函数。接下来看看Kotlin是如何处理这个问题的。
2.2 继承中Kotlin的构造函数
在Kotlin中实现这种功能，只需要极少的代码量就可以实现：
// Person
open class Person(var name:String, var age:Int) {
// Empty Code
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
// Empty Code
}
fun main() {
val man = Man("Tom", 22)
println("name is ${
man.name} age is ${
man.age}")
}
打印结果：
name is Tom age is 22
通过Man类的构造函数传递参数name和age，再通过: Person(name, age)传递到父类。
有人可能要问了，如果不加上后面的: Person(name, age)是否可行？
显然是不行的，Man类的构造函数没有var，那么它们就只是Man类构造函数的参数，不是类的成员变量。
那么如果Man类加上var是否可以？
答案也是不行的，这样父类和子类就会有两套成员变量，肯定会报错的。但是，我们可以重写父类的成员变量，后面会详细讲到。
2.3 Kotlin多个构造函数的情况
Kotlin是有主次构造函数之分的，如果一个父类有多个构造函数，那么子类是如何继承的呢？
第一种写法：
// Person类，这里有三个构造函数
open class Person(var name: String, var age: Int) {
constructor(name: String): this(name, -1)
constructor(age: Int): this("", age)
}
// Man类
class Man(name: String, age: Int) : Person(name, age) {
// Empty Code
}
父类有多个构造函数的情况，可以和上面一样这么写。但是，这样就不能以次构造函数的方式去创建一个对象。
fun main(){
val man = Man("Tom") // 报错！
println("name is ${
man.name} age is ${
man.age}")
}
造成这种情况的原因是，我们只重写了父类的主构造函数，没有重写父类的次构造函数。针对这种情况，我们可以这样写。同样是上面的例子，代码如下：
// Person类，这里有三个构造函数
open class Person(var name: String, var age: Int) {
constructor(name: String): this(name, -1) // 次构造函数
constructor(age: Int): this("", age) // 次构造函数
}
// Man类
class Man: Person {
constructor(name: String, age: Int) : super(name, age) // 对应Person类的主构造函数
constructor(name: String) : super(name) // 对应Person类的constructor(name: String)
constructor(age: Int) : super(age) // 对应Person类的constructor(age: Int)
}
直接将父类的三个次构造函数再复写一遍，用super指向父类的构造函数就行了。
为了方便快速的构建，可以利用AndroidStudio的快捷创建方式：
首先在类的内部点击鼠标右键，弹出如下菜单：
在弹出的菜单中点击Generate按钮，再弹出以下菜单：
最后点击Secondary Constructor按钮，选择你需要重写的构造函数：
通过这种快捷方式可以快速的重写父类的所有主次构造函数。
三. 重写和重载
这一章节重点讲解重写，至于重载，可以看我之前的文章Kotlin学习之路(三)：函数
中的1.3小结
3.1 方法的重写
代码还是上面的例子，只不过父类里面多一个测试方法：
// Person
open class Person(var name:String, var age:Int) {
open fun testMethod(){
// 注意这里加上了open，表示可以被重写。默认情况下是fina
println("父类test!")
}
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
override fun testMethod(){
// 类似Java的override重写标志
println("子类test!")
}
}
fun main(){
val man = Man("Tom", 22)
man.testMethod()
}
输出结果：
子类test!
这里需要着重介绍的一点的是，Kotlin的方法不加修饰符之前都是public final 的，特别是final ，所以在需要被重写的方法中加上open修饰符。
重写方法需要遵循 两同、两小、一大的原则。
- 两同：方法名相同，参数类型相同
// Person
open class Person(var name:String, var age:Int) {
open fun testMethod(str: String){
println("父类test! $str")
}
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
override fun testMethod(str: String){
println("子类test! $str")
}
}
fun main(){
val man = Man("Tom", 22)
man.testMethod("aaa")
}
- 两小：子类返回值类型比父类返回值类型(返回值类型范围)小或相等、子类抛出异常类型比父类小或相等
// Person
open class Person(var name:String, var age:Int) {
open fun testMethod(): Any?{
println("父类test!")
return null
}
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
override fun testMethod(): String{
println("子类test!")
return "test"
}
}
上面的例子父类的方法的返回值类型是Any?，子类的方法的返回值类型是String，从继承关系看，String继承于Any?，范围自然是Any?大于String。不过这种情况一般用的不多。
- 一大：子类的修饰符权限比父类的修饰符权限大或相等
// Person
open class Person(var name:String, var age:Int) {
protected open fun testMethod(): Any?{
println("父类test!")
return null
}
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
override fun testMethod(): String {
// 如果这里改为private就会报错
println("子类test!")
return "test"
}
}
3.2 属性的重写
属性的重写和方法的重写类似：
// Person
open class Person(var name:String, var age:Int) {
open var test = -1 // 和方法一样，加上了open
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
override var test = 0 // 这里加上了override标志
}
fun main(){
val man = Man("Tom", 22)
println("test value is ${
man.test}")
}
输出结果：
test value is 0
从结果可以看出父类的成员变量test被子类重写了。一般情况下这种功能较少使用，重写属性可能会破坏里氏替换原则（子类可以扩展父类的功能，但不能改变父类原有的功能）
四. super关键字
Kotlin和Java一样也是有super关键字的。和Java的用法也是类似的，都是指代父类，用法也和Java相似。
4.1 简单用法
// Person
open class Person(var name:String, var age:Int) {
// Empty Code
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
fun test(){
println("name is ${
super.name}")
}
}
fun main(){
val man = Man("Tom", 22)
man.test()
}
输出结果：
name is Tom
上面的例子多少有点脱裤子放屁的意思，实际上可以去掉super，这里只是为了演示。它的主要作用还是用于方法重写上面。
4.2 复杂情况下的用法
这里介绍相对复杂的情况下的super的用法。
4.2.1 子类重写方法中使用super
在重写方法中使用super的方式基本和Java一样：
// Person
open class Person(var name:String, var age:Int) {
open var test = -1
open fun testMethod(){
println("父类test!")
}
}
// Man类
class Man(name: String, age: Int): Person(name, age) {
override var test = 0
override fun testMethod() {
super.testMethod() // 和Java的用法一样，调用父类Person的方法testMethod
println("test value is ${
super.test}") // 调用的是父类Person的test
}
}
fun main(){
val man = Man("Tom", 22)
man.testMethod()
}
输出结果：
父类test!
test value is -1
4.2.2 子类选择性调用父接口/父类的方法
当Kotlin的类继承父类和多个接口的时候，这就需要区分super调用的是哪一个父类的方法。Kotlin中通过super<父类/父接口>.方法方式调用父类/接口的方法
// Australopithecus接口，写法和Java类似
interface Australopithecus{
fun testMethod(){
println("接口test!")
}
}
// Person
open class Person {
open fun testMethod(){
println("父类test!")
}
}
// Man类，既继承了父类Man，也实现了接口Australopithecus
class Man: Person(), Australopithecus {
override fun testMethod() {
super<Australopithecus>.testMethod()
super<Person>.testMethod()
}
}
fun main(){
val man = Man()
man.testMethod()
}
输出结果：
接口test!
父类test!
4.2.3 子类内部类调用父类方法
这种情况在于子类的内部类调用父类的方法，写法类似这样：super@子类.方法
// Person
open class Person {
open fun testMethod(){
println("父类test!")
}
}
// Man类
class Man: Person() {
// 被inner修饰的内部类是非静态内部类，静态内部类显然不能访问非静态内部类的成员方法
inner class Heart{
fun testMethod(){
super@Man.testMethod()
}
}
}
fun main(){
Man().Heart().testMethod()
}
输出结果：
父类test!
其实this在内部类中也有类似的用法：
// Man类
class Man {
fun eat(){
println("eat!")
}
inner class Heart{
fun testMethod(){
this@Man.eat() // 调用外部类的方法，这种操作更加常见
}
}
}
fun main(){
Man().Heart().testMethod()
}
输出结果：
eat!
记住无论是super还是this的@后面一定是子类！