Kotlin-Anko学习(4) Kotlin语法-类、继承、抽象类

本系列文章来学习 Kotlin 和 Anko 插件通过 Kotlin 开发一个 Android 项目。

Kotlin-Anko学习(1) Kotlin、Anko 介绍
 Kotlin-Anko学习(2) Kotlin 语法基础-基本类型
 Kotlin-Anko学习(3) Kotlin 语法基础-关键字 package、Import、if、when、for、while、return、break、continue
Kotlin-Anko学习(4) Kotlin语法-类、继承、抽象类
 Kotlin-Anko学习(5) Kotlin语法-属性、字段、接口

Kotlin 类

与Java相同，类由 class 关键字声明。

类声明的组成

类名 TestKot：

class TestKot{...}

类头在类名后声明属性、指定其类型参数、主构造函数等。如

 /**
  * val 声明不变的属性，var声明可变属性
  * firstName  lastName 指定为String类型参数 age为Int类型参数
  * Person(...) 为主构造函数，是类头的一部分，如果没有类没有声明构造函数(primary、secondary都没有)，系统会默认生成一个无惨构造函数，与java类似。
  */
class Person(val firstName: String, val lastName: String, var age: Int) {
    // ...
}

类体 TestKot： class TestKot{...} 大括号中为类体部分，如果类没有类头，类体可以简写成class TestKot。类体中可以包含：

构造函数和初始化块

函数

属性

嵌套类和内部类

对象声明

构造函数、属性初始化、初始化块

Kotlin 中一个类可以包含一个主构造函数和一个或多个次构造函数，用关键字constructor修饰

Kotlin 中属性初始化可以在类头中，也可以在类体中写，并且可以获得主构造函数的参数值

Kotlin 中由于主构造函数在类头中，不能写初始化代码，所以Kotlin 通过一个关键字 init 来包含初始化代码块

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

//省略constructor的写法，默认为public
class TestKot(name: String) {……}
//包含注解
class TestKot public @Inject constructor(name: String) { …… }
//声明主构造函数为私有
class TestKot private constructor(name: String){......}

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

class Constructors(name:String) {
    //第一个属性初始化
    val firstProperty = "First property: $name".also(::println)
    //第一个init初始化块
    init {
        println("Init first")
    }
     //次构造函数委托给次构造函数（间接）
    constructor(name:String,age: Int,weight:Int):this(name,age) {
        println("Constructor name = $name age = $age weight = $weight kg")
    }
    //次构造函数委托给主构造函数（直接）
    constructor(name:String,age: Int):this(name) {
        println("Constructor name = $name age = $age")
    }
     //第二个init初始化块
    init {
        println("Init second")
    }
     //第二个属性初始化
    val secondProperty = "Second property: $name ".also(::println)
}

fun main(args: Array<String>) {
    Constructors("张三")
    print("--------------------------------------------\n")
    Constructors("李四",16)
    print("--------------------------------------------\n")
    Constructors("王五",17,55)
}

运行结果：

First property: 张三
Init first
Init second
Second property: 张三 
--------------------------------------------
First property: 李四
Init first
Init second
Second property: 李四 
Constructor name = 李四 age = 16
--------------------------------------------
First property: 王五
Init first
Init second
Second property: 王五 
Constructor name = 王五 age = 17
Constructor name = 王五 age = 17 weight = 55 kg

从以上代码可以看出，属性初始化和init初始化代码块是按顺序执行的，次构造函数式在属性初始化和init执行完才开始的，所以可以把属性初始化和init初始化代码块当做主构造函数体来理解。这样构造函数部分就讲完了。

类的实例化

Kotlin 中类的实例化就像普通函数一样直接调用，如上面的main函数中的示例，不需要new与java不同，也没有new关键字。

Kotlin 继承

与java不同，kotlin中类的继承在类头后加冒号： “Current类：Base类”

Any 超类

Kotlin 中所有类都有一个共同的超类 Any,不同于java的Object类，只有三个方法代码如下：

public open class Any {

    public open operator fun equals(other: Any?): Boolean

    public open fun hashCode(): Int

    public open fun toString(): String
}

open关键字

open 标注与 Java 中 final 相反，它允许其他类从这个类继承。默认情况下，在 Kotlin 中所有的类都是 final，抽象类不需要用open修饰。

//超类型
open class Base(p: Int)
//基类
class Current(p: Int) : Base(p)

上面代码可以看出超类有构造函数的话，其基类可以（并且必须）用（基类型的）主构造函数参数就地初始化。

super 关键字

super与java类似，用于超类属性、方法的实现，这里我们看派生类如何初始化超类的构造函数

//超类型
open class Base {
    constructor(name:String ,age:Int)
    constructor(name: String,age: Int,weight:Int):this(name,age)
}
//基类 示例1
class Current(name: String, age: Int) : Base(name, age) {
  //constructor(name: String,age: Int,weight:Int):super(name,age,weight)//报错
}
//基类 示例2
class Current(name: String,age: Int,weight:Int) : Base(name,age,weight) {
 //constructor(name: String,age: Int):super(name,age)//报错
}
//基类 示例3
class Current : Base {
    constructor(name: String,age: Int):super(name,age)
    constructor(name: String,age: Int,weight:Int):super(name,age,weight)
}

以上代码可以看出，超类没有主构造函数，基类可以通过主构造函数初始化超类的任意一个次构造函数，在此基础上，基类的次构造函数不能通过super来初始化超类的其他次构造函数，如示例1,2；基类也可以不声明主构造函数，通过次构造函数super来初始化对应的次构造函数，如示例3。

override 关键字

Kotlin 中 override 只能修饰父类显式标注可覆盖的成员（开放open），父类中没有显式标注的成员在其子类中不允许定义相同签名的函数。

覆盖方法

open class Base {
    open fun v() {}
    fun nv() {}
}
//示例1
class Bar1() : Base() {
    override fun v() {}
//     override  fun nv(){}//error:'nv' in 'Base' is final and cannot be overridden
//     fun nv(){}//error: 'nv' hides member of supertype 'Base' and needs 'override' modifier
}
//示例2
class Foo {
//    open val x: Int get() { return 1 } //Warning:'open' has no effect in a final class
//示例3
open class Bar2() : Base() {
    final override fun v() {}
}

示例1：说明父类的显式标注方法，在子类中可以通过override修饰的相同方法覆盖，对于没有开放的函数，不论加不加 override，都不允许定义与父类相同签名的方法。
示例2：说明在一个 final 类中（没有用 open 标注的类），open修饰的方法没有用
示例3：说明子类重写的方法如果想在，子类的子类中不被继续重写，可以在override前用final 进行修饰。

覆盖属性

open class Foo {
    open val x: Int =1
    open val y: Int get(){return 5}
}
示例1
class Bar1 : Foo() {
    override val x: Int = 2
    init{
        print("x= $x \n")
        print("y= $y \n")
    }

}
示例2
class Bar2 : Foo(){
    override var x : Int = 3
    init{
        print("x= $x")
    }
}
fun main(args: Array<String>) {
    Bar1()
    Bar2()
}

输出结果：

x= 2 
x= 5
x= 3

重写属性的规则也是通过override进行修饰，并且派生类的重写的属性必须兼容超类的属性，示例1可以看出
声明的属性由具有初始化器的属性或者具有 getter 方法的属性覆盖，示例2可以看出用一个 var 属性覆盖一个 val 属性是可以的，本质上var的get方法覆盖了val的get方法，并且在派生类额外生成一个set方法。

调用超类的实现

调用超类中的方法与java相同，通过super关键字修饰，属性属kotlin独有的。

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
    init{
        println("x= $x")
    }
}
fun main(args: Array<String>) {
    Bar().f()
}

输出结果：

x= 2
Foo.f()
Bar.f()

以上就是派生类中调用超类具体的实现，跟java相似。

覆盖规则

既有继承又有接口的实现

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

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

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

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

输出结果：

C()
A
B

首先在派生类既有继承又有接口，并且超类、接口中存在相同的方法，派生类必须重写该方法，并且通过
surper<A>.f() 尖括号中表明实现哪个父类的方法，并且这里说明一下kotlin中接口中的方法默认是open的。

内部类中访问外部类超类的实现

open class Foo {
    open fun f() { println("Foo.f()") }
    open val x: Int get() = 1
}

class Bar : Foo() {
    override fun f() {  println("Bar.f()")}
    override val x: Int get() = 0
    
    inner class Baz {
        fun g() {
            super@Bar.f() // 调用 Foo 实现的 f()
            println(super@Bar.x) // 使用 Foo 实现的 x 的 getter
        }
    }
}
fun main(args: Array<String>) {
    Bar().Baz().g()
}

输出结果：

Foo.f()
1

内部类需要实现外部类的属性和方法，我们super@Outer().f()、super@Outer.x来实现。

抽象类

kotlin 中抽象类和java相同，通过 abstract 关键字来修饰，抽象类中可以包含抽象的方法或属性。

open class Base {
    open fun f() {}
}
abstract class Bar : Base() {
    abstract val x :Int
    override abstract fun f()
    open fun g(){println("Bar.g()")}
}
class Child() :Bar(){
    override var x: Int =2
    override fun g() {
        super.g()
        println("Child g()")
    }
    override fun f() {
       println("Child f()")
    }
}
fun main(args: Array<String>) {
  var child = Child()
    child.g()
    child.f()   
}

输出结果：

Bar.g()
Child g()
Child f()

上面的代码可以看出，非抽象的超类可以派生出抽象类，并且开放的方法可以被重写成抽象方法，抽象方法是不允许有方法体的，abstract 修饰的属性或方法默认是open的。这里与接口不同，接口中的方法默认抽象的也是默认开放的，抽象类中的方法只有抽象的方法才是默认open的。