多态

1.多态的概述

2.多态的格式和使用

 1 public class FuTest1 {
 2     public void method(){
 3         System.out.println("父类方法");
 4     }
 5     public void methodFu(){
 6         System.out.println("父类特有方法");
 7     }
 8 }
 9 
10 
11 public class ZiTest extends FuTest1{
12     @Override
13     public void method(){
14         System.out.println("子类特有方法");
15     }
16 }
17 
18 
19 /*
20 代码中体现多态性，其实就是一句话:父类引用指向子类对象
21 格式：
22 父类名称 对象名 = new 子类名称();
23 或者：
24 接口名称 对象名 = new 实现类名称
25  */
26 public class Demo01Multi {
27     public static void main(String[] args) {
28 //        ZiTest zi  = new ZiTest();
29 //        zi.method();
30 //        zi.methodFu();
31         //多态的写法：左侧父类的引用，指向了右侧子类的对象。
32           FuTest1 obj = new ZiTest();
33           obj.method();
34           obj.methodFu();
35     }
36 }

3.多态中成员变量的使用特点

 1 public class FuTest2 /*extends Object*/ {
 2     int num = 10;
 3     public void showNum(){
 4         System.out.println(num);
 5     }
 6 
 7 
 8 
 9 public class ZiTest2 extends FuTest2{
10     int num = 20;
11     int age = 15;
12 
13     @Override
14     public void showNum() {
15         System.out.println(num);
16     }
17 }
18 
19 
20 /*
21 访问成员变量的两种方式：
22 1.直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有则想上找。
23 2.间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则想上找。
24  */
25 public class Demo02Multi {
26     public static void main(String[] args) {
27         FuTest2 obj = new ZiTest2();
28         System.out.println(obj.num); //父：10
29         //System.out.println(obj.age);//错误写法：父类没有该变量，向上找不到
30         System.out.println("=======================");
31         //子类没有覆盖重写就是父：10
32         //子类覆盖重写，就是访问子：20
33         obj.showNum();
34     }
35 }

4.多态中成员方法的使用特点

 1 public class FuTest3 {
 2     public void method(){
 3         System.out.println("父类方法");
 4     }
 5     public void methodFu(){
 6         System.out.println("父类特有方法");
 7     }
 8 }
 9 
10 
11 public class ZiTest3 extends FuTest3{
12     public void method(){
13         System.out.println("子类方法");
14     }
15     public void methodZi(){
16         System.out.println("子类特有方法");
17     }
18 }
19 
20 
21 /*
22 在多态的代码中，成员方法的访问规则是：
23     看new的是谁，就优先用谁，没有则向上找。
24     口诀：编译看左边，运行看右边
25 对比一下：
26 成员变量：编译看左边，运行还看左边
27 成员方法：编译看左边，运行看右边
28  */
29 public class Domo02Multi {
30     public static void main(String[] args) {
31         FuTest3 obj = new ZiTest3(); //多态
32         obj.method(); // 父子都有，优先用子
33         obj.methodFu(); //子类没有，父类有，向上找到父类
34 
35     }
36 }

5.使用多态的好处

6.对象的向上转型

 1 public abstract class Animal {
 2     public abstract void eat();
 3 }
 4 
 5 
 6 
 7 public class Cat extends Animal{
 8 
 9     @Override
10     public void eat() {
11         System.out.println("猫吃鱼");
12     }
13 }
14 
15 
16 public class Demo01Main {
17     public static void main(String[] args) {
18         //对象的向上转型：父类引用指向子类对象
19         Anima anima= new Cat();
20         anima.eat();
21     }
22 }

7.对象的向下转型

 1 public abstract class Anima {
 2     public abstract void eat();
 3 }
 4 
 5 
 6 public class Cat extends Anima{
 7 
 8     @Override
 9     public void eat() {
10         System.out.println("猫吃鱼");
11     }
12     public void catchMouse(){
13         System.out.println("猫抓老鼠");
14     }
15 }
16 
17 
18 public class Demo01Main {
19     public static void main(String[] args) {
20         //对象的向上转型：父类引用指向子类对象
21         Anima anima= new Cat(); //本来创建的时候就是一只猫
22         anima.eat();//猫吃鱼
23         //anima.catchMouse();//错误写法
24 
25         //向下转型，进行“还原”动作
26         Cat cat = (Cat) anima;
27         cat.catchMouse();//猫抓老鼠
28 
29         //下面是错误的向下转型
30         //本来new的时候是一只猫，现在非要当作狗
31         //错误写法！编译不会报错，但是运行会出现异常
32         //java.lang.ClassCastException
33 //        Dog dog = (Dog) animal;
34     }
35 }

8.用instanceof关键字进行类型判断

 1 /接上面6.7代码
 2 public class Dog extends Anima{
 3     @Override
 4     public void eat() {
 5         System.out.println("狗啃骨头");
 6     }
 7 }
 8 
 9 //如何才能直到一个父类引用的对象，本来是什么子类：
格式：  对象  instatceof  类名称
这将会得到一个boolean值的结果，也就是判断前面的对象能不能当作后面类型的实例
10 public class Demo02Instanceof {
11     public static void main(String[] args) {
12         Anima anima = new Cat();
13         anima.eat();
14         giveMePet(new Dog());
15     }

//如果希望调用子类特有的方法，需要向下转型
//判断一个父类引用animal本来是不是Dog
16     public static void giveMePet(Anima anima){
17         if (anima instanceof Dog){
18             Dog dog = (Dog) anima;
19             dog.eat();
20         }
21         if(anima instanceof Cat){
22             Cat cat = (Cat) anima;
23             cat.eat();
24         }
25     }
26 }

__EOF__

本文作者：cclv
本文链接：https://www.cnblogs.com/lcc-lv/p/16029885.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！