java的多态性学习代码

1. 1、下面的代码是定义一个抽象类Shape，然后Circel和Square类继承Shape类，实现Shape中的方法MianJi();  
2.   
3. public class ShapeDemo {  
4.     public static void main(String[] args) {  
5.       
6.     //向上转型，创建一个父类Shape的引用，让引用指向子类  
7.         Shape shape =  new Square(2);  
8.           
9.         //如果shape引用的对象是Square类型的对象，返回true,否则为false  
10.         if(shape instanceof Square) {  
11.               
12.             //将shape对象想下转型为子类的对象  
13.             Square square = (Square)shape;  
14.               
15.             //在show方法中，以子类对象sqaure为参数，求出求出子类的面积  
16.             show(square);  
17.         }  
18.            
19.         //向上转型，创建父类的引用，指向子类Circel的对象  
20.         Shape shape1 = new Circle(2);  
21.         //在show方法中，以父类Shape1参数调用方法，求出子类的面积  
22.         show(shape1);  
23.           
24.           
25.           
26.           
27.           
28. }  
29.       
30. //定义静态方法show来调用父类或则子类的MianJi()方法  
31. public static void show(Shape s) {  
32.         s.MianJi();  
33. }  
34.   
35. }  
36.   
37. //定义一个抽象类Shpe，给出抽象方法MianJi，不给出具体实现  
38. abstract class Shape{  
39.     float r;  
40.       
41.     abstract void MianJi();  
42. }  
43.   
44.   
45.       
46. //定义一个Square正方形类，继承父类Shape类，给出父类MainJi方法的具体实现  
47. class Square extends Shape{  
48.     //定义参数边长  
49.     float r;  
50.       
51.     //默认参数构造方法来初始化Square，  
52.     Square(float r){  
53.         super();  
54.         this.r = r;  
55.     }  
56.       
57.     //求出正方形的面积  
58.     void  MianJi() {  
59.         System.out.println( "我是正方形，面积是：" +r * r);  
60.     }  
61. }  
62.   
63. //定义圆类，继承父类Shape  
64. class Circle extends Shape{  
65.     //定义参数半径  
66.     float r;  
67.       
68.     //构造方法初始化  
69.     Circle(float r){  
70.         super();  
71.         this.r = r;  
72.     }  
73.       
74.     //求出圆的面积  
75.     void MianJi(){  
76.         System.out.println("我是圆形，面积是：" +3.14 * r *r);  
77.     }  
78. }
79. 1. 运行结果：  
    2. 我是正方形，面积是：4.0  
    3. 我是圆形，面积是：12.56  
    
    

1. 2.定义一个Animal父类，子类Cat和Dog继承Animal类  
2. public class Demo{  
3.     public static void main(String[] args) {  
4.       show(new Cat());  // 以 Cat 对象调用 show 方法  
5.       show(new Dog());  // 以 Dog 对象调用 show 方法  
6.                   
7.       Animal a = new Cat();  // 向上转型    
8.       a.eat();               // 调用的是 Cat 的 eat  
9.       Cat c = (Cat)a;        // 向下转型    
10.       c.work();        // 调用的是 Cat 的 work  
11.           
12.   }    
13.               
14.     public static void show(Animal a)  {  
15.       a.eat();    
16.         // 类型判断  
17.         if (a instanceof Cat)  {  // 猫做的事情   
18.             Cat c = (Cat)a;    
19.             c.work();    
20.         }   
21.     else if (a instanceof Dog) { // 狗做的事情   
22.             Dog c = (Dog)a;    
23.             c.work();    
24.         }    
25.     }    
26. }  
27.    
28. //定义一个抽象Animal类，为父类  
29. abstract class Animal {    
30.     //定义一个抽象的父类eat方法，子类必须具体实现这个方法  
31.     abstract void eat();    
32. }    
33.     
34. //继承父类Animal  
35. class Cat extends Animal {    
36.     //实现父类的抽象方法  
37.     public void eat() {    
38.         System.out.println("我是猫， 吃鱼");    
39.     }    
40.     //定义子类自己的方法  
41.     public void work() {    
42.         System.out.println("我是猫，抓老鼠");    
43.     }    
44. }    
45.     
46. //继承父类Animal，实现自己的方法  
47. class Dog extends Animal {    
48.     //实现父类的方法  
49.     public void eat() {    
50.         System.out.println("我是狗，吃骨头");    
51.     }    
52.     //定义自己的方法  
53.     public void work() {    
54.         System.out.println("我是狗，看家");    
55.     }    
56. }

1. 1. 我是猫， 吃鱼  
   2. 我是猫，抓老鼠  
   3. 我是狗，吃骨头  
   4. 我是狗，看家  
   5. 我是猫， 吃鱼  
   6. 我是猫，抓老鼠