一、多态概述(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 = new Student();
2 Object o = new Person(); //Object类型的变量o,指向Person类型的对象
3 o = new Student(); //Object类型的变量o,指向Student类型的对象
子类可看做是特殊的父类,所以父类类型的引用可以执行子类的对象:向上转型(upcasting)。
一个引用类型变量如果声明为父类的类型,但实际引用的是子类对象,那么该变量就不能再访问子类中添加的属性和方法。
Demo:
1 Student m = new Student();
2 m.school = “pku”; //合法,Student类有school成员变量
3 Person e = new Student();
4 e.school = “pku”; //非法,Person类没有school成员变量
注意:属性是在编译是确定的,编译是 e 是 Person类型,没有 school 成员变量,因而编译错误。
4、多态的应用案例
Demo:方法声明的形参类型为父类类型,可以使用子类的对象作为实参调用该方法
1 public class Test {
2 public void method(Person e) {
3 // ……
4 e.getInfo();
5 }
6 public static void main(Stirng args[]) {
7 Test t = new Test();
8 Student m = new Student();
9 Teacher te = new Teacher();
10 t.method(te);
11 t.method(m); // 子类的对象m传送给父类类型的参数e
12 }
13 }
5、虚拟方法调用(Virtual Method Invocation)
(1)正常的方法调用
1 Person e = new Person();
2 e.getInfo();
3 Student s = new Student();
4 s.getInfo();
(2)虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法,在多态情况下,将此时父类的方法称为虚拟方法,父类根据赋给它的不同子类对象,动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
1 Person p = new Student();
2 p.getInfo(); //调用Student类的getInfo() 方法
(3)编译时类型和运行时类型
编译时 p 为 Person类型,而方法的调用是在运行时确定的,所以调用的是 Student 类的 getInfo() 方法。——动态绑定。
注意:多态是在运行时期的!
6、多态不适用于属性
对象的多态性,只是适用于方法,不适用于属性(即:编译看左边,运行看左边)
Demo:
1 public class Person {
2 String name;
3 int age;
4
5 int id = 1001;
6
7 public void eat(){
8 System.out.println("人:吃饭");
9 }
10
11 public void walk(){
12 System.out.println("人:走路");
13 }
14 }
15 public class Man extends Person{
16
17 boolean isSmoking;
18
19 int id = 1002;
20
21 public void earnMoney(){
22 System.out.println("男人负责挣钱养家");
23 }
24
25 public void eat(){
26 System.out.println("男人多吃肉,长肌肉");
27 }
28
29 public void walk(){
30 System.out.println("男人霸气的走路");
31 }
32 }
33
34 public class PersonTest {
35 public static void main(String[] args) {
36 Person p1 = new Person();
37 p1.eat();
38
39 Man man = new Man();
40 man.eat();
41 man.age = 25;
42 man.earnMoney();
43
44 System.out.println("*******************");
45 //对象的多态性:父类的引用指向子类的对象
46 Person p2 = new Man();
47 // Person p3 = new Woman();
48 //多态的使用:当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法 ---虚拟方法调用
49 p2.eat();
50 p2.walk();
51
52 // p2.earnMoney();
53
54 System.out.println(p2.id);//1001
55
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 extends Object {…}
2 public class Student extends Person {…}
3 public class Graduate extends Person {…}
4
5 public void method1(Person e) {
6 if (e instanceof Person)
7 // 处理Person类及其子类对象
8 if (e instanceof Student)
9 //处理Student类及其子类对象
10 if (e instanceof Graduate)
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 class Animal {
3 abstract void eat();
4 }
5 class Cat extends Animal {
6 public void eat() {
7 System.out.println("吃鱼");
8 }
9 public void catchMouse() {
10 System.out.println("抓老鼠");
11 }
12 }
13 class Dog extends Animal {
14 public void eat() {
15 System.out.println("吃骨头");
16 }
17 public void watchHouse() {
18 System.out.println("看家");
19 }
20 }
21
22 // 测试类
23 public class Test {
24 public static void main(String[] args) {
25 // 向上转型
26 Animal a = new Cat();
27 a.eat(); // 调用的是 Cat 的 eat
28 // 向下转型
29 Cat c = (Cat)a;
30 c.catchMouse(); // 调用的是 Cat 的 catchMouse
31 }
32 }
6、转型中的异常
转型的过程中,一不小心就会遇到这样的问题,观察下面的代码:
1 public class Test {
2 public static void main(String[] args) {
3 // 向上转型
4 Animal a = new Cat();
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 class Test {
2 public static void main(String[] args) {
3 // 向上转型
4 Animal a = new Cat();
5 a.eat(); // 调用的是 Cat 的 eat
6 // 向下转型
7 if (a instanceof Cat){
8 Cat c = (Cat)a;
9 c.catchMouse(); // 调用的是 Cat 的 catchMouse
10 } else if (a instanceof Dog){
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 class Animal { 3 public abstract void eat(); 4 } 5 6 // 定义子类 7 class Cat extends Animal { 8 public void eat() { 9 System.out.println("吃鱼"); 10 } 11 } 12 class Dog extends Animal { 13 public void eat() { 14 System.out.println("吃骨头"); 15 } 16 } 17 18 // 定义测试类 19 public class Test { 20 public static void main(String[] args) { 21 // 多态形式,创建对象 22 Cat c = new Cat(); 23 Dog d = new Dog(); 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 void showCatEat (Cat c){ 36 c.eat(); 37 } 38 public static void showDogEat (Dog d){ 39 d.eat(); 40 } 41 public static void showAnimalEat (Animal a){ 42 a.eat(); 43 } 44 }
由于多态的支持,showAnimalEat 方法的 Animal 类型,是 Cat 和 Dog 的父类类型,父类类型接收子类对象,当然可以把 Cat 对象 和 Dog 对象,传递给方法。
当eat方法执行时,多态规定,执行的是子类重写的方法,那么效果自然与showCatEat、showDogEat方法一致,所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代,在扩展性方面,无论之后再多的子类出现,我们都不需要编写showXxxEat方法了,直接使用showAnimalEat都可以完成。
多态的好处,体现在,可以使程序编写的更简单,并有良好的扩展。
八、多态的案例
Demo:继承成员变量和继承方法的区别
1 public class Test { 2 3 public static void main(String[] args){ 4 Sub s = new Sub(); 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 11 } 12 } 13 14 class Base { 15 int count = 10; 16 public void display() { 17 System.out.println(this.count); 18 } 19 } 20 21 class Sub extends Base { 22 int count = 20; 23 public void display() { 24 System.out.println(this.count); 25 } 26 }
子类继承父类:
(1)若子类重写了父类方法,就意味着子类里定义的方法彻底覆盖了父类里的同名方法,系统将不可能把父类里的方法转移到子类中;
(2)对于实力变量则不存在这样的现象,即使子类里定义了与父类完全相同的实例变量,这个实例变量依然不可能覆盖父类中定义的实例变量;
常见面试:方法的重载与重写
方法的重载和重写都是实现多态的方式,区别在于重载是编译时的多态性,而重写实现的是运行时的多态性。
重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;
重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里式替换原则)。重载对返回类型没有特殊的要求。
方法重载的规则:
(1)方法名一致,参数列表中参数的顺序,类型,个数不同;
(2)重载与方法的返回值无关,存在于父类和子类,同类中;
(3)可以跑出不同的异常,可以有不同的修饰符;
方法重写的规则:
(1)参数列表必须完全与被重写方法的一致,返回类型必须完全与被重写的方法的返回类型一致;
(2)构造方法不能被重写,声明为 final 的方法不能被重写;声明为 static 的方法不能被重写,但是能够再次声明;声明为 private 的方法不能被重写;
(3)访问权限不能比父类的中被重写的访问权限低;
(4)重写的方法能够抛出任何非强制异常(非运行时异常),无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常。
5、从编译和运行角度看:
重载,是指允许存在多个同名方法,而这些方法的参数不同。 编译器根据方法不同的参数表, 对同名方法的名称做修饰。对于编译器而言,这些同名方法就成了不同的方法。 它们的调用地址在编译期就绑定了。 Java的重载是可以包括父类和子类的,即子类可以重载父类的同名不同参数的方法。
所以: 对于重载而言,在方法调用之前,编译器就已经确定了所要调用的方法,这称为“早绑定”或“静态绑定” ;而对于多态,只有等到方法调用的那一刻, 解释运行器才会确定所要调用的具体方法,这称为“晚绑定”或“动态绑定” 。
引用一句Bruce Eckel的话: “不要犯傻,如果它不是晚绑定, 它就不是多态。”