Java

一、多态的概念

　　前提：必须在继承或者是实现接口的前提下；

　　概念：一个事物或者是一个对象多种形态（如机器狗是一个狗类，但也属于机器类，即一个对象有多种形态）；

　　特点：父类对象的引用指向子类的对象；

　　语法：父类类名 对象名 = new 子类类名；

二、多态访问成员变量

 1  1 //多态访问成员变量
 2  2 
 3  3 //父类
 4  4 class A{
 5  5     int numA = 10;
 6  6     int num = 50;
 7  7 }
 8  8 
 9  9 //子类
10 10 class B extends A{
11 11     int numB = 100;
12 12     int num = 500;
13 13 }
14 14 
15 15 //测试类
16 16 public class Test {
17 17     public static void main(String[] args) {
18 18         //实例化对象 多态
19 19         A a = new B(); //A为父类 B为子类
20 20         System.out.println(((B) a).num);//a.num==500 引用的是子类B的num
21 21         System.out.println(a.numA);//a.numA==10 引用的是父类A的numA
22 22         System.out.println(((B) a).numB);//a.numB==100 引用的是子类B的numB
23 23     }
24 24 }

三、多态中访问成员方法

 1 //多态访问成员方法
 2 
 3 //父类
 4 class A {
 5     public void showA(){
 6         System.out.println("我是父类的showA方法");
 7     }
 8     public void show(){
 9         System.out.println("我是父类的show方法");
10     }
11 }
12 
13 //子类
14 class B extends A {
15     public void showB(){
16         System.out.println("我是子类的showB方法");
17     }
18     public void show(){
19         System.out.println("我是子类的show方法");
20     }
21 }
22 
23 //测试类
24 public class Test {
25     public static void main(String[] args) {
26         //实例化对象 多态
27         A a = new B();
28         //展示
29         a.show();    //a.show 为子类show方法的
30         a.showA();     //a.showA 为父类的showA方法
31         ((B) a).showB();   //a.showB 为子类的showB方法
32     }
33 }

四、多态转型

1.多态向上转型

　　概念：把子类当做父类来看待，多态的向上转型（为自动类型转换）数据安全；

　　语法：父类类名 对象名 =  new 子类类名()；如 Pet p = new Cat();

　　问题：不能获取到子类独有的资源；　

2.多态向下转型

　　概念：将原本子类对象当做父类对象看待的子类对象，即还原成本身的子类；（将原本是猫当做动物类来看待，还原成本身猫类）

　　语法：子类类名 对象名 = （需要转换的子类对象）父类引用；如 Dog d = (Dog)p;

　　问题：向下转型类似强制类型转换，数据不安全；

案例case1：

 1 //宠物类
 2 class pet{
 3 
 4 
 5 }
 6 
 7 //狗类
 8 class dog extends pet{
 9     public void showdog(){
10         System.out.println("这里是showdog方法");
11     }
12 }
13 
14 
15 //猫类
16 class cat extends pet{
17     public void showcat(){
18         System.out.println("这里是showcat方法");
19     }
20 }
21 
22 //测试类
23 public class Test08 {
24     public static void main(String[] args) {
25         //多态向上转型
26         pet p = new cat();      //将猫类看成父类
27         
28         //多态向下转型
29         cat c = (cat)p;         //将被看成父类的猫类-->还原回猫类
30         c.showcat();        //不还原回猫类是不能调用猫类本身的方法的
31     }
32 }

结果图

案例case2：异常情况

 1 //宠物类
 2 class pet{
 3 
 4 
 5 }
 6 
 7 //狗类
 8 class dog extends pet{
 9     public void showdog(){
10         System.out.println("这里是showdog方法");
11     }
12 }
13 
14 
15 //猫类
16 class cat extends pet{
17     public void showcat(){
18         System.out.println("这里是showcat方法");
19     }
20 }
21 
22 //测试类
23 public class Test08 {
24     public static void main(String[] args) {
25         //多态向上转型
26         pet p = new cat();      //将猫类看成父类
27 
28         /*
29         //多态向下转型
30         cat c = (cat)p;         //将被看成父类的猫类-->还原回猫类
31         c.showcat();        //不还原回猫类是不能调用猫类本身的方法的
32         */
33 
34         //多态向下转型 若向下转型不是转回猫类 则会出现异常
35         dog d = (dog)p;
36         d.showdog();        //出现异常
37     }
38 }

 案例case3：instanceof 判断是否还原回子类

 1 //宠物类
 2 class pet{
 3 
 4 
 5 }
 6 
 7 //狗类
 8 class dog extends pet{
 9     public void showdog(){
10         System.out.println("这里是showdog方法");
11     }
12 }
13 
14 
15 //猫类
16 class cat extends pet{
17     public void showcat(){
18         System.out.println("这里是showcat方法");
19     }
20 }
21 
22 //测试类
23 public class Test08 {
24     public static void main(String[] args) {
25         //多态向上转型
26         pet p = new cat();      //将猫类看成父类
27 
28         /*
29         //多态向下转型
30         cat c = (cat)p;         //将被看成父类的猫类-->还原回猫类
31         c.showcat();        //不还原回猫类是不能调用猫类本身的方法的
32         */
33 
34         /*
35         //多态向下转型 若向下转型不是转回猫类 则会出现异常
36         dog d = (dog)p;
37         d.showdog();        //出现异常
38         */
39 
40         //多态向下转型 利用instanceof判断是否可以被还原回对应的子类
41         if(p instanceof dog){
42             dog d = (dog)p;
43             d.showdog();
44         }else if(p instanceof cat){
45             cat c = (cat)p;
46             c.showcat();
47         }
48     }
49 }

结果图