kotlin继承

继承语法

类和接口的继承通过 ： 来实现

/**定义一个基类，必须有open关键字 才能被继承*/
open class Base(val p:Int) {

}

/**类继承*/
class Derived(p:Int):Base(p){

}

/**接口中的方法 默认是 open的*/
interface Animal{
    fun run()
}

//实现接口 不需要 （）
abstract class BaseAnimal() : Animal{
    var name:String ? = null
    constructor(name:String):this(){
        this.name = name
    }
}

class Dog(name: String) : BaseAnimal(name) {
    override fun run() {
        println("$name run ....")
    }
}

fun main() {
    val dog = Dog("哈士奇")
    dog.run()
}

接口

kotlin 的接口可以包含抽象方法，以及方法的实现，接口可以有属性但必须是抽象的，或者提供访问器的实现，当然java 8 中的接口也支持这些特性了。

• 接口之间的继承

interface Animal{
    fun die()
    fun eat(){
        //kotlin中的接口方法允许有函数体
        println("animal eat ... ")
    }
}

interface Bird:Animal{
    fun fly(){
        println("自由飞翔")
    }
    //直接覆盖Animal接口中的方法
    override fun eat() {
        println("bird eat ... ")
    }
}

class Magpie:Bird{
    override fun die() {
        println("鹊 死了")
    }

    override fun eat() {
        super.eat()
        println("鹊 吃谷物")
    }
}

fun main() {
    val magpie = Magpie()
    magpie.eat()
    magpie.fly()
    magpie.die()
}

bird eat …
鹊 吃谷物
自由飞翔
鹊 死了

• 接口中的属性与继承
  在kotlin中，在接口中不仅可以定义和实现方法，也可以定义属性，在接口中所声明的属性，默认是abstract类型的，因此一个类型如果实现了某个接口，则必须要复写接口中的属性。在复写接口属性时，必须添加override关键字，并且定义在接口中的属性不能被初始化。

interface Animal {
    var name: String
    fun run()
}

class Magpie(override var name: String) : Animal {
    //复写接口中的属性的两种方式
//    override var name: String = "喜鹊"

    override fun run() {
        println("喜鹊 自由飞翔")
    }
}

fun main() {
    val magpie = Magpie("喜鹊")
    magpie.run()
    println(magpie.name)
}

虚类（抽象类）

在kotlin中定义一个虚类，语法与java相似，在虚类中，可以声明类属性，构造函数，可以只定义方法头，也可以定义个包含方法体的完整方法。

abstract class Animal(val name: String) {
    var age: Int = 0
    abstract fun run()
    fun eat(){
        println("animal eat ... ")
    }
}

多重继承

• 类与接口的继承
  kotlin中也像java一样一个类（接口）可以继承多个接口，只是类继承接口的时候必须实现接口方法。和java一样一个类只能继承一个类，不能继承多个类。

interface Animal{
    fun run()
}

interface Mammal{
    fun feed()
}

interface Canine:Mammal,Animal{
    fun bite()
}

open class Bird:Animal,Mammal{
    override fun run() {
       //
    }

    override fun feed() {
        //
    }
}

//类继承 必须有（）
class Eagle : Bird(){
    
}

• 构造函数继承
  如果父类中有多个构造函数，子类随便继承父类的一个构造函数就好

open class Animal(var name:String){
    fun run(){
        println("$name run ...")
    }
}

//显示定义主构造函数类继承包含主构造函数的父类
class Mammal(name: String):Animal(name){
    fun feed(){
        println("投喂 $name")
    }
}

class Canine:Animal{
    //通过二级构造函数继承父类的主构造函数
    constructor(name: String):super(name){
        //do something
    }
}

• 接口方法的多重继承
  无论在java还是kotlin中，一个类都无法同时继承多个父类，但是如果父类又继承了另一个基类，如此便可以形成一个 “继承树”，在一棵继承树中，一个类可以有多个基类，只不过这些基类之间本身也有继承关系。在子类中，可以通过super关键字调用父类中的某个方法。当一个类的多个基类都同时定义了同一个方法时，那么在子类中通过super关键字去调用父类的方法时，会调用哪一个父类的同名方法呢？

1. 类的多继承：

open class Animal(var name:String){
   open fun run(){
       println("animal run ...")
   }
}

open class Mammal(name: String):Animal(name){
    override fun run() {
        println("mammal run ....")
    }
}
class Panda(name: String):Mammal(name){
    override fun run() {
        super.run()
    }
}
fun main() {
    val panda = Panda("盼盼")
    panda.run()
}

mammal run …

2. 接口的多继承

interface Animal{ 
    fun run(){
       println("animal run ...")
   }
}

interface Mammal:Animal{
    override fun run() {
        println("mammal run ....")
    }
}
class Panda(val name: String):Mammal,Animal{
    override fun run() {
        //这里必须使用泛型，标明调用哪一个父类的方法
        super<Mammal>.run()
    }
}

• 继承的初始化
  当子类构造函数被执行的时候，期父类以及继承体系中的所有父类的构造函数都会被执行,类的继承，不仅仅是对接口的继承，更重要的是对字段属性的继承。

open class Base{
    constructor(){
        println("base constructor")
    }
    init {
        println("base init")
    }
}
open class ExtendClass1:Base{
    constructor():super(){
        println("ExtendClass1 constructor")
    }
    init {
        println("ExtendClass1 init")
    }
}


open class ExtendClass2:ExtendClass1{
    constructor():super(){
        println("ExtendClass2 constructor")
    }
    init {
        println("ExtendClass2 init")
    }
}
fun main() {
    val base = ExtendClass2()
}

base init
base constructor
ExtendClass1 init
ExtendClass1 constructor
ExtendClass2 init
ExtendClass2 constructor

子类在实例化的时候，没有实例化父类，那为什么要调用父类的构造函数呢？主要是为了对字段属性进行初始化。

类型转换

提出类的继承机制的初衷，大体上处于以下两个方面考虑：

• 为了设计一些特殊的算法和模式
• 为了实现一成文种通用的设计思想------面向接口设计

关于类型转换，有两条不成文的规则：

1. 可以向上转型，不能向下转
2. 编译期不报错，运行时报错

在基于面向接口设计原则开发程序时，必定会发生以下两种转换：

1. 在调用接口前，会先实例化子类，将子类实例作为入参传递给接口，这里发生了隐式转换——有子类转换成基类
2. 在接口内部，则可以将基类类型的入参变量强制转换为子类，并调用子类的方法。

在第二步中，将基类强制转换为子类，是正确的——因为基类变量实际上指向的是子类实例对象
在kotlin中提供的强制转换语法是 as , 判断一个类型是 is （代替了java 中的 instanceof）

   val a:Int = 1
    val b:Long = 2L
    //强制转换
    val c:Number = b as Number
    //判断类型
    println( a is Int)