0基础学java_面向对象之多态

对象的多态性

多态性是在面向对象中一个最重要的概念，在Java中面向对象主要有以下两个表现：
方法的重载和重写
对象的多态

对象的多态性主要分为以下两种类型：

向上转型：子类对象—>父类对象，对于向上转型，程序会自动完成，格式为

父类父类对象 = 子类实例；

向下转型：父类对象—>子类对象，对于向下转型，必须明确的指明要转型的子类类型，格式为子类子类对象(子类)父类实例；

举例：向上转型

 1 package company.feimao.package1;
 2 
 3 class O{
 4     public void fun1(){
 5         System.out.println("O--->public void fun1(){}");
 6     }
 7     public void fun2(){
 8         this.fun1();
 9     }
10 }
11 class P extends O{
12     public void fun1(){
13         System.out.println("P-->public void fun1(){}");
14     }
15     public void fun3(){
16         System.out.println("P-->public void fun3(){}");
17     }
18 }
19 public class PolDemo01 {
20     public static void main(String args[]){
21         P p = new P();
22         O o = p;
23         o.fun1();
24     }
25 }
26 
27

举例：向下转型

 1 package company.feimao.package1;
 2 
 3 
 4 
 5 class O{
 6 
 7     public void fun1(){//定义fun1()方法
 8 
 9         System.out.println("O--->public void fun1(){}");
10 
11     }
12 
13     public void fun2(){//调用fun1()方法
14 
15         this.fun1();
16 
17     }
18 
19 }
20 
21 class P extends O{
22 
23     public void fun1(){//此方法被子类覆写
24 
25         System.out.println("P-->public void fun1(){}");
26 
27     }
28 
29     public void fun3(){
30 
31         System.out.println("P-->public void fun3(){}");
32 
33     }
34 
35 }
36 
37 public class PolDemo01 {
38 
39     public static void main(String args[]){
40 
41         O o = new P();//向上转型
42 
43         P p = (P)o;//发生向下转型关系
44 
45         p.fun1();
46 
47         p.fun2();
48 
49         p.fun3();
50 
51     }
52 
53 }
54

如果两个没有关系的对象之间发生了转换关系，则肯定会出现ClassCastException

也就是说，如果想产生对象向下转型，则肯定必须先产生一个向上的转型关系“A a = new B();”表示建立关系。

举例：

涉及一个方法，此方法可以接受父类的任意子类对象，并调用方法。实现要求：
1.不使用对象的多态完成
2.使用多态完成

 1 package com.feimao.code;
 2 
 3 class H{
 4     public void fun1(){
 5         System.out.println("O--->public void fun1(){}");
 6     }
 7     public void fun2(){
 8         System.out.println("O--->public void fun2(211){}");
 9     }
10 }
11 class I extends H{
12     public void fun1(){
13         System.out.println("I-->public void fun1(152){}");
14     }
15     public void fun4(){
16         System.out.println("I-->public void fun3(){}");
17     }
18 }
19 public class PolDemo04 {
20     public static void main(String args[]){
21      fun1(new I());//传递I的事例
22     }
23     public static void fun1(I i){
24         i.fun1();//覆写父类的中发fun1()方法
25         i.fun2();
26     }
27 
28     }

按照以上代码，每增加一个子类就颠写一遍父类方法，如果使用多态，不然增加多少子类，轻松搞定。

 1 package com.feimao.code;
 2 
 3 class H{
 4     public void fun1(){
 5         System.out.println("O--->public void fun1(){}");
 6     }
 7     public void fun2(){
 8         System.out.println("O--->public void fun2(211){}");
 9     }
10 }
11 class I extends H{
12     public void fun1(){
13         System.out.println("I-->public void fun1(152){}");
14     }
15     public void fun4(){
16         System.out.println("I-->public void fun3(){}");
17     }
18 }
19 public class PolDemo04 {
20     public static void main(String args[]){
21      fun1(new I());//传递I的事例
22     }
23     public static void fun1(H h){
24         h.fun1();//覆写父类的中发fun1()方法
25         h.fun2();
26     }
27 
28     }

子类覆写父类方法，优先访问子类方法，如果子类方法不存在或者不能访问，才会访问本类即父类方法。

0基础学java_面向对象之多态

相关推荐