kotlin继承 - JavaShuo

继承语法

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

/**定义一个基类，必须有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 ... 鹊吃谷物自由飞翔鹊死了ide

接口中的属性与继承 在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关键字去调用父类的方法时，会调用哪个父类的同名方法呢？

类的多继承：

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 ....this

接口的多继承

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设计

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

类型转换

提出类的继承机制的初衷，大致上处于如下两个方面考虑：对象

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

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

能够向上转型，不能向下转
编译期不报错，运行时报错

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

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

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

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