Java基础之面向对象(四)--多态、Object类

多态：

在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：
无论编译和运行，都参考做左边。

[java]  view plain copy

1. /* 
2. 多态：可以理解为事物存在的多种体现形态。 
3.  
4. 人：男人，女人 
5.  
6. 动物：猫，狗。 
7.  
8. 猫 x = new 猫(); 
9.  
10. 动物 x = new 猫(); 
11.  
12. 1，多态的体现 
13.     父类的引用指向了自己的子类对象。 
14.     父类的引用也可以接收自己的子类对象。 
15. 2，多态的前提 
16.     必须是类与类之间有关系。要么继承，要么实现。 
17.     通常还有一个前提：存在覆盖。 
18.  
19. 3，多态的好处 
20.     多态的出现大大的提高程序的扩展性。 
21.  
22. 4，多态的弊端： 
23.     虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。 
24.  
25. 5，多态的应用 
26.  
27. 6，多态的出现代码中的特点(多态使用的注意事项) 
28.  
29.  
30.  
31.  
32. 第二个问题：如何使用子类特有方法。 
33. */  
34.   
35. /* 
36. 动物， 
37. 猫，狗。 
38. */  
39.   
40. class Cat extends Animal  
41. {  
42.     public void eat()  
43.     {  
44.         System.out.println("吃鱼");  
45.     }  
46.     public void catchMouse()  
47.     {  
48.         System.out.println("抓老鼠");  
49.     }  
50. }  
51.   
52.   
53. class Dog extends Animal  
54. {  
55.     public void eat()  
56.     {  
57.         System.out.println("吃骨头");  
58.     }  
59.     public void kanJia()  
60.     {  
61.         System.out.println("看家");  
62.     }  
63. }  
64.   
65.   
66. class Pig extends Animal  
67. {  
68.     public void eat()  
69.     {  
70.         System.out.println("饲料");  
71.     }  
72.     public void gongDi()  
73.     {  
74.         System.out.println("拱地");  
75.     }  
76. }  
77.   
78. //-----------------------------------------  
79.   
80.   
81. class DuoTaiDemo2   
82. {  
83.     public static void main(String[] args)   
84.     {  
85.         //Animal a = new Cat();//类型提升。 向上转型。  
86.         //a.eat();  
87.   
88.         //如果想要调用猫的特有方法时，如何操作？  
89.         //强制将父类的引用。转成子类类型。向下转型。  
90.         ///Cat c = (Cat)a;  
91.         //c.catchMouse();  
92.         //千万不要出现这样的操作，就是将父类对象转成子类类型。  
93.         //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。  
94.         //多态自始至终都是子类对象在做着变化。  
95. //      Animal a = new Animal();  
96. //      Cat c = (Cat)a;  
97.           
98.   
99.         /* 
100.         毕姥爷 x = new 毕老师(); 
101.  
102.         x.讲课(); 
103.  
104.         毕老师 y = (毕老师)x; 
105.  
106.  
107.         y.看电影(); 
108.         */  
109.         function(new Dog());  
110.         function(new Cat());  
111.   
112.   
113.     }  
114.     public static void function(Animal a)//Animal a = new Cat();  
115.     {  
116.         a.eat();  
117.         /* 
118.         if(a instanceof Animal) 
119.         { 
120.             System.out.println("haha"); 
121.         } 
122.         else  
123.         */  
124.         if(a instanceof Cat)  
125.         {  
126.             Cat c = (Cat)a;  
127.             c.catchMouse();  
128.         }  
129.         else if(a instanceof Dog)  
130.         {  
131.             Dog c = (Dog)a;  
132.             c.kanJia();  
133.         }  
134.   
135.   
136.         /* 
137.         instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)   
138.         */  
139.       
140.     }  
141.       
142.   
143.   
144. }  

Object类：

[java]  view plain copy

1. /* 
2. Object:是所有对象的直接后者间接父类，传说中的上帝。 
3. 该类中定义的肯定是所有对象都具备的功能。 
4.  
5.  
6.  
7. Object类中已经提供了对对象是否相同的比较方法。 
8.  
9. 如果自定义类中也有比较相同的功能，没有必要重新定义。 
10. 只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。 
11. */  
12.   
13. class Demo //extends Object  
14. {  
15.     private int num;  
16.     Demo(int num)  
17.     {  
18.         this.num = num;  
19.     }  
20.       
21.     public boolean equals(Object obj)//Object obj = new Demo();  
22.     {  
23.   
24.         if(!(obj instanceof Demo))  
25.             return false;  
26.         Demo d = (Demo)obj;  
27.   
28.         return this.num == d.num;  
29.     }  
30.       
31.     /* 
32.     public boolean compare(Demo d) 
33.     { 
34.         return this.num==d.num; 
35.     } 
36.     */  
37.     public String toString()  
38.     {  
39.         return "demo:"+num;  
40.     }  
41.   
42.   
43. }  
44. class Person   
45. {  
46. }  
47.   
48.   
49. class ObjectDemo   
50. {  
51.     public static void main(String[] args)   
52.     {  
53.         Demo d1 = new Demo(4);  
54.         System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。  
55.         Demo d2 = new Demo(7);  
56.         System.out.println(d2.toString());  
57.         //Demo d2 = new Demo(5);  
58.         //Class c = d1.getClass();  
59. //  
60. //      System.out.println(c.getName());  
61. //      System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));  
62. //      System.out.println(d1.toString());  
63.         //Person p = new Person();  
64.         ///System.out.println(d1.equals(p));  
65.   
66.     }  
67. }