Kotlin学习（8）：类和继承

• 开发环境：IntelliJ IEDA
• 个人博客：http://blog.csdn.net/IInmy
• 项目源码：https://github.com/Rushro2m/KotlinForOfficial
• 官方文档中文版：https://www.kotlincn.net/docs/reference/classes.html

1、类

Kotlin中使用关键字class声明类

class Invoice{
    //代码块
}

类声明由类名、类头（指定其类型参数、主构造函数等）和由大括号包围的类体构成。
比如，下面这个类中：
关键字：class
类名：Person
类头：（name：String）
类体：｛fun zoo(){}｝

class Person(name:String){
    fun zoo(){
    }
}

类头和类体都是可选的，如果一个类没有类体，可以省略花括号。

class Empty

2、构造函数

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

class Person constructor(firstName: String) {

}

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

class Person(firstName: String) {

}

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

class Customer(var name: String) {
    init {
        name = "张三"
    }
}

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

class People(name:String){
    val nameKey = name.toUpperCase()
}

3、次构造函数

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

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

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

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

4、创建类的实例

要创建一个类的实例，我们就像普通函数一样调用构造函数，Kotlin没有new关键字：

val invoice = Invoice()
val customer = Customer("张三")

5、类成员

类可以包含：

• 构造函数和初始化块
• 函数
• 属性
• 嵌套类和内部类
• 对象声明

6、继承

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

//从Any隐式继承
class Example

class Example1:Any()

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

open class Base(p: Int)

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

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

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

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

类上的open标注与Java中final相反，它允许其它类从这个类继承。默认情下，在Kotlin中所有的类都是final。

7、覆盖方法

Kotlin需要显式标注可覆盖的成员和覆盖后的成员，通过关键字open关键字来标注其可以覆盖：

open class Father{
    //open标注可以被覆盖
    open fun v(){}

    fun nv(){}
}

open class Son():Father(){
    //override标注覆盖方法
    override fun v() {}
}

如果一个类没有被open标注，那么它是不可以被继承的。如果一个方法没有被open标注，子类中不能被覆盖的，并且不允许定义相同签名的函数。

open class Father{
     fun zoo(){}
}

class Son():Father(){
    //这里会报错，不允许覆盖
     override fun zoo(){
    }
}

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

open class Daugther() : Father() {
    final override fun v() {}
}

8、覆盖属性

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

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

class Bar1 : Foo() {
    override val x: Int
        get() = super.x
}

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

open interface Zoo {
    val count: Int
}

class Bar(override val count: Int) : Zoo

class Bar2 : Zoo {
    override val count: Int = 0
}

9、覆盖规则

在Kotlin中如果一个类从它的直接超类继承相同成员的多个实现，它必须覆盖这个成员并提供其自己的实现。为了表示从哪个超类型继承的实现，我们使用由尖括号中超类型名限定的super，如super<Base>：

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

    fun a() {
        print("a")
    }
}

//接口成员默认的是open所有不需要用open标注
interface B {
    fun f() {
        print("B")
    }

    fun b() {
        print("b")
    }
}

class C() : A(), B {
    override fun f() {
        super<A>.f()//调用A.f()
        super<B>.f()//调用B.f()
    }
}

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

10、抽象类

类和其中的某些成员可以声明为abstract。抽象成员在本类中可以不同实现。需要注意的是，并需要用open标注一个抽象类或者函数。
我们可以用一个抽象成员覆盖一个非抽象的开放成员

open class BaseOne {
    open fun f() {}
}

abstract class One : BaseOne() {
    override abstract fun f()
}