java中的多态
1. 多态性的概述
面向对象的三大特征：封装性、继承性、多态性。
extends继承或者implements实现，无论是类与类之间的继承、类与接口之间的实现还是接口与接口间的继承，反正总会出现上下的层次关系，这种关系的产生就是多态性出现的前提。
看下图解析：
2. 在代码中体现多态性
-
代码中体现多态性，其实就是一句话，父类引用指向子类对象
-
格式：左父右子
父类名称 对象名 = new 子类名称();
或者；
接口名称 对象名 = new 实现类名称();
-
代码中体现多态性：
- 先新建一个People类
public class People{ public void method(){ System.out.println("我是父类方法"); } }- 再来个Student类，并继承People类
public class Student extends People{ public void method(){ System.out.println("我是子类方法"); } }- 在main中用
父类名称 对象名 = new 子类名称();格式新建一个对象
public class Demo01Main { public static void main(String[] args) { People John = new Student(); John.method(); //我是子类方法 } }- 上面代码中，用子类来构造父类的对象，然后调用重名方法method()，调用的是子类的method()方法，这就说明了当父类和子类有重名方法时，看等号“=” 右边的是什么类，调用的就是什么类的方法
- 用子类来构造父类是可以的，因为“子类就是一个父类”好比“学生就是一个人”，我们可以把学生当人看，但是人不一定就是学生，People John = new Student();这句代码从右往左读就是【把学生当人看，John有人的形态，也有学生的形态】，多态性出来了。
- Student John = new People(); 这就不行了，从右往左看，把人当学生看，人一定是学生吗？不一定呀！
3. 多态中成员变量的访问特点
3.1 访问成员变量的两种方式概述
- 直接通过对象名称访问成员变量（非private修饰的变量）：看创建对象语句中的等号，等号左边是谁，就优先用谁，没有则向上找，永远不会向下找。
- 间接用过成员方法访问：看该方法属于谁，优先用谁，没有则向上找，永远不会向下找。
3.2 方式一：直接通过对象名称访问成员变量
等号左边是谁，就优先用谁，没有则向上找
-
新建一个Fu类
public class Fu{ int num = 10; } -
新建一个Zi类，继承Fu类
public class Zi extends Fu{ int num = 20; //与父类中的num重名 } -
在main中，用父类引用指向子类对象，等号的左边是父类，优先用父类的num
public class Demo01Main { public static void main(String[] args) { Fu fu = new Zi(); System.out.println(fu.num); //10，打印的是父类的num } }
3.2 方式二：间接用过成员方法访问
看该方法属于谁，优先用谁，没有则向上找，永远不会向下找。
-
新建一个父类
public class Fu{ int num = 10; //父类独有的方法 public void methodFu(){ System.out.println(num); } } -
新建一个子类
public class Zi extends Fu{ int num = 20; //子类独有的方法 public void methodZi(){ System.out.println(num); } } -
看main中的注释
public class Demo01Main { public static void main(String[] args) { //多态的写法 Fu fu = new Zi(); fu.methodFu(); //父类的 num = 10，该方法属于父类，打印的必定是父类的num System.out.println("------------"); Zi zi = new Zi(); zi.methodFu(); //父类的 num = 10，该方法属于父类，打印的必定是父类的num zi.methodZi(); //子类的 num = 20，该方法属于子类，打印的必定是子类的num } }
4. 多态中成员方法的使用特性
在多态的代码中，成员方法的访问规则是：看new的是谁就优先用谁，没有就往上找。
但是现在我们介绍一个非常好用的口诀：编译看左边，运行看右边。
首先看左边，看能不能编译，编译都不行，那就没必要看右边了。
请看下面代码演示：
-
新建一个父类
public class Fu{ int numFu = 10; //子类也有一个叫method的方法 public void method(){ System.out.println(numFu); } //父类独有的方法 public void methodFu(){ System.out.println(numFu); } } -
新建一个子类
public class Zi extends Fu{ int numZi = 20; //父类也有一个叫method的方法，现在重写它 @Override public void method(){ System.out.println(numZi); } //子类独有的方法 public void methodZi(){ System.out.println(numZi); } } -
看main中的注释
/* 编译看左边，运行看右边 首先看左边，看能不能编译，编译都不行，那就没必要看右边了 */ public class Demo01Main { public static void main(String[] args) { // 1. 多态的写法，左边是父类，右边是子类 Fu fu = new Zi(); //左，父类中有 method 方法，编译准过,其实看代码有没有变红就知道了； //右，子类中有 method 方法，运行时，优先用子类的 fu.method(); //20 //左，父类中有 methodFu 方法，编译准过, 而且代码没变红； //右，子类中没有 methodFu 方法，往上找，父类有，运行时用父类的 fu.methodFu(); //10 //左，父类中没有 methodZi 方法，往上找，也没有，编译不能过 // fu.methodZi(); System.out.println("----------------------------"); // 2. 注意了，左边是父类，右边是父类 Fu fu1 = new Fu(); //左，父类有 method 方法，编译能过 //右，父类有 method 方法，运行用父类的 fu1.method(); //10 //左，父类中没有 methodZi() 方法，往上找，也没有，编译不能过 // fu1.methodZi(); System.out.println("----------------------------"); // 3. 注意了，左边是子类，右边也是子类 Zi zi = new Zi(); //左，子类中有 method 方法，编译能过 //右，子类中有 method 方法，运行用子类的 zi.method(); //20 //左，子类中没有 methodFu 方法，往上找，父类有，编译能过 //右，子类中没有 methodFu 方法，往上找，父类有，运行时用父类的 zi.methodFu(); //10 } }
成员方法的访问特性：编译看左边，运行看右边
成员变量的访问特性：编译看左边，运行还是看左边
5. 使用多态的好处
仔细观察上图，如果我们不用多态，只用子类，那么写法是
Teacher one = new Teacher();
one.work(); //讲课
Assistant two = new Assistant();
two.work(); //辅导
如果使用多态的写法，对比一下：
Employee one = new Teacher();
one.work(); //讲课，口诀：编译看左边，运行看右边
Employee two = new Assistant();
two.work(); //辅导
所以，它的好处是：无论右边new的时候换成哪个子类对象，等号左边都是Employee，调用方法也不会发生变化
6. 向上转型
对象的向上造型，其实就是多态的写法，左父右子：
格式：父类名称 对象名 = new 子类名称();
比如：Animal animal = new Cat(); //创建了一只猫，当做动物看待
含义：右侧创建一个子类对象，把它当做父类来看待使用。
注意事项：向上造型一定是安全的。从小范围到大范围，从小范围的猫，向上转换为更大范围的动物
代码演示：向上造型
-
先来一个父类，Animal类
//抽象类 public abstract class Animal { //抽象方法 public abstract void eat(); } -
再来一个子类，Cat类
public class Cat extends Animal { //重写抽象方法 @Override public void eat() { System.out.println("猫吃鱼"); } } -
在main中采用多态写法，创建猫的对象，用动物类引用指向它
public class Demo02Main { public static void main(String[] args) { //多态的写法，左父右子，把猫当动物来看，向上造型 Animal animal = new Cat(); //编译看左边，运行看右边，上面等式的左边是父类，右边是子类 //左，父类，父类中含有 eat 方法，编译能过 //右，子类，子类中含有 eat 方法，运行子类中的 eat 方法 animal.eat(); } }
7. 向下转型
向上转型一定是正确的，但是它有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
还是上面的动物和猫例子
7.1 代码演示：向上转型的弊端
-
先来一个动物类
//抽象类 public abstract class Animal { //抽象方法 public abstract void eat(); } -
再来一个猫类，它有自己独有的抓老鼠方法
public class Cat extends Animal { //重写抽象方法 @Override public void eat() { System.out.println("猫吃鱼"); } // Cat类独有的方法,抓老鼠 public void CatchMouse() { System.out.println("抓老鼠"); } } -
在main中，采用多态的写法，并尝试调用抓老鼠方法，结果调用失败
public class Demo02Main { public static void main(String[] args) { //多态的写法，左父右子，把猫当动物来看，向上造型 Animal animal = new Cat(); //左，父类，父类中没有 CatchMouse 方法，编译报错 // animal.CatchMouse(); } } -
结论：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
7.2 修补向上造型的弊端，向下造型【还原】
对象的向下造型，其实就是一个【还原】的动作
注意：还原指的是==本来是一只猫，才能还原成一只猫==
上面的例子中，猫向上造型成为动物，它本来就是一只猫，才能从动物还原成猫，这才叫【还原】
格式：子类名称 对象名 = (子类名称) 父类对象
Animal animal = new Cat(); //本来是猫，向上转型为动物
Cat cat =（Cat）animal; // 本来是猫，已经被当做动物了，还原回来成为原来的猫
7.2.1 注意事项：
a. 必须保证对象本来创建的时候，就是猫，才能向下转型成猫，本来是猫，向下转型成狗也不行。
b. 如果对象创建的时候本来不是猫，现在非要向下转型成猫，就会报错
7.2.2 修补7.1中的main的代码问题
public class Demo02Main {
public static void main(String[] args) {
//多态的写法，左父右子，把猫当动物来看，向上造型
Animal animal = new Cat();
//左，父类，父类中没有 CatchMouse 方法，编译报错
// animal.CatchMouse();
//向下转型成猫
Cat cat = (Cat)animal;
//调用猫的独有方法
cat.CatchMouse(); //抓老鼠
}
}
8. instanceof关键字
我们说向下转型不一定是安全的，如果animal本来是一只猫，非要向下转型成狗，就会引发类转型异常ClassCastException，所以我们每次向下转型前最好先进行判断，判断这次转型安不安全，instanceof关键字就起作用了。
格式：instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
代码演示：instanceof关键字
-
先来个动物类
//抽象类 public abstract class Animal { //抽象方法 public abstract void eat(); } -
猫类
public class Cat extends Animal { //重写抽象方法 @Override public void eat() { System.out.println("猫吃鱼"); } // Cat类独有的方法,抓老鼠 public void CatchMouse() { System.out.println("抓老鼠"); } } -
狗类
public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃骨头"); } //狗的独有方法，看门 public void watchHouse(){ System.out.println("狗看门"); } } -
写一个方法giveMeAPet，判断它本来是猫还是狗
public class Demo02Main { public static void main(String[] args) { //多态的写法，左父右子，把猫当动物来看，向上造型 Animal animal = new Cat(); giveMeAPet(animal); } //送一个动物进来，判断它本来是猫还是狗 public static void giveMeAPet(Animal animal){ //本来是一个猫 if(animal instanceof Cat){ //安全地向下转型为猫 Cat cat = (Cat)animal; cat.eat(); cat.CatchMouse(); } //本来是一个狗 if(animal instanceof Dog){ //安全地向下转型为狗 Dog dog = (Dog)animal; dog.eat(); dog.watchHouse(); } } } /*输出结果： 猫吃鱼 抓老鼠 */
扫一扫
3487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
