java基础学习总结——多态(动态绑定)详解编程语言

  1 package javastudy.summary; 
  2  
  3 class Animal { 
  4     /** 
  5      * 声明一个私有的成员变量name。 
  6      */ 
  7     private String name; 
  8  
  9     /** 
 10      * 在Animal类自定义的构造方法 
 11      * @param name 
 12      */ 
 13     Animal(String name) { 
 14         this.name = name; 
 15     } 
 16  
 17     /** 
 18      * 在Animal类里面自定义一个方法enjoy 
 19      */ 
 20     public void enjoy() { 
 21         System.out.println("动物的叫声……"); 
 22     } 
 23 } 
 24  
 25 /** 
 26  * 子类Cat从父类Animal继承下来，Cat类拥有了Animal类所有的属性和方法。 
 27  * @author gacl 
 28  * 
 29  */ 
 30 class Cat extends Animal { 
 31     /** 
 32      * 在子类Cat里面定义自己的私有成员变量 
 33      */ 
 34     private String eyesColor; 
 35  
 36     /** 
 37      * 在子类Cat里面定义Cat类的构造方法 
 38      * @param n 
 39      * @param c 
 40      */ 
 41     Cat(String n, String c) { 
 42         /** 
 43          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。 
 44          * 把子类对象里面的父类对象先造出来。 
 45          */ 
 46         super(n); 
 47         eyesColor = c; 
 48     } 
 49  
 50     /** 
 51      * 子类Cat对从父类Animal继承下来的enjoy方法不满意，在这里重写了enjoy方法。 
 52      */ 
 53     public void enjoy() { 
 54         System.out.println("我养的猫高兴地叫了一声……"); 
 55     } 
 56 } 
 57  
 58 /** 
 59  * 子类Dog从父类Animal继承下来，Dog类拥有了Animal类所有的属性和方法。 
 60  * @author gacl 
 61  * 
 62  */ 
 63 class Dog extends Animal { 
 64     /** 
 65      * 在子类Dog里面定义自己的私有成员变量 
 66      */ 
 67     private String furColor; 
 68  
 69     /** 
 70      * 在子类Dog里面定义Dog类的构造方法 
 71      * @param n 
 72      * @param c 
 73      */ 
 74     Dog(String n, String c) { 
 75         /** 
 76          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。 
 77          * 把子类对象里面的父类对象先造出来。 
 78          */ 
 79         super(n); 
 80         furColor = c; 
 81     } 
 82  
 83     /** 
 84      * 子类Dog对从父类Animal继承下来的enjoy方法不满意，在这里重写了enjoy方法。 
 85      */ 
 86     public void enjoy() { 
 87         System.out.println("我养的狗高兴地叫了一声……"); 
 88     } 
 89 } 
 90  
 91 /** 
 92  * 子类Bird从父类Animal继承下来，Bird类拥有Animal类所有的属性和方法 
 93  * @author gacl 
 94  * 
 95  */ 
 96 class Bird extends Animal { 
 97     /** 
 98      * 在子类Bird里面定义Bird类的构造方法 
 99      */ 
100     Bird() { 
101         /** 
102          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。 
103          * 把子类对象里面的父类对象先造出来。 
104          */ 
105         super("bird"); 
106     } 
107  
108     /** 
109      * 子类Bird对从父类Animal继承下来的enjoy方法不满意，在这里重写了enjoy方法。 
110      */ 
111     public void enjoy() { 
112         System.out.println("我养的鸟高兴地叫了一声……"); 
113     } 
114 } 
115  
116 /** 
117  * 定义一个类Lady(女士) 
118  * @author gacl 
119  * 
120  */ 
121 class Lady { 
122     /** 
123      * 定义Lady类的私有成员变量name和pet 
124      */ 
125     private String name; 
126     private Animal pet; 
127  
128     /** 
129      * 在Lady类里面定义自己的构造方法Lady()， 
130      * 这个构造方法有两个参数，分别为String类型的name和Animal类型的pet， 
131      * 这里的第二个参数设置成Animal类型可以给我们的程序带来最大的灵活性， 
132      * 因为作为养宠物来说，可以养猫，养狗，养鸟，只要是你喜欢的都可以养， 
133      * 因此把它设置为父类对象的引用最为灵活。 
134      * 因为这个Animal类型的参数是父类对象的引用类型，因此当我们传参数的时候， 
135      * 可以把这个父类的子类对象传过去，即传Dog、Cat和Bird等都可以。 
136      * @param name 
137      * @param pet 
138      */ 
139     Lady(String name, Animal pet) { 
140         this.name = name; 
141         this.pet = pet; 
142     } 
143  
144     /** 
145      * 在Lady类里面自定义一个方法myPetEnjoy() 
146      * 方法体内是让Lady对象养的宠物自己调用自己的enjoy()方法发出自己的叫声。 
147      */ 
148     public void myPetEnjoy() { 
149         pet.enjoy(); 
150     } 
151 } 
152  
153 public class TestPolymoph { 
154     public static void main(String args[]) { 
155         /** 
156          * 在堆内存里面new了一只蓝猫对象出来，这个蓝猫对象里面包含有一个父类对象Animal。 
157          */ 
158         Cat c = new Cat("Catname", "blue"); 
159         /** 
160          * 在堆内存里面new了一只黑狗对象出来，这个黑狗对象里面包含有一个父类对象Animal。 
161          */ 
162         Dog d = new Dog("Dogname", "black"); 
163         /** 
164          * 在堆内存里面new了一只小鸟对象出来，这个小鸟对象里面包含有一个父类对象Animal。 
165          */ 
166         Bird b = new Bird(); 
167  
168         /** 
169          * 在堆内存里面new出来3个小姑娘，名字分别是l1，l2，l3。 
170          * l1养了一只宠物是c(Cat)，l2养了一只宠物是d(Dog)，l3养了一只宠物是b(Bird)。 
171          * 注意：调用Lady类的构造方法时，传递过来的c，d，b是当成Animal来传递的， 
172          * 因此使用c，d，b这三个引用对象只能访问父类Animal里面的enjoy()方法。 
173          */ 
174         Lady l1 = new Lady("l1", c); 
175         Lady l2 = new Lady("l2", d); 
176         Lady l3 = new Lady("l3", b); 
177         /** 
178          * 这三个小姑娘都调用myPetEnjoy()方法使自己养的宠物高兴地叫起来。 
179          */ 
180         l1.myPetEnjoy(); 
181         l2.myPetEnjoy(); 
182         l3.myPetEnjoy(); 
183     } 
184 }