仓颉面向对象-多态

一、多态的定义

       类中定义的方法是同一个方法名，但却是不同的实现结果。

       具体体现在方法重载与方法重写两方面。

二、方法重载与方法重写

1.方法重载

       相同的方法名，不同的参数列表(参数的个数或者参数的类型)，与返回值类型无关，与static关键字无关。决定调用哪个重载的方法是由参数决定的，所以也把方法重载叫做编译时多态。

class Employee{
    var name : String = ""
    var age : Int64 = 0
    func workWay()
    {
        println("做普通的工作")
    }
    func workWay(name:String)
    {
        println("高层做决策性工作")
    }
}
main(): Int64 {
    var employee : Employee = Employee()
    employee.workWay()
    employee.workWay("高层领导")
    return 0
}

如上述代码所演示，Employee类中两个相同方法名的workWay方法其中有一个带有参数，此时构成方法重载，具体调用哪个方法取决于参数。如不带参数就会调用第一个方法，带了参数后就会调用第二个方法。

具体演示结果如下图：

2.方法重写

       在继承关系中，子类和父类具有相同的方法名，相同的参数列表(参数的个数和类型)，相同的返回值类型，与static无关。决定调用哪个重名的方法，是由创建的对象来决定的。

注意：在父类中的方法如果要被子类重写，父类的方法要用open修饰，否则子类是不能够重写的。

open class Employee{
    var name : String = ""
    var age : Int64 = 0
    public open func workplace():Unit
    {
        println("普通职员的工作地点")
    }
}
class Manager <: Employee{
    public override func workplace():Unit
    {
        println("高层领导的工作地点")
    }
}
main(): Int64 {
    var employee : Employee = Employee()
    var manager : Manager = Manager()
    employee.workplace()
    manager.workplace()
    return 0
}

运行结果：

当为静态方法时：

open class Employee{
    var name : String = ""
    var age : Int64 = 0
    static public  func workplace():Unit
    {
        println("普通职员的工作地点")
    }
}
class Manager <: Employee{
    static public  func workplace():Unit
    {
        println("高层领导的工作地点")
    }
}
class Worker <: Employee{

}
main(): Int64 {
    var employee : Employee = Employee()
    var manager : Employee = Manager()
    var worker : Employee = Worker()
    Employee.workplace()
    Manager.workplace()
    return 0
}

结果为：

注意：仓颉中静态方法不能通过创建对象进行访问，须直接通过类名进行访问，这也是仓颉与Java的不同之处。

由此可见，创建父类的对象调用的方法为父类里的同名方法，创建子类的对象调用的方法为子类里的同名方法。

3.动态绑定机制

       动态绑定机制就是指一个父类指向多个子类的现象。

open class Employee{
    var name : String = ""
    var age : Int64 = 0
    public open func workplace():Unit
    {
        println("普通职员的工作地点")
    }
}
class Manager <: Employee{
    public  func workplace():Unit
    {
        println("高层领导的工作地点")
    }
}
class Worker <: Employee{

}
main(): Int64 {
    var employee : Employee = Employee()
    var manager : Employee = Manager()
    var worker : Employee = Worker()
    employee.workplace()
    manager.workplace()
    return 0
}

创建对象时，类型全部是Employee父类，通过调用workplace方法和上述结果一致。