今天是面向对象的最后一节，下一节为函数式编程。

一、继承

在面向对象中继承使用的特别多，当你有几个类，属性和函数差不多。你就可以定义一个父类，然后继承它，拿到它的属性和函数，不用一直重复写。

在Kotlin中继承使用：来表示

class Student : Person() {

}

但是继承的父类必须是open的，也就是说kotlin中所有类默认是find的，而open就是取消自动find的意思。

open class Person {

    var name: String? = "人"
    var age = 20


    fun hand() {
        println("hand")
    }

}

所有类默认继承Any这个类，类似Java中的object。Kotlin和Java都是单继承多实现的规则，只允许继承一个父类，但可以实现很多接口。

重载和重写

在Java中也有重载和重写的概念。它们发生在继承得基础上，只有继承关系后才会出现。

重载：函数名相同，参数列表不同

重写：函数名相同，参数列表相同

特点：他们都需要函数名相同

this和super

this是本类，super是父类

open class Person() {
   open var name="Person"

}

class Student() : Person() {
    override var name = "Student"
    fun test() {
        println(super.name)
        println(this.name)
    }
}

fun main(args: Array<String>) {
   var student=Student()
    student.test()

}

结果：

二、多态

同一种功能多种表达形态。

多态发生的条件

继承：必须要有继承关系
重写：子类重写父类函数
声明对象是父类类型，对象是子类实例

看个例子，容易明白。

open class Person() {

   open fun speak() {
        println("说话")
    }
}

发生了继承关系，重写了父类的函数

class Student : Person() {
    override fun speak() {
        println("学生在说话")
    }
}

声明对象是父类类型，对象是子类实例

fun main(args: Array<String>) {
    var person: Person = Student()
    person.speak()

}

打印结果为：

这就是多态

类型判断 is和!is

在Kotlin中使用is或者!is来判断类型

fun main(args: Array<String>) {
    var person: Person = Student()
    println(person is Person)

}

结果

!is 和is的意思是相反的意思

类型转换 as 和！as

as使用于引用类型转换的，但是只能用于属于同一种继承关系才可以。

fun main(args: Array<String>) {
    // 向上转型
    var p = Student()
    var pp: Person = p

    //向下转型
    var p1: Person = Student()
    var p11 = p1 as Student

    //错误
    var p2 = Person()
    //  var p22 = p2 as Student  //这里异常

    //as?的使用
    var p3 = Person()
    var p33 = p3 as? Student   //这里就不会异常，会返回null

    println(pp)
    println(p11)
    println(p33)

}

密封类

密封类可以限制它子类的个数，密封类是一种抽象类。

sealed class A
class AA : A()
class AAA : A()

sealed是声明密封类的关键字，下面则是它的子类。

抽象类

声明一个抽象类很简单

abstract class Person() {
    abstract fun test1()
}

抽象类可以有自己的属性、函数、构造方法

abstract class Person(var name: String) {
    abstract fun test1()
    var age = 0
    fun test2() {
        
    }
}

实现一个抽象类，必须重写它抽象函数、属性。

抽象类不能被实例化即使它有构造函数

接口

接口则是比抽象类更抽象的对象，它只能有抽象的属性和函数。

和Java不同Kotlin中的接口可以有具体的函数和属性，并不是只能抽象的。

interface Demo1 {
    var int: Int
    fun test(string: String) {   //具体的函数
        string + int
    }

    fun test2()   //抽象的函数


}

一个类可以实现多个接口，接口可以继承接口。当然接口本来都是抽象的，所以继承了别的接口，你可以选择重写或者不重写父接口的函数。

Kotlin—面向对象（二）