多态（Polymorphism） 、接口（Interface）、浅谈设计模式

5.1 多态的概念
     面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。

     多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

     实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

     多态的作用：消除类型之间的耦合关系。

     现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

下面是多态存在的三个必要条件，要求大家做梦时都能背出来！

5.2 多态存在的三个必要条件

一、要有继承；

二、要有重写；

三、父类引用指向子类对象。

5.3 TestPolymoph.as —— 多态的应用，体会多态带来的好处

package {

    public class TestPolymoph {

        public function TestPolymoph() {

            var cat:Cat = new Cat("MiMi");

            var lily:Lady = new Lady(cat);

            // var dog:Dog = new Dog("DouDou");

            // var lucy:Lady = new Lady(dog);

            lady.myPetEnjoy();

        }

    }

}

class Animal {

    private var name:String;

    function Animal(name:String) {

        this.name = name;

    }

    public function enjoy():void {

        trace("call...");

    }

}

class Cat extends Animal {

    function Cat(name:String) {

        super(name);

    }

    override public function enjoy():void {

        trace("Miao Miao...");

    }

}

class Dog extends Animal {

    function Dog(name:String) {

        super(name);

    }

    override public function enjoy():void {

        trace("Wang Wang...");

    }

}

// 假设又添加了一个新的类 Bird

class Bird extends Animal {

    function Bird(name:String) {

        super(name);

    }

    override public function enjoy():void {

        trace("JiJi ZhaZha");

    }

}

class Lady {

    private var pet:Animal;

    

    function Lady(pet:Animal) {

        this.pet = pet;

    }

   

    public function myPetEnjoy():void {

        // 试想如果没有多态

        //if (pet is Cat) { Cat.enjoy() }

        //if (pet is Dog) { Dog.enjoy() }

        //if (pet is Bird) { Bird.enjoy() }

        pet.enjoy();

    }

}

    首先，定义 Animal 类包括：一个 name 属性（动物的名字），一个 enjoy() 方法（小动物玩儿高兴了就会叫）。接下来，定义 Cat, Dog 类它们都继承了 Animal 这个类，通过在构造函数中调用父类的构造函数可以设置 name 这个属性。猫应该是“喵喵”叫的，因此对于父类的 enjoy() 方法进行重写（override），打印出的叫声为 “Miao Maio…”。Dog 也是如此，重写 enjoy 方法，叫声为 “Wang Wang…”。

    再定义一个 Lady 类，设置一个情节：假设这个 Lady 是一个小女孩儿，她可以去养一只宠物，这个小动物可能是 Cat, Dog，或是 Animal 的子类。在 Lady 类中设计一个成员变量 pet，存放着宠物的引用。具体是哪类动物不清楚，但肯定是 Animal 的子类，因此 pet 的类型为 Animal，即 pet:Animal。注意这是父类引用，用它来指向子类对象。

    最后在 Lady 类里面有一个成员函数 myPetEnjoy()，这个方法中只有一句 pet.enjoy()，调用 pet 的 enjoy() 方法。

    现在来看测试类。new 出来一只 Cat，new 出来一个 Lady，将 Cat 的对象传给 Lady。现在 Lady 中的成员变量应该是 pet:Animal = new Cat(“MiMi”)。下面，调用 lady.myPetEnjoy() 方法，实际就是在调用 pet.enjoy()，打印出 Miao Miao。pet 的类型明明是 Animal，但被调的方法却是 Cat 的 enjoy()，而非 Animal 的 enjoy()，这就叫动态绑定——“在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法”。