面向对象高级(04)-对象的多态性,以及对象多态性在抽象类和接口中的实际应用

1、16. 面向对象高级（04） 本季要点：对象的都态性、instanceof关键字、Object类。本季为Java基础中面向对象的重要一季，讲解了对象的多态性，以及对 象多态性在抽象类和接口中的实际应用。blog: 零基础学JAVAJava SE面向对象部分-16.面向对象高级（04） 2009-01-15上季内容回顾：1、final关键字 · 修饰类不能被继承 · 修饰方法不能被覆写 · 修饰的变量就是一个常量，全局常量（public static final） 2、抽象类和接口 · 抽象类：只包含一个抽

2、象方法的类，抽象方法只需声明而不需要实现，必须有子类 · 接口：只包含抽象方法和全局常量的类接口，也是必须有子类在实际中一个类很少会去继承一个已经完全实现好的类，基本上都是继承抽象类和实现接口。本季主要知识点：1、对象的多态性 2、instanceof关键字 3、Object类对象的多态性注意点： 为了清楚的阐述出概念，现在先使用普通类的继承关系。向上转型：class A              

3、;  public void fun1()                                System.out.println("A类=>public void fun1()")

4、;                        public void fun2()                     &

5、#160;          /fun2方法调用的是fun1方法                    this.fun1();              &#

6、160;     class B extends A                /覆写A类中的fun1()方法            public void fun1()    

7、;                            System.out.println("B类=>public void fun1()");          

8、60;             public void fun3()                                

9、;System.out.println("B类=>public void fun3()");                    public class Demo01             

10、0;  public static void main(String args)                                B b = new B();   &

11、#160;                A a = new A();                    b.fun1();       

12、0;            a.fun2();                    b.fun3();              

13、0; 对象多态性体现在对象相互转型上面哈class A                public void fun1()                       &

14、#160;        System.out.println("A类=>public void fun1()");                        public void fun2() &

15、#160;                              /fun2方法调用的是fun1方法                &#

16、160;   this.fun1();                    class B extends A                /覆写A类中的fun1()方法

17、60;           public void fun1()                                System.out.

18、println("B类=>public void fun1()");                        public void fun3()            

19、;                    System.out.println("B类=>public void fun3()");                  

20、60; public class Demo02                public static void main(String args)                   &

21、#160;            /声明一个父类对象                    A a = null;             

22、       /new B()是子类对象向父类对象转换                    a = new B();                

23、    a.fun1();                 现在我们来看下a.fun1()调用的是哪个类的方法哈class A                public void fun1()

24、60;                               System.out.println("A类=>public void fun1()");       &

25、#160;                public void fun2()                            

26、60;   /fun2方法调用的是fun1方法                    this.fun1();                    class 

27、;B extends A                /覆写A类中的fun1()方法            public void fun1()           &

28、#160;                    System.out.println("B类=>public void fun1()");                  

29、;      public void fun3()                                System.out.println("B类=>public 

30、;void fun3()");                    public class Demo02                public static void&#

31、160;main(String args)                                /声明一个父类对象             

32、       A a = null;                    /new B()是子类对象向父类对象转换                 

33、   /子类对象向父类对象转型之后，所调用的方法一定是被覆写过的方法                    a = new B();                    

34、;a.fun1();                    a.fun2();                子类对象向父类对象转型之后，所调用的方法一定是被覆写过的方法，这就是对象的向上转型哈向下转型：class A 

35、               public void fun1()                              &#

36、160; System.out.println("A类=>public void fun1()");                        public void fun2()        &#

37、160;                       /fun2方法调用的是fun1方法                    this.fun1(); 

38、60;                  class B extends A                /覆写A类中的fun1()方法       

39、0;    public void fun1()                                System.out.println("B类=>public void 

40、fun1()");                        public void fun3()                   

41、             System.out.println("B类=>public void fun3()");                    public class Demo03 

42、;               public static void main(String args)                          &#

43、160;     /声明一个父类对象                    A a = null;                    /

44、new B()是子类对象向父类对象转换                    /子类对象向父类对象转型之后，所调用的方法一定是被覆写过的方法                    a = n

45、ew B();                    a.fun1();                    a.fun2();     

46、               a.fun3();                现在我们来看下能否调用a.fun3()哈程序提示找不到fun3()方法，A类中没有fun3()方法哈，如果我们一定要调用的话，我们就要使用向下转型哈class A   &

47、#160;            public void fun1()                                Sys

48、tem.out.println("A类=>public void fun1()");                        public void fun2()          

49、60;                     /fun2方法调用的是fun1方法                    this.fun1();   

50、0;                class B extends A                /覆写A类中的fun1()方法          

51、;  public void fun1()                                System.out.println("B类=>public void fun1()")

52、;                        public void fun3()                     &

53、#160;          System.out.println("B类=>public void fun3()");                    public class Demo03   

54、             public static void main(String args)                            

55、60;   /声明一个父类对象                    A a = null;                    /new B()是子类对象向

56、父类对象转换                    /子类对象向父类对象转型之后，所调用的方法一定是被覆写过的方法                    a = new B();&

57、#160;                   /可以进行向下转型，需要使用强制性手段哈                    B b = (B)a;     

58、               b.fun3();                验证下效果：这就是对象向下转型哈观察以下一种代码，检查下有没问题哈：class A          

59、;      public void fun1()                                System.out.println("A类=>public 

60、;void fun1()");                        public void fun2()                 &

61、#160;              /fun2方法调用的是fun1方法                    this.fun1();          &#

62、160;         class B extends A                /现在我们不覆写A类中的fun1()方法            public void 

63、funX()                                System.out.println("B类=>public void fun1()");     

64、0;                  public void fun3()                           

65、     System.out.println("B类=>public void fun3()");                    public class Demo04         

66、;       public static void main(String args)                                A a = new

67、 B();                    a.fun1();                程序找不到B类中被覆写的fun1()方法，所以去查找父类A中的fun1()方法了哈class A  

68、              public void fun1()                               &#

69、160;System.out.println("A类=>public void fun1()");                        public void fun2()         &#

70、160;                      /fun2方法调用的是fun1方法                    this.fun1();  

71、60;                 class B extends A                /覆写A类中的fun1()方法        

72、0;   public void fun1()                                System.out.println("B类=>public void fun1()

73、");                        public void fun3()                    

74、            System.out.println("B类=>public void fun3()");                    public class Demo04  

75、;              public static void main(String args)                           &#

76、160;    A a = new A();                    a.fun1();                现在对象实例化时没有子类哈，所以a.fun1(

77、)调用的是父类A中本身的fun1()方法如果现在我们要调用fun3()方法呢？现在使用向下转型可以吗?class A                public void fun1()                   

78、;             System.out.println("A类=>public void fun1()");                        public

79、60;void fun2()                                /fun2方法调用的是fun1方法            

80、        this.fun1();                    class B extends A              

81、0; /覆写A类中的fun1()方法            public void fun1()                             

82、60;  System.out.println("B类=>public void fun1()");                        public void fun3()       

83、60;                        System.out.println("B类=>public void fun3()");              &

84、#160;     public class Demo04                public static void main(String args)               

85、;                 A a = new A();                    /如果我们要调用fun3()方法呢？现在使用向下转型可以吗?     

86、60;              B b = (B)a;                    b.fun3();            &

87、#160;   这样修改的话，我们看下有没问题哈，验证一下，发现编译时没有错误，但执行时却出现ClassCastException错误了哈在程序开发中有两大错误是比较常见的： · NullPointerException：表示空指向异常，如果没有开辟堆内存空间，则出现此异常 · ClassCastException：表示类转换异常，两个不相关的类的对象进行向下转型操作。上面一个解释比较难理解哈，我们光看A类的话，我们不能知道A类有什么子类哈，但是如果我们光看B类的话，我们可以看出B类是继承A类的话，所以得

88、出了下面一个结论。结论： 在进行向下转型之前，两个对象必然先发生向上转型关系，这样好建立起关系，否则两个没有关系的对象是不能相互转型的。对象多态性到底有那些用处呢？如果不知道多态性的时候应该使用以下的方式编写代码，利用方法的重载完成。class A                public void fun1()       

89、                         System.out.println("A类=>public void fun1()");             

90、0;          public void fun2()                                /fun2方法调用的是fun1方法&

91、#160;                   this.fun1();                    class B extends A   

92、;             /覆写A类中的fun1()方法            public void fun1()                 

93、0;              System.out.println("B类=>public void fun1()");                        pu

94、blic void fun3()                                System.out.println("B类=>public void fun3()");  &#

95、160;                 class C extends A                /覆写A类中的fun1()方法        

96、60;   public void fun1()                                System.out.println("C类=>public void fun1(

97、)");                        public void fun4()                    

98、;            System.out.println("C类=>public void fun4()");                    public class Demo05 

99、0;              public static void main(String args)                           &

100、#160;    fun(new B();                    fun(new C();                   

101、60;    /现在要求定义几个方法，可以接收父类A的子类对象            /如果不知道多态性的时候应该使用以下的方式编写代码            public static void fun(B b)         

102、;                       b.fun2();                        public s

103、tatic void fun(C c)                                c.fun2();             &#

104、160;  如果按此做法，就会面临一个很严重的问题： · 如果现在A类有30个子类，则方法要重写30遍。 所以此时就可以利用对象的多态性完成，因为所有的子类对象都可以向父类对象转换。class A                public void fun1()        

105、                        System.out.println("A类=>public void fun1()");              

106、0;         public void fun2()                                /fun2方法调用的是fun1方法 &

107、#160;                  this.fun1();                    class B extends A    

108、;            /覆写A类中的fun1()方法            public void fun1()                  

109、0;             System.out.println("B类=>public void fun1()");                        public&#

110、160;void fun3()                                System.out.println("B类=>public void fun3()");   &#

111、160;                class C extends A                /覆写A类中的fun1()方法         

112、60;  public void fun1()                                System.out.println("C类=>public void fun1()"

113、;);                        public void fun4()                     

114、;           System.out.println("C类=>public void fun4()");                    public class Demo06  

115、0;             public static void main(String args)                            &

116、#160;   fun(new B();                    fun(new C();                    

117、60;   /现在要求定义几个方法，可以接收父类A的子类对象            /现在使用多态性编写代码            public static void fun(A a)         

118、60;                      a.fun2();                现在我们就只留一个fun()方法，new B()，new C()都是A类的子类哈，所以现在不管调用时传什么子类，都调用所

119、传子类被覆写的fun1()方法哈这就是对象多态性带来的好处，谁被其实例化就具备这样的功能哈如果父类设计的非常的完善，则方法中会非常的好写。要求： 如果传入的是B类的对象，则要求再调用fun3()方法，如果传入的是C类的对象，则要求再调用fun4() 方法。问题： 如何去判断一个对象是否是某个类的实例呢？这就需要instanceof关键字支持哈。instanceof关键字class A              

120、60; public void fun1()                                System.out.println("A类=>public void fun1()");

121、60;                       public void fun2()                      

122、;          /fun2方法调用的是fun1方法                    this.fun1();               

123、     class B extends A                /覆写A类中的fun1()方法            public void fun1()    

124、60;                           System.out.println("B类=>public void fun1()");           &

125、#160;            public void fun3()                                Sys

126、tem.out.println("B类=>public void fun3()");                    class C extends A              

127、;  /覆写A类中的fun1()方法            public void fun1()                            

128、0;   System.out.println("C类=>public void fun1()");                        public void fun4()      

129、0;                         System.out.println("C类=>public void fun4()");             &#

130、160;      public class Demo07                public static void main(String args)              

131、                  B b = new B();                    System.out.println(b instanceof A);

132、60;               我们来判断下对象b是否是A类的实例哈，我们分析下哈，子类B可以直接向父类A转型哈，说明父类A可以接收子类B的实例，那两者必然有关系哈，我们验证一下，结果返回true哈，证明对象b是A类的实例哈class A                pub

133、lic void fun1()                                System.out.println("A类=>public void fun1()");  

134、60;                     public void fun2()                        

135、;        /fun2方法调用的是fun1方法                    this.fun1();                 

136、   class B extends A                /覆写A类中的fun1()方法            public void fun1()      

137、60;                         System.out.println("B类=>public void fun1()");             &

138、#160;          public void fun3()                                System.out.prin

139、tln("B类=>public void fun3()");                    class C extends A                

140、;/覆写A类中的fun1()方法            public void fun1()                              

141、0; System.out.println("C类=>public void fun1()");                        public void fun4()        

142、0;                       System.out.println("C类=>public void fun4()");               &#

143、160;    public class Demo07                public static void main(String args)                

144、                B b = new B();                    System.out.println(b instanceof A);  

145、60;                 System.out.println(b instanceof B);                 对象b也肯定是B类的实例哈class A    

146、;            public void fun1()                                System.

147、out.println("A类=>public void fun1()");                        public void fun2()           &

148、#160;                    /fun2方法调用的是fun1方法                    this.fun1();    &#

149、160;               class B extends A                /覆写A类中的fun1()方法          

150、60; public void fun1()                                System.out.println("B类=>public void fun1()");

151、60;                       public void fun3()                      

152、;          System.out.println("B类=>public void fun3()");                    class C extends A   &

153、#160;            /覆写A类中的fun1()方法            public void fun1()                  

154、              System.out.println("C类=>public void fun1()");                        publ

155、ic void fun4()                                System.out.println("C类=>public void fun4()");  

156、0;                 public class Demo07                public static void main(String args)   &#

157、160;                            A a = new A();                 &#

158、160;  System.out.println(a instanceof A);                    System.out.println(a instanceof B);            &#

159、160;   那相反对象a是B类的实例吗？验证显示不是哈说明不能向子类转换哈class A                public void fun1()                  

160、60;             System.out.println("A类=>public void fun1()");                        public&

161、#160;void fun2()                                /fun2方法调用的是fun1方法           

162、0;        this.fun1();                    class B extends A              &#

163、160; /覆写A类中的fun1()方法            public void fun1()                             &

164、#160;  System.out.println("B类=>public void fun1()");                        public void fun3()       &

165、#160;                        System.out.println("B类=>public void fun3()");              

166、;      class C extends A                /覆写A类中的fun1()方法            public void fun1()   &#

167、160;                            System.out.println("C类=>public void fun1()");          

168、              public void fun4()                               &#

169、160;System.out.println("C类=>public void fun4()");                    public class Demo08             &

170、#160;  public static void main(String args)                                fun(new B();    

171、;                System.out.println("#");                    fun(new C();     &#

172、160;                  public static void fun(A a)                        &#

173、160;       a.fun2();                    if (a instanceof B)               &

174、#160;                                B b = (B)a;               &#

175、160;            b.fun3();                                    

176、;    if (a instanceof C)                                        &

177、#160;       C c = (C)a;                            c.fun4();           

178、;                         这就是instanceof关键字的作用哈Instanceof的使用时机： 一般情况下都是在转型之前进行一下判断，这样就可以进行比较安全的转型操作。Object类在Java中用户所编写的一切类都是一个类的子类，称为Object类。实际上此类默认继承了Object类，以上代码等价于以下代码：

179、Object类的作用： · 如果一个好的类需要覆写Object类中的三个方法： |- public String toString()：对象输出时的操作 |- public boolean equals(Object obj)：对象比较时的操作 |- public int hashCode()： 返回该对象的哈希码值。class Student /extends Object            

180、;    private String name;            private int age;            public Student(String name,int age)      

181、;                           = name;                    this.age = age;