Kotlin学习（七）: 类和继承、接口与实现

本文是学习Kotlin的类和继承相关，嵌套类相关，接口相关。

类

Kotlin的类的声明与Java一样，使用class关键字

class Invoice {}

类的声明包含类名，类头(指定类型参数，主构造函数等等)，以及类主体，用大括号包裹。类头和类体是可选的；如果没有类体可以省略大括号。

class Empty

构造函数

Kotlin的类有两种构造函数，一种是主构造函数，一种是二级构造函数。
主构造函数是写在类名后面(可以有可选的类型参数)，使用constructor关键字声明

class Person constructor(firstName: String) {}

如果一个非抽象类没有声明构造函数(主构造函数或二级构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想类有公共的构造函数，就得声明一个空的主构造函数

class DontCreateMe private constructor () {}

如果主构造函数没有任何注释或可见性修饰符，则可以省略constructor关键字

class Person(firstName: String) {}

主构造函数不包含任何代码，初始化代码应该放在以init做前缀的初始化块中

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

主构造函数的参数既可以用在初始化块中，也可以用在类的属性初始化声明处

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

一般用Java写构造函数的时候，里面是写属性的初始化，如下面

class 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）

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

如果构造函数具有注解(@Inject)或可见性修饰符(public)，则constructor关键字必须写上，并且写在可见性和注解的后面

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

二级构造函数

二级构造函数同样是以constructor关键字来声明，与主构造函数不同的是，二级构造函数是写在类里面，同时，二级构造函数可以有多个。

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

如果该类有主构造函数，那么声明二级构造函数都要使用this关键字来代理(Delegation)主构造函数

class 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 虚拟机中，如果主构造函数的所有参数都有默认值，编译器会生成一个附加的无参的构造函数，这个构造函数会直接使用默认值。

class Customer(val customerName: String = "")

创建类的实例

Kotlin创建类的实例不需要像Java一样使用到new关键字，直接调用构造函数即可创建类的实例

val invoice = Invoice()val customer = Customer("Joe Smith")

类成员

Kotlin的类里面可以包含
- 构造函数和初始化块(Constructors and initializer blocks)
- 函数(Functions)
- 属性(Properties)
- 嵌套类和内部类(Nested and Inner Classes)
- 数据对象(Object Declarations)

继承

Kotlin中的所有类都有一个公共的父类Any

class Example // 隐式继承自Any

Any不是java.lang.Object，Any只包含equals(),hashCode()以及toString()三个成员

如何继承一个类，声明一个类的父类呢，在类后面加冒号然后再加父类

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

注意一个类如果要被别的类继承，要加上open关键字，在类名的最前面，默认情况下，Kotlin中的所有类都是final的，Kotlin的接口以及成员默认都是open。

同样，如果父类有主构造函数，则子类必须在主构造函数中初始化

/*** 父类*/open class BaseKot(name: String) {}/*** 子类*/class Kot(name: String) : BaseKot(name) {}

如果子类没有主构造函数，则可以在二级构造函数中使用super关键字初始化或者在代理(Delegation)另一个构造函数。

/*** 父类*/open class BaseKot(name: String) {}/*** 子类*/class Kot : BaseKot {    constructor(name: String) : super(name) {    }}

下面这种情形中不同的二级构造函数可以调用父类不同的构造方法

class MyView : View {    constructor(ctx: Context) : super(ctx) {    }    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {    }}

重写方法

上面说了，如果一个类要被继承需要在父类的类名前面加上open关键字，该类才能被继承，同样，一个父类的方法如果要能被重写，也需要加上open关键字，如果没有加的话，子类是不能重写改方法的。

/*** 父类*/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属性重写成val

/*** 父类*/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()    }}

可以在子类的主构造函数中声明override

class Kot(override var age: Int) : BaseKot() {    override fun v() {        super.v()    }}

使用super实现

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

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：

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<Base>来表示

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 {    // The compiler requires f() to be overridden:    override fun f() {        super<A>.f() // call to A.f()        super<B>.f() // call to B.f()    }}

可以同时从A B中继承方法，而且C继承a()或b()的实现没有任何问题，因为它们都只有一个实现。但是f()有两个实现，所以要在C中必须复写f()并且提供自己的实现。

抽象类

与Java类似，Kotlin的类或者成员都可以被声明为abstract，同时不需要添加open关键字。
可以用一个抽象成员去复写一个带 open 注解的非抽象方法

open class Base {    open fun f() {}}abstract class Derived : Base() {    override abstract fun f()}

枚举类

Kotlin也支持枚举，每个枚举常量都是一个对象。

enum class Direction {    NORTH, SOUTH, WEST, EAST}

初始化

由于每个枚举都是枚举类的实例，因此可以进行初始化

enum class Color(val rgb: Int) {        RED(0xFF0000),        GREEN(0x00FF00),        BLUE(0x0000FF)}

匿名类

枚举常量也可以使用对应的方法声明自己的匿名类，以及覆盖基本方法。

注意，与Java一样，如果枚举类定义了任何成员，则需要使用分号将成员定义中的枚举常量定义分隔开。

enum class ProtocolState {    WAITING {        override fun signal() = TALKING    },    TALKING {        override fun signal() = WAITING    };    abstract fun signal(): ProtocolState}

使用枚举常量

就像在Java中一样，Kotlin中的枚举类有合成方法，允许列出定义的枚举常量，并通过名称获取枚举常量。这些方法的签名如下（假设枚举类的名称是EnumClass）：

EnumClass.valueOf(value: String): EnumClass

EnumClass.values(): Array<EnumClass>

如果指定的名称与类中定义的任何枚举常量不匹配，该valueOf()方法将抛出IllegalArgumentException。

每个枚举常量都具有在枚举类声明中获取其名称和位置的属性：

val name: String

val ordinal: Int

密封类

密封类是用来表示受限的类层次结构。例如当一个值为有限集中的 类型、而不能有任何其他类型时。在某种意义上,他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例,而密封类的一个子类可以有可包含状态的多个实例。
密封类是类名前加sealed关键字来声明

sealed class Expr {    class Const(val number: Double) : Expr()    class Sum(val e1: Expr, val e2: Expr) : Expr()    object NotANumber : Expr()}

密封类子类的扩展可以在任何地方，不必在密封类声明内部进行

使用密封类的最主要的的好处体现在使用when表达式。可以确保声明可以覆盖到所有的情形，不需要再使用 else情形。

fun eval(expr: Expr): Double = when(expr) {    is Const -> expr.number    is Sum -> eval(expr.e1) + eval(expr.e2)    NotANumber -> Double.NaN    // 前面说过，使用when的时候除非能把所有可能的情况都列举出来，不然一定要加上else    // 这里就不需要，因为列举了所有的情况}

嵌套类

与Java一样，一个类中可以嵌套其他的类

class Outer {    private val bar: Int = 1    class Nested {        fun foo() = 2    }}

如何调用

val demo = Outer.Nested().foo() //==2

内部类

内部类是使用inner关键字来声明。

class Outer {    private val bar: Int = 1    inner class Inner {        fun foo() = bar    }}

如何调用

val demo = Outer().Inner().foo() // == 1

嵌套类与内部类的区别是：嵌套类不能够访问外部成员，因为内部类包含对外部类的对象的引用，所以能够访问外部类的成员；调用的时候，内部类需要使用外部类的实例来调用。

接口

Kotlin的接口类似与Java 8，都可以包含抽象方法，以及方法的实现。和抽象类不同的是，接口不能保存状态。可以有属性但必须是抽象的，或者提供访问器(getter)的实现。
接口的定义同样是使用interface关键字

interface MyInterface {    fun bar()    fun foo() {      // 函数体是可选的，自己实现方法    }}

实现接口

一个类或对象可以实现一个或多个接口

class Child : MyInterface, YouInterface {    override fun bar() {        // body    }}

接口中的属性

interface MyInterface {    val prop: Int // abstract    val propertyWithImplementation: String        get() = "foo" // 提供访问器getter，可以直接获取propertyWithImplementation的值foo    fun foo() {        print(prop)    }}class Child : MyInterface {    override val prop: Int = 29    override val propertyWithImplementation: String = "123"}

解决重写冲突

同类的重写类似，接口也一样，如果父类中声明了许多类型，有可能出现一个方法的多种实现，必须复写这个成员并且提供自己的实现，要使用父类中提供的方法，用super<Base>来表示

interface 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>来区分。