java 对象的态_Java 面向对象（十一）：面向对象特性之三：多态性

最新推荐文章于 2023-02-05 12:01:21 发布

CyberNinja

最新推荐文章于 2023-02-05 12:01:21 发布

阅读量173

点赞数

文章标签： java 对象的态

本文链接：https://blog.csdn.net/weixin_35828357/article/details/114586391

版权

一、多态概述(Polymorphism)

1、引入

多态是继封装、继承之后，面向对象的第三大特性。

可以理解为一个事物的多种形态。通过不同的事物，体现出来的不同的形态。多态，描述的就是这样的状态。如跑的动作，每个动物的跑的动作就是不一样的。

2、定义

多态：是指同一行为，具有多个不同表现形式。

3、Java 中多态的前提【重点】

(1)继承或实现【二选一】；

(2)方法的重写【意义体现：不重写，无意义】

(3)父类引用指向子类对象【格式体现】

二、多态性

1、多态性

多态性，是面向对象中最重要的概念，在 Java 中的体现：

对象的多态性：父类的引用指向子类的对象；(可以直接应用在抽象类和接口上)

2、变量的引用形式

(1)本态引用：左边的变量与右边的对象是同一种类型；

(2)多态引用：左边的变量是父类类型，右边的对象是子类的对象；

3、多态的表现出来的特征

特征：编译类型与运行时类型不一致；

编译的时候，按照父类的类型进行编译的；

执行的方法，按照子类类型运行，是“执行子类重写的方法”。

口诀：编译看左边，运行看右边。

注意：多态强调的是方法的动态绑定，即多态与属性无关，只说方法。

4、多态

Java 引用变量有两个类型：编译时类型和运行时类型。

编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

多态情况下：“看左边”：看的是父类的引用(父类中不具备子类特有的方法)

“看右边”：看的是子类的对象(实际运行的是子类重写父类的方法)

三、多态的使用：虚拟方法调用

1、多态的使用

有了对象的多态性以后，在编译期，只能调用父类中声明的方法，但在运行期间我们实际执行的是子类重写父类的方法。

口诀：编译看左边，运行看右边。

2、多态的使用前提

(1)类的继承关系；

(2)方法的重写；

3、对象的多态

在Java中，子类的对象可以替换父类的对象使用：

(1)一个变量只能有一种确定的数据类型；

(2)一个引用类型变量可能只需(引用)多种不同的类型的对象；

Demo：

1 Person p = newStudent();2 Object o = new Person(); //Object类型的变量o，指向Person类型的对象

3 o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以执行子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。

Demo：

1 Student m = newStudent();2 m.school = “pku”; //合法,Student类有school成员变量

3 Person e = newStudent();4 e.school = “pku”; //非法,Person类没有school成员变量

注意：属性是在编译是确定的，编译是 e 是 Person类型，没有 school 成员变量，因而编译错误。

4、多态的应用案例

Demo：方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

1 public classTest {2 public voidmethod(Person e) {3 //……

4 e.getInfo();5 }6 public static voidmain(Stirng args[]) {7 Test t = newTest();8 Student m = newStudent();9 Teacher te = newTeacher();10 t.method(te);11 t.method(m); //子类的对象m传送给父类类型的参数e

12 }13 }

5、虚拟方法调用(Virtual Method Invocation)

(1)正常的方法调用

1 Person e = newPerson();2 e.getInfo();3 Student s = newStudent();4 s.getInfo();

(2)虚拟方法调用(多态情况下)

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

1 Person p = newStudent();2 p.getInfo(); //调用Student类的getInfo() 方法

(3)编译时类型和运行时类型

编译时 p 为 Person类型，而方法的调用是在运行时确定的，所以调用的是 Student 类的 getInfo() 方法。——动态绑定。

注意：多态是在运行时期的！

6、多态不适用于属性

对象的多态性，只是适用于方法，不适用于属性(即：编译看左边，运行看左边)

Demo：

1 public classPerson {2 String name;3 intage;4

5 int id = 1001;6

7 public voideat(){8 System.out.println("人：吃饭");9 }10

11 public voidwalk(){12 System.out.println("人：走路");13 }14 }15 public class Man extendsPerson{16

17 booleanisSmoking;18

19 int id = 1002;20

21 public voidearnMoney(){22 System.out.println("男人负责挣钱养家");23 }24

25 public voideat(){26 System.out.println("男人多吃肉，长肌肉");27 }28

29 public voidwalk(){30 System.out.println("男人霸气的走路");31 }32 }33

34 public classPersonTest {35 public static voidmain(String[] args) {36 Person p1 = newPerson();37 p1.eat();38

39 Man man = newMan();40 man.eat();41 man.age = 25;42 man.earnMoney();43

44 System.out.println("*******************");45 //对象的多态性：父类的引用指向子类的对象

46 Person p2 = newMan();47 //Person p3 = new Woman();48 //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用

49 p2.eat();50 p2.walk();51

52 //p2.earnMoney();

54 System.out.println(p2.id);//1001

56 }57 }

四、多态小结

1、多态作用

提高了代码的通用性，常称作接口重用；

2、前提

(1)需要存在继承或者实现关系

(2)有方法的重写

3、成员方法

编译时：要查看引用变量所声明的类是否有所调用的方法；

运行时：调用实际 new 的对象所属的类中的重写方法；

口诀：编译看左边，运行看右边。

4、成员变量

成员变量不具备多态性，只看引用变量所声明的类。

口诀：编译看左边，运行看左边。

五、对象类型转换(Casting)

1、instance 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

要求 x 所属的类与类A必须是子类和父类的关系，否则编译错误。

如果 x 属于类A的子类B，x instanceof A 值也为 true。

Demo:

1 public class Person extendsObject {…}2 public class Student extendsPerson {…}3 public class Graduate extendsPerson {…}4

5 public voidmethod1(Person e) {6 if (e instanceofPerson)7 //处理Person类及其子类对象

8 if (e instanceofStudent)9 //处理Student类及其子类对象

10 if (e instanceofGraduate)11 //处理Graduate类及其子类对象

12 }

2、对象类型转换(Casting)

基本数据类型的 Casting

(1)自动类型转换：小的数据类型可以自动转换成大的数据类型；

如long g=20; double d=12.0f

(2)强制类型转换：可以把大的数据类型强制转换成小的数据类型；

如 float f=(float)12.0; int a=(int)1200L

对 Java 对象的强制类型转换称为造型

(1)从子类到父类的类型转换可以自动进行；向上转型(UpCasting)

(2)从父类到子类的类型转换必须通过造型(强制类型转换)实现；向下转型(DownCasting)

(3)无继承关系的引用类型间的转换是非法的；

(4)在造型前可以使用 instanceof 操作符测试一个对象的类型；

3、向上转型(UpCasting)

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型变量名 = new 子类类型();

如：Animal a = new Cat();

4、向下转型(DownCasting)

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型，向下转型的目的是为了调用子类特有的方法等。

使用格式：

子类类型变量名 = (子类类型) 父类变量名;

如:Cat c =(Cat) a;

5、转型原因

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。

当使用多态方式方法时，首先要检查父类中是否有该方法，如果没有，则编译错误。不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的“小麻烦”。所以，想要调用子类特有的方法，必须做向下转型。

Demo：

1 //定义类

2 abstract classAnimal {3 abstract voideat();4 }5 class Cat extendsAnimal {6 public voideat() {7 System.out.println("吃鱼");8 }9 public voidcatchMouse() {10 System.out.println("抓老鼠");11 }12 }13 class Dog extendsAnimal {14 public voideat() {15 System.out.println("吃骨头");16 }17 public voidwatchHouse() {18 System.out.println("看家");19 }20 }21

22 //测试类

23 public classTest {24 public static voidmain(String[] args) {25 //向上转型

26 Animal a = newCat();27 a.eat(); //调用的是 Cat 的 eat28 //向下转型

29 Cat c =(Cat)a;30 c.catchMouse(); //调用的是 Cat 的 catchMouse

31 }32 }

6、转型中的异常

转型的过程中，一不小心就会遇到这样的问题，观察下面的代码：

1 public classTest {2 public static voidmain(String[] args) {3 //向上转型

4 Animal a = newCat();5 a.eat(); //调用的是 Cat 的 eat

6 //向下转型

7 Dog d =(Dog)a;8 d.watchHouse(); //调用的是 Dog 的 watchHouse 【运行报错】

9}10 }

这段代码可以通过编译，但是运行时，却报出了 ClassCastException，类型转换异常！

这是因为，明明创建了 Cat 类型对象，运行时，当然不能转换为 Dog 对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

向下转型是有风险的，为了避免 ClassCastException 的发生，java 提供了 instanceof 关键字，给引用变量类型的校验。

格式如下：

变量名/对象 instanceof数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false。

Demo：

1 public classTest {2 public static voidmain(String[] args) {3 //向上转型

4 Animal a = newCat();5 a.eat(); //调用的是 Cat 的 eat

6 //向下转型

7 if (a instanceofCat){8 Cat c =(Cat)a;9 c.catchMouse(); //调用的是 Cat 的 catchMouse

10 } else if (a instanceofDog){11 Dog d =(Dog)a;12 d.watchHouse(); //调用的是 Dog 的 watchHouse

13}14}15 }

7、

六、多态的使用【重要】

1、访问成员变量

(1)直接通过对象名称访问成员变量：看等号左边是谁，就优先用谁，没有则向上找；

(2)间接通过成员方法访问成员变量：看该方法属于谁，就优先用谁，没有则向上找；

2、访问成员方法

规则：看 new 的是谁，就优先用谁，没有则向上找；

3、总结

成员变量：编译看左边，运行还看左边；(变量无多态)

成员方法：编译看左边，运行看右边；

注意：多态是运行时行为，不是编译时行为。

4、子类继承父类

(1)若子类重写了父类方法，就意味或着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中；

(2)对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。

七、多态的好处

实际开发中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

Demo：

1 //定义父类

2 public abstract classAnimal {3 public abstract voideat();4 }5

6 //定义子类

7 class Cat extendsAnimal {8 public voideat() {9 System.out.println("吃鱼");10 }11 }12 class Dog extendsAnimal {13 public voideat() {14 System.out.println("吃骨头");15 }16 }17

18 //定义测试类

19 public classTest {20 public static voidmain(String[] args) {21 //多态形式，创建对象

22 Cat c = newCat();23 Dog d = newDog();24 //调用showCatEat

25 showCatEat(c);26 //调用showDogEat

27 showDogEat(d);28 /*

29 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代30 而执行效果一致31 */

32 showAnimalEat(c);33 showAnimalEat(d);34 }35 public static voidshowCatEat (Cat c){36 c.eat();37 }38 public static voidshowDogEat (Dog d){39 d.eat();40 }41 public static voidshowAnimalEat (Animal a){42 a.eat();43 }44 }

由于多态的支持，showAnimalEat 方法的 Animal 类型，是 Cat 和 Dog 的父类类型，父类类型接收子类对象，当然可以把 Cat 对象和 Dog 对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

八、多态的案例

Demo：继承成员变量和继承方法的区别

1 public classTest {2

3 public static voidmain(String[] args){4 Sub s = newSub();5 System.out.println(s.count); //20

6 s.display(); //20

7 Base b =s;8 System.out.println(b == s); //true

9 System.out.println(b.count); //10

10 b.display(); //20