仓颉面向对象-抽象

一、抽象的作用

        为了加强多态，加强动态绑定，也就是为了方法重写。具体体现是抽象类和接口。

二、抽象的定义

       1. 在class前面用abstract关键字进行修饰。如下代码所演示：

​
abstract class Father{
    
}

main(): Int64 {
   
    return 0
}

​

        抽象类不能实例化，属于大类型，一定会有子类型，通过子类完成实例化。抽象类绑定子类，抽象方法被子类重写。如下代码演示：

abstract class Father{
    public func abstractFunction():Unit
}
class Son <: Father{
    public func abstractFunction():Unit
    {
        println("父类抽象方法在子类被重写")
    }
}
main(): Int64 {
    var son : Son = Son()
    son.abstractFunction()
    return 0
}

运行结果：

通过错误提示可知，抽象类是不能实例化对象的。

注意：父类中的抽象方法与子类中重写的方法需要用public或protected访问修饰符修饰否则报错。

2.抽象类中可以有主构造函数

abstract class Father{
    Father(a:Int64)
    {

    }
    public func abstractFunction():Unit
}
class Son <: Father{
    Son()
    {
        super(10)
    }
    public func abstractFunction():Unit
    {
        println("父类抽象方法在子类被重写")
    }
}
main(): Int64 {
    var son : Son = Son()
    son.abstractFunction()
    return 0
}

        同样，子类构造函数依赖于父类，当父类中主构造函数含有参数时，子类主构造函数需要显示的写出super(参数)。

三、接口的定义

        1.关键字interface后接接口名称。    interface  接口名称{}

interface A{
    public func interfaceFunction():Unit
}
class UserA <: A{
    public func interfaceFunction()
    {
        println("接口中的抽象方法在子类中被重写")
    }
}
main(): Int64 {
    var usera : UserA = UserA()
    usera.interfaceFunction()
    return 0
}

运行结果：

注意：接口中的抽象方法与子类中重写的方法都要用访问修饰符public进行修饰，接口也不能实例化对象，接口中不能有构造函数。

2.接口可以多继承，通过&

interface A{
    public func interfaceFunction():Unit
}
interface B{

}
interface C{

}
class UserA <: A & B & C{
    public func interfaceFunction()
    {
        println("接口中的抽象方法在子类中被重写")
    }
}
main(): Int64 {
    var usera : UserA = UserA()
    usera.interfaceFunction()
    return 0
}

四、抽象类与接口的区别

•  抽象类是可以有构造函数，提供给子类依赖，接口则不能有构造函数。
•  抽象类是单继承，不能继承多个类，但接口则是可以多继承。