多态

多态的含义

多态的实际含义是：同一操作作用于不同的对象什么，可以产生不同的解释和不同的执行结果。换句话说，给不同的对象发送同一个消息的时候，这些对象会根据这个消息分别给出不同的反馈。

举例说明：

主人家里养了一只鸡和一只鸭，当主人向它们发出“叫”的指令时，鸭会“嘎嘎嘎”地叫，而鸡会“咯咯咯”地叫。根据主人的指令，这两只动物都以各自的形式来响应。

let makeSound = function(animal) {
  if (animal instanceof Duck) {
    console.log("嘎嘎嘎");
  } else if (animal instanceof Chicken) {
    console.log("咯咯咯");
  }
}

let Duck = function() {};
let Chicken = function() {};

makeSound(new Duck());        // 嘎嘎嘎
makeSound(new Chicken());      // 咯咯咯

这段代码体现了“多态”，但是这样的“多态”并不能让人满意。如果后来又增加一条狗，就必须得改动 makeSound 函数，才能让狗发出叫声。

多态背后的思想是将“做什么”和“谁去做以及怎么做”分离开来，也就是将“不变的事物”与“可能改变的事物”分离开。在这里，动物都会叫，这是不变的，但是不同类型的动物具体怎么叫是可变的。把不变的部分隔离，把可变的部分封装，就可以赋予程序扩展的能力，也是符合开放-封闭原则的，相对与修改代码来说，仅增加代码就能完成同样的功能，这显然优雅和安全得多。

对象的多态性

从静态类型语言（如 Java）与动态类型语言（如 Javascript）两方面来考虑。

动态类型语言（Javascript）

首先把不变的部分隔离出来，那就是所有的动物都会发出叫声。

let makeSound = function(animal) {
  animal.sound();
}

然后把可变的部分各自封装起来，也就是不同类型动物的叫法。

let Duck = function() {};
Duck.prototype.sound = function() {
  console.log("嘎嘎嘎");
};

let Chicken = function() {};
Chicken.prototype.sound = function() {
  console.log("咯咯咯");
};

makeSound(new Duck());        // 嘎嘎嘎
makeSound(new Chicken());      // 咯咯咯

现在如果增加了一条狗，只要简单追加一些代码就行了，不用改动以前的 makeSound 函数。

静态类型语言（Java）

静态类型语言在编译时会进行类型匹配检查。由于在代码编译时要进行严格的类型检查，所以不能给变量赋予不同类型的值。

要解决这一问题，归根结底是先要消除类型之间的耦合关系。

如果类型之间的耦合关系没有被消除，那么我们在 makeSound 方法中指定了发出叫声的对象是某个类型，它就不可能再被替换为另外一个类型，这一般是通过向上转型来实现。

将 Duck 和 Chicken 不变的部分分隔开封装到超类的抽象方法中，再分别让两者都继承自抽象类 Animal。下述代码中 (1) 和 (2) 处的赋值语句显然是成立的，因为 Duck 和 Chicken 都是 Animal：

public abstract class Animal {
  abstract void makeSound();
}

public class Chicken extends Animal {
  public void makeSound() {
    System.out.println("咯咯咯");
  }
}

public class Duck extends Animal {
  public void makeSound() {
    System.out.println("嘎嘎嘎");
  }
}

Animal duck = new Duck();          // (1)
Animal chicken = new Chicken();    // (2)

剩下的就是让 AnimalSound 类的 makeSound 方法接受 Animal 类型的参数，而不是具体的 Duck 类型或者 Chicken 类型：

public class AnimalSound {
  public void makeSound(Animal animal) {        // 接受抽象类的参数
    animal.makeSound();
  }
}

public class Test {
  public static void main(String args[]) {
    AnimalSound animalSound = new AnimalSound();
    Animal duck = new Duck();
    Animal chicken = new Chicken();
    animalSound.makeSound(duck);           // 嘎嘎嘎
    animalSound.makeSound(chicken);        // 咯咯咯
  }
}

两者区别

多态思想实际上是把“做什么”和“谁去做”分离开，要实现这一点，归根结底是先要消除类型之间的耦合关系。在静态类型语言中，可以通过向上转型来实现。

而动态类型语言的变量类型在运行期是可变的。比如一个 Javascript 对象，就既可以表示 Duck 类型的对象，又可以表示 Chicken 类型的对象，这意味这动态类型语言的多态是与生俱来的。这不难解释，因为动态类型语言在编译时没有类型检查的过程，所以不存在任何程度上的类型耦合，不需要向上转型之类的技术来取得多态的效果。

设计模式与多态

在命令模式中，请求被封装在一些命令对象中，这使得命令的调用者和命令的接收者可以完全解耦开来，当调用命令的 execute 方法时，不同的命令会做出不同的事情，从而会产生不同的执行结果。而做这些事情的过程早已被封装在命令对象内部的，作为调用命令的客户，根本不必去关心命令执行的具体过程。

在组合模式中，多态性使得客户可以完全忽略组合对象和叶节点对象之间的区别，这正是组合模式最大的作用所在。对组合对象和叶节点对象发出同一个消息的时候，它们会各自做自己应该做的事情，组合对象把消息继续转发给下面的叶节点对象，叶节点对象则会对这些消息作出真实的反馈。

在策略模式中，Context 并没有执行算法的能力，而是把这个职责委托给了某个策略对象。每个策略对象负责的算法已被各自封装在对象内部。当我们对这些策略对象发出“计算”的消息时，它们会返回各自不同的计算结果。

总结

Martin Fowler 在《重构：改善既有代码的设计》里写到：

多态最根本好处在于，你不必再向对象询问“你是什么类型”而后根据得到的答案调用对象的某个行为——你只管调用该行为就是了，其它的一切多态机制都会为你安排妥当。

换句话说，多态最根本的作用就是通过把过程化的分支语句转化为对象的多态性，从而消除这些条件分支语句。