定义：动态绑定是指在执行期间（非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
运用多态的三个必要条件：
1、要有继承      2、要有方法重写     3、父类引用指向子类对象
 
  1. package com.sxt;  
  2.  
  3. class Animal {  
  4.     private String name;  
  5.     Animal(String name) {  
  6.         this.name = name;  
  7.     }  
  8.     public void enjoy() {  
  9.         System.out.print("叫声...");  
  10.     }  
  11. }  
  12. class Cat extends Animal {  
  13.     private String eyesColor;  
  14.     Cat(String n, String c) {  
  15.         super(n);  
  16.         eyesColor = c;  
  17.     }  
  18.     public void enjoy() {  
  19.         System.out.print("猫叫声...");  
  20.     }  
  21. }  
  22. class Dog extends Animal {  
  23.     private String furColor;  
  24.     Dog(String n, String c) {  
  25.         super(n);  
  26.         furColor = c;  
  27.     }  
  28.     public void enjoy() {  
  29.         System.out.print("狗叫声...");  
  30.     }  
  31. }  
  32. class Bird extends Animal {  
  33.     Bird() {  
  34.         super("bird");  
  35.     }  
  36.     public void enjoy() {  
  37.         System.out.print("鸟叫声...");  
  38.     }  
  39. }  
  40. class Lady {  
  41.     private String name;  
  42.     private Animal pet;  
  43.     Lady(String name, Animal pet) {  
  44.         this.name = name;  
  45.         this.pet = pet;  
  46.     }  
  47.     public void myPetEnjoy() {  
  48.         pet.enjoy();  
  49.     }  
  50. }  
  51. public class Test {  
  52.     public static void main(String args[]) {  
  53.         Cat c = new Cat("catname", "blue");  
  54.         Dog d = new Dog("dogname", "black");  
  55.         Bird b = new Bird();  
  56.         Lady l1 = new Lady("l1", c);          
  57.         Lady l2 = new Lady("l2", d);  
  58.         Lady l3 = new Lady("l3", b);  
  59.         l1.myPetEnjoy();  
  60.         l2.myPetEnjoy();  
  61.         l3.myPetEnjoy();  
  62.     }  
  63. }  
  64. //输出结果：猫叫声... 狗叫声... 鸟叫声... 


结果分析：程序执行到Lady l1 = new Lady("l1", c)这句时，c会被转换为Animal类型。此时，它只能访问Animal类中的成员变量，而不能访问Cat类中的成员变量。 


程序执行到 l1.myPetEnjoy()这句时，会调用enjoy()方法。而这个方法是Cat中的enjoy()方法，而不是Animal中enjoy()方法。这就是多态的应用，增强了程序的可扩展性。如果程序中再添加一个从Animal继承的类，需要用到enjoy()方法时。只需调用Lady中的myPetEnjoy()方法，不需改动程序的结构。