Kotlin系列（十四）：类的继承

Luckly 收录于移动开发

2017-10-24 约 4659 字预计阅读 10 分钟次阅读

一、前言：

继承是面向对象编程的特性之一，通过继承，我们可以获得父类的方法和特性。
本章我们将参考官方文档以及个人理解来学习Kotlin中继承相关的知识点。

二、继承之Kotlin与Java的几个不同点

面向对象的编程语言都有继承这一特性，C++允许我们多继承，而在使用多继承的时候会给程序添加复杂性，为什么呢？举个简单的例子：我们有三个类A、B、C，类C继承了类A和类B，但是类A和类B都有相同的方法methodA或者属性name，此时类C如果要使用父类的方法methodA或者属性name，那么是使用A的还是B的呢？
而Java有所改进，其采用了单继承的模式，只允许类继承一个父类，但是可以通过实现多个接口来补救但继承带来的缺陷。
而我们的Kotlin同样也是但继承机制。
但是在Kotlin 中的继承模式与 Java 有一些不同之处，主要在三个地方：

1、Any

Kotlin 中所有类的最终父类是 Any，而非 Java 中的 Object。
当你不继承任何类时，默认是Any；
Any 不是 java.lang.Object；尤其是，它除了 equals()、hashCode()和toString()外没有任何成员。

2、:

java使用 extends关键字来实现类的继承。
Kotlin 中没有 extends 关键字，声明一个类继承自另一个标记为 open 的类的方式是 ：后面接上继承的类。

3、open

Java中我们需要显示的将类标记为final来禁止其被继承。
kotlin中默认类、字段、方法都是final的，所以我们需要在类前面加上open，该类才能被其他类所继承。

三、继承

继承类的语法：

  class 子类[(主构造方法参数)]: 父类[(主构造方法参数)] {……}

要声明一个显式的超类型，我们把类型放到类头的冒号之后：

创建一个Person作为父类

  package com.anjie.demo

  /**
   * Created by 安杰 on 2017/10/23. */
   open class Person(var age:Int) {
   }

创建一个User继承自Person类

  package com.anjie.demo

  /**
   * Created by 安杰 on 2017/10/23. */
  class User(var uage: Int) : Person(uage) {

  }

从上面我们可以看到，我们在继承Person的时候，需要传入age来调用Person的主构造函数。
因为Kotlin中规定，如果继承的目标类有一个主构造函数，其基类型可以（并且必须）用（基类型的）主构造函数参数就地初始化继承的目标类。
简单的说就是：目标类声明了带参数的主构造函数，实现类需要用主构造函数的参数直接初始化父类。

当然，如果你没有在类后面声明主函数，那么也可以这样子写：

  package com.anjie.demo

  /**
   * Created by 安杰 on 2017/10/23. */
   open class Person {
  		var age: Int

  		constructor(age: Int) {
  				this.age = age;
  		}

  }

  package com.anjie.demo

  /**
   * Created by 安杰 on 2017/10/23. */
  class User : Person {
  		var uage: Int

  		constructor(uage: Int) : super(uage) {
  				this.uage = uage;
  		}
  }

代码解析：
我们在次级构造函数后面需要通过super来初始化父类。
因为在Kotlin中规定：

如果类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类型，或委托给另一个构造函数做到这一点。注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数

还有一点，我们的顶部变成了：User:Person，Person后面连()都不需要，这是为什么呢？因为我们的Person并没有无参构造函数，如果你给Person编写的无参构造函数，就需要这样子了：User:Person();
记得的一点，Person一定要是open的哦。

四、方法的覆盖

我们之前提到过，Kotlin 力求清晰显式。与 Java 不同，Kotlin 需要显式标注可覆盖的成员（我们称之为_开放_）和覆盖后的成员：
在重写的方法前必须加上_override_，否则编译出错。被重写的方法必须是open的
标记为 override 的成员本身是open的，也就是说，它可以在后面的子类中继续被覆盖。
如果你想禁止再次覆盖，使用 _final_关键字：

修改Person类：

  package com.anjie.demo

  /**
   * Created by 安杰 on 2017/10/23. */open class Person {
  		var age: Int
  		var name: String = ""

  	constructor(age: Int, name: String) {
  				this.age = age;
  				this.name = name;
  		}

  		constructor(age: Int) {
  				this.age = age
  		}

  		open fun printClassName() {
  				println("my class name is User")
  		}

  }

修改User类

  package com.anjie.demo

  /**
   * Created by 安杰 on 2017/10/23. */
  class User : Person {
  		var uage: Int
  		var uname: String

  		constructor(uage: Int, uname: String) : super(uage) {
  				this.uage = uage;
  				this.uname = uname;
  		}

  		override fun printClassName() {
  				println("my class name is User")
  		}
  }

代码解析：
首先，从上面我们再次验证了类的继承，子类的次级构造函数只需要调用父类的任意构造函数进行初始化即可，当然该情况是在父类没有主构造函数的情况下。
其次，我们的子类重写了Person的printClassName方法。我们来看下一。

测试代码如下：

  class Test {

  		@Test
  	fun test1() {
  				var person = Person(1);
  				person.printClassName();
  				val user = User(2,"anjie");
  				user.printClassName();

  		}

  }

结果输出为：

  my class name is Person
  my class name is User

  - 其确实重写了Person的printClassName
  - 假设我们不重写,将其注释掉，再次运行

  class User : Person {
  		var uage: Int
  		var uname: String

  		constructor(uage: Int, uname: String) : super(uage) {
  				this.uage = uage;
  				this.uname = uname;
  		}

  //    override fun printClassName() {
  //        println("my class name is User")
  //    }
  }

运行结果为：

  my class name is Person
  my class name is Person

  - 当然，我们也可以通过super在子类中调用父类被重写的函数

  class User : Person {
  		var uage: Int
  		var uname: String

  		constructor(uage: Int, uname: String) : super(uage) {
  				this.uage = uage;
  				this.uname = uname;
  		}

  		override fun printClassName() {
  				super.printClassName();
  				println("my class name is User")

  		}
  }

结果输出为：

  my class name is Person
  my class name is Person
  my class name is User

附赠：主构造函数的好处

从上面突然发现，我们可以通过声明主构造函数来限制子类在继承我时必须要传给我哪些数据来初始化。

五、字段的覆盖

Kotlin中属性的覆盖和方法的覆盖类似

被覆盖的字段需要声明为open

  open  class  Foo  {  
  	open  val  x:  Int  get()  {  ……  }  
  	}  
  class  Bar1  :  Foo()  {  
  	override  val  x:  Int  =  ……  
  }

附赠：覆盖属性时注意点：

Kotlin中**不允许用 val 属性覆盖 var 属性。**用 val 属性覆盖 val 属性和用 var 属性覆盖 var 属性很好理解，该是什么样还是什么样嘛。此外，Kotlin 还允许用 var 属性覆盖 val 属性（只需给子类中的属性添加一个 setter 方法），但不允许用 val 属性覆盖 var 属性：

类和继承

类

Kotlin 中使用关键字 class 声明类

	class Invoice {
	}

类声明由类名、类头（指定其类型参数、主构造函数等）和由大括号包围的类体构成。类头和类体都是可选的；如果一个类没有类体，可以省略花括号。

1

class Empty

构造函数

在 Kotlin 中的一个类可以有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。

1
2


class Person constructor(firstName: String) {
}

如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。

1
2


class Person(firstName: String) {
}

主构造函数不能包含任何的代码。初始化的代码可以放到以 init 关键字作为前缀的**初始化块（initializer blocks）**中：

1
2
3
4
5


class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}

注意，主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用：

1
2
3


class Customer(name: String) {
    val customerKey = name.toUpperCase()
}

事实上，声明属性以及从主构造函数初始化属性，Kotlin 有简洁的语法：

1
2
3


class Person(val firstName: String, val lastName: String, var age: Int) {
    // ……
}

与普通属性一样，主构造函数中声明的属性可以是可变的（var）或只读的（val）。

如果构造函数有注解或可见性修饰符，这个 constructor 关键字是必需的，并且这些修饰符在它前面：

1

class Customer public @Inject constructor(name: String) { …… }

更多详情，参见可见性修饰符

次构造函数

类也可以声明前缀有 _constructor_的次构造函数：

1
2
3
4
5


class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}

如果类有一个主构造函数，每个次构造函数需要委托给主构造函数，可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字即可：

1
2
3
4
5


class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是 public。如果你不希望你的类有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数：

1
2


class DontCreateMe private constructor () {
}

注意：在 JVM 上，如果主构造函数的所有的参数都有默认值，编译器会生成一个额外的无参构造函数，它将使用默认值。这使得 Kotlin 更易于使用像 Jackson 或者 JPA 这样的通过无参构造函数创建类的实例的库。
1
class Customer(val customerName: String = "")

创建类的实例

要创建一个类的实例，我们就像普通函数一样调用构造函数：

1
2
3


val invoice = Invoice()

val customer = Customer("Joe Smith")

注意 Kotlin 并没有 new 关键字。

创建嵌套类、内部类和匿名内部类的类实例在嵌套类中有述。

类成员

类可以包含：

继承

在 Kotlin 中所有类都有一个共同的超类 Any，这对于没有超类型声明的类是默认超类：

1

class Example // 从 Any 隐式继承

Any 不是 java.lang.Object；尤其是，它除了 equals()、hashCode()和toString()外没有任何成员。更多细节请查阅Java互操作性部分。

要声明一个显式的超类型，我们把类型放到类头的冒号之后：

1
2
3


open class Base(p: Int)

class Derived(p: Int) : Base(p)

如果该类有一个主构造函数，其基类型可以（并且必须）用（基类型的）主构造函数参数就地初始化。

如果类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类型，或委托给另一个构造函数做到这一点。注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数：

1
2
3
4
5


class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

类上的 open 标注与 Java 中 final 相反，它允许其他类从这个类继承。默认情况下，在 Kotlin 中所有的类都是 final，对应于 Effective Java书中的第 17 条：要么为继承而设计，并提供文档说明，要么就禁止继承。

覆盖方法

我们之前提到过，Kotlin 力求清晰显式。与 Java 不同，Kotlin 需要显式标注可覆盖的成员（我们称之为_开放_）和覆盖后的成员：

1
2
3
4
5
6
7


open class Base {
    open fun v() {}
    fun nv() {}
}
class Derived() : Base() {
    override fun v() {}
}

Derived.v() 函数上必须加上 override标注。如果没写，编译器将会报错。如果函数没有标注 open 如 Base.nv()，则子类中不允许定义相同签名的函数，不论加不加 override。在一个 final 类中（没有用 open标注的类），开放成员是禁止的。

标记为 override 的成员本身是开放的，也就是说，它可以在子类中覆盖。如果你想禁止再次覆盖，使用 _final_关键字：

1
2
3


open class AnotherDerived() : Base() {
    final override fun v() {}
}

覆盖属性

属性覆盖与方法覆盖类似；在超类中声明然后在派生类中重新声明的属性必须以 override 开头，并且它们必须具有兼容的类型。每个声明的属性可以由具有初始化器的属性或者具有 getter 方法的属性覆盖。

1
2
3
4
5
6
7


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

class Bar1 : Foo() {
    override val x: Int = ……
}

你也可以用一个 var 属性覆盖一个 val 属性，但反之则不行。这是允许的，因为一个 val 属性本质上声明了一个 getter 方法，而将其覆盖为 var 只是在子类中额外声明一个 setter 方法。

请注意，你可以在主构造函数中使用 override 关键字作为属性声明的一部分。

1
2
3
4
5
6
7
8
9


interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}

调用超类实现

派生类中的代码可以使用 super 关键字调用其超类的函数与属性访问器的实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


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：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Bar : Foo() {
    override fun f() { /* …… */ }
    override val x: Int get() = 0

    inner class Baz {
        fun g() {
            super@Bar.f() // 调用 Foo 实现的 f()
            println(super@Bar.x) // 使用 Foo 实现的 x 的 getter
        }
    }
}

六、覆盖规则

在 Kotlin 中，实现继承由下述规则规定：如果一个类从它的直接超类继承相同成员的多个实现，它必须覆盖这个成员并提供其自己的实现（也许用继承来的其中之一）。为了表示采用从哪个超类型继承的实现，我们使用由尖括号中超类型名限定的 super，如 super：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // 接口成员默认就是“open”的
    fun b() { print("b") }
}

class C() : A(), B {
    // 编译器要求覆盖 f()：
    override fun f() {
        super<A>.f() // 调用 A.f()
        super<B>.f() // 调用 B.f()
  }
}

同时继承 A 和 B 没问题，并且 a() 和 b() 也没问题因为 C 只继承了每个函数的一个实现。但是 f() 由 C 继承了两个实现，所以我们必须在 C 中覆盖 f() 并且提供我们自己的实现来消除歧义。

七、总结

本章我们学习的知识点稍微有点多，有些案例直接参考了官网，有些自己来写。主要学习了类的继承与属性的重写相关的知识点
大家可以慢点看，效果会好一些。

更新于 2017-10-24

阅读原始文档

kotlin

返回 | 主页

目录