本文是学习Kotlin的类和继承相关，嵌套类相关，接口相关。
类
Kotlin的类的声明与Java一样，使用class关键字1
2class Invoice {
}
类的声明包含类名，类头(指定类型参数，主构造函数等等)，以及类主体，用大括号包裹。类头和类体是可选的；如果没有类体可以省略大括号。1
class Empty
构造函数
Kotlin的类有两种构造函数，一种是主构造函数，一种是二级构造函数。
主构造函数是写在类名后面(可以有可选的类型参数)，使用constructor关键字声明1
2class Person constructor(firstName: String) {
}
如果一个非抽象类没有声明构造函数(主构造函数或二级构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想类有公共的构造函数，就得声明一个空的主构造函数1
2class DontCreateMe private constructor () {
}
如果主构造函数没有任何注释或可见性修饰符，则可以省略constructor关键字1
2class Person(firstName: String) {
}
主构造函数不包含任何代码，初始化代码应该放在以init做前缀的初始化块中1
2
3
4
5class Customer(name: String) {
init {
logger.info("Customer initialized with value ${name}")
}
}
主构造函数的参数既可以用在初始化块中，也可以用在类的属性初始化声明处1
2
3class Customer(name: String) {
val customerKry = name.toUpperCase()
}
一般用Java写构造函数的时候，里面是写属性的初始化，如下面1
2
3
4
5
6
7
8
9
10class Person {
private String firstName;
private String lastName;
private int age;
Person(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
}
Kotlin有更简洁的写法，可以在主构造函数重声明属性并在主构造函数中初始化，同时可以设置属性为可变（var）或者设置为只读（val）1
2class Person(val firstName: String, val lastName: String, var age: Int){
}
如果构造函数具有注解(@Inject)或可见性修饰符(public)，则constructor关键字必须写上，并且写在可见性和注解的后面1
class Customer public constructor(name: String) { }
二级构造函数
二级构造函数同样是以constructor关键字来声明，与主构造函数不同的是，二级构造函数是写在类里面，同时，二级构造函数可以有多个。1
2
3
4
5
6
7
8
9class Person {
constructor(parent: Person) {
parent.children.add(this)
}
constructor(parent: Person, count: Int) {
parent.children.add(this)
}
}
如果该类有主构造函数，那么声明二级构造函数都要使用this关键字来代理(Delegation)主构造函数1
2
3
4
5
6
7
8class Person(val name: String) {
constructor(name: String, paret: Person) : this(name) {
parent.children.add(this)
}
constructor(name: String, parent: Person, count: Int) : this(name) {
parent.children.add(this)
}
}
注意：在 JVM 虚拟机中，如果主构造函数的所有参数都有默认值，编译器会生成一个附加的无参的构造函数，这个构造函数会直接使用默认值。
1 | class Customer(val customerName: String = "") |
创建类的实例
Kotlin创建类的实例不需要像Java一样使用到new关键字，直接调用构造函数即可创建类的实例1
2
3val invoice = Invoice()
val customer = Customer("Joe Smith")
类成员
Kotlin的类里面可以包含
- 构造函数和初始化块(
Constructors and initializer blocks) - 函数(
Functions) - 属性(
Properties) - 嵌套类和内部类(
Nested and Inner Classes) - 数据对象(
Object Declarations)
继承
Kotlin中的所有类都有一个公共的父类Any1
class Example // 隐式继承自Any
Any不是java.lang.Object，Any只包含equals(),hashCode()以及toString()三个成员
如何继承一个类，声明一个类的父类呢，在类后面加冒号然后再加父类1
2
3open class Base(p: Int)
class Derived(p: Int) : Base(p)
注意一个类如果要被别的类继承，要加上
open关键字，在类名的最前面，默认情况下，Kotlin中的所有类都是final的，Kotlin的接口以及成员默认都是open。
同样，如果父类有主构造函数，则子类必须在主构造函数中初始化1
2
3
4
5
6
7
8
9
10
11/**
* 父类
*/
open class BaseKot(name: String) {
}
/**
* 子类
*/
class Kot(name: String) : BaseKot(name) {
}
如果子类没有主构造函数，则可以在二级构造函数中使用super关键字初始化或者在代理(Delegation)另一个构造函数。1
2
3
4
5
6
7
8
9
10
11
12
13
14/**
* 父类
*/
open class BaseKot(name: String) {
}
/**
* 子类
*/
class Kot : BaseKot {
constructor(name: String) : super(name) {
}
}
下面这种情形中不同的二级构造函数可以调用父类不同的构造方法1
2
3
4
5
6class MyView : View {
constructor(ctx: Context) : super(ctx) {
}
constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
}
}
重写方法
上面说了，如果一个类要被继承需要在父类的类名前面加上open关键字，该类才能被继承，同样，一个父类的方法如果要能被重写，也需要加上open关键字，如果没有加的话，子类是不能重写改方法的。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19/**
* 父类
*/
open class BaseKot {
open fun v() {}
fun nv() {}
}
/**
* 子类
*/
class Kot : BaseKot() {
// 加final可以设置不被重写
override fun v() {
super.v()
}
// 重写nv方法会报错，加override也不行，只有父类的nv方法设置为open才行
// fun nv() { }
}
同样，如果类不是
open的话，里面的成员也不允许设置为open
重写属性
重写属性与重写方法类似，并且属性必须具有兼容类型，可以将val属性重写成var，也可以将var属性重写成val1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18/**
* 父类
*/
open class BaseKot {
open val age: Int get() = 0 // get() = 0 与 = 0相同
open fun v() {}
}
/**
* 子类
*/
class Kot : BaseKot() {
override var age: Int = 5 // 重写为var类型
override fun v() {
super.v()
}
}
可以在子类的主构造函数中声明override1
2
3
4
5
6class Kot(override var age: Int) : BaseKot() {
override fun v() {
super.v()
}
}
使用super实现
子类中的代码可以使用super关键字调用其父类的函数与属性访问器的实现：1
2
3
4
5
6
7
8
9
10
11
12
13open 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
11class 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<Base>来表示
1 | open class A { |
可以同时从A B中继承方法，而且C继承a()或b()的实现没有任何问题，因为它们都只有一个实现。但是f()有两个实现，所以要在C中必须复写f()并且提供自己的实现。
抽象类
与Java类似，Kotlin的类或者成员都可以被声明为abstract，同时不需要添加open关键字。
可以用一个抽象成员去复写一个带 open 注解的非抽象方法1
2
3
4
5
6
7open class Base {
open fun f() {}
}
abstract class Derived : Base() {
override abstract fun f()
}
枚举类
Kotlin也支持枚举，每个枚举常量都是一个对象。1
2
3enum class Direction {
NORTH, SOUTH, WEST, EAST
}
初始化
由于每个枚举都是枚举类的实例，因此可以进行初始化1
2
3
4
5enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
匿名类
枚举常量也可以使用对应的方法声明自己的匿名类，以及覆盖基本方法。
注意，与Java一样，如果枚举类定义了任何成员，则需要使用分号将成员定义中的枚举常量定义分隔开。
1 | enum class ProtocolState { |
使用枚举常量
就像在Java中一样，Kotlin中的枚举类有合成方法，允许列出定义的枚举常量，并通过名称获取枚举常量。这些方法的签名如下（假设枚举类的名称是EnumClass）：
EnumClass.valueOf(value: String): EnumClass
EnumClass.values(): Array<EnumClass>
如果指定的名称与类中定义的任何枚举常量不匹配，该valueOf()方法将抛出IllegalArgumentException。
每个枚举常量都具有在枚举类声明中获取其名称和位置的属性：
val name: String
val ordinal: Int
密封类
密封类是用来表示受限的类层次结构。例如当一个值为有限集中的 类型、而不能有任何其他类型时。在某种意义上,他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例,而密封类的一个子类可以有可包含状态的多个实例。
密封类是类名前加sealed关键字来声明1
2
3
4
5sealed class Expr {
class Const(val number: Double) : Expr()
class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
}
在1.1之后，数据类扩展包括密封类在内的其他类的可能性，这样写1
2
3
4sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
密封类子类的扩展可以在任何地方，不必在密封类声明内部进行
使用密封类的最主要的的好处体现在使用when表达式。可以确保声明可以覆盖到所有的情形，不需要再使用 else情形。1
2
3
4
5
6
7fun eval(expr: Expr): Double = when(expr) {
is Const -> expr.number
is Sum -> eval(expr.e1) + eval(expr.e2)
NotANumber -> Double.NaN
// 前面说过，使用when的时候除非能把所有可能的情况都列举出来，不然一定要加上else
// 这里就不需要，因为列举了所有的情况
}
嵌套类
与Java一样，一个类中可以嵌套其他的类1
2
3
4
5
6class Outer {
private val bar: Int = 1
class Nested {
fun foo() = 2
}
}
如何调用1
val demo = Outer.Nested().foo() //==2
内部类
内部类是使用inner关键字来声明。1
2
3
4
5
6class Outer {
private val bar: Int = 1
inner class Inner {
fun foo() = bar
}
}
如何调用1
val demo = Outer().Inner().foo() // == 1
嵌套类与内部类的区别是：嵌套类不能够访问外部成员，因为内部类包含对外部类的对象的引用，所以能够访问外部类的成员；调用的时候，内部类需要使用外部类的实例来调用。
接口
Kotlin的接口类似与Java 8，都可以包含抽象方法，以及方法的实现。和抽象类不同的是，接口不能保存状态。可以有属性但必须是抽象的，或者提供访问器(getter)的实现。
接口的定义同样是使用interface关键字1
2
3
4
5
6interface MyInterface {
fun bar()
fun foo() {
// 函数体是可选的，自己实现方法
}
}
实现接口
一个类或对象可以实现一个或多个接口1
2
3
4
5class Child : MyInterface, YouInterface {
override fun bar() {
// body
}
}
接口中的属性
1 | interface MyInterface { |
解决重写冲突
同类的重写类似，接口也一样，如果父类中声明了许多类型，有可能出现一个方法的多种实现，必须复写这个成员并且提供自己的实现，要使用父类中提供的方法，用super<Base>来表示1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20interface A {
fun foo() { print("A") }
fun bar()
}
interface B {
fun foo() { print("B") }
fun bar() { print("bar") }
}
class C : A {
override fun bar() { print("bar") }
}
class D : A, B {
override fun foo() {
super<A>.foo()
super<B>.foo()
}
}
上面的代码是A，B接口都有声明了foo()，bar()函数，都实现了foo()方法，但只有B实现了bar()，bar()在A中并没有声明它是抽象的，C实体类需要重写并实现bar()，而D类，不用重写bar()方法，因为继承的B接口已经实现了。由于继承了两个foo()的实现，所以用super<Base>来区分。