Object-oriented features three 2.5: Polymorphism
2.5.1 on java language upward transition and the downward transition
① upward transition (upcasting): Sub ---> Parent (automatic conversion)
② downward transition (downcasting): Parent ---> child (cast)
Note: either upward or downward transition in transition, there must be an inheritance relationship between two classes.
public class Animal{ //member public void eat(){ System.out.println ( "Animals eat!"); } } |
public class Cat extends Animal{ // rewrite public void eat(){ System.out.println ( "cat fish"); } // Cat peculiar way. public void move(){ System.out.println ( "cat catwalk!"); } } |
public class Test02{ public static void main(String[] args){ // upward transition is also called: Automatic type conversion . // parent type of reference point to sub-type object . // program in two phases: compilation phase, the operational phase. // compile stage only know that a1 is an Animal type. // actual object program at runtime stack is Cat type. Animal a1 = new Cat(); // program at compile a1 is regarded as the compiler Animal type . // so the program at compile a1 reference binding is Animal class eat method . ( Static binding ) // program at run time heap object is actually a Cat type, and Cat has been rewritten eat method. // so the program method binding object stage operation is Cat in the eat method . ( Dynamic binding ) a1.eat (); // cat fish //向下转型:强制类型转换 Animal a2 = new Cat(); //向上转型. //要执行move方法,怎么做? //只能强制类型转换,需要加强制类型转换符 Cat c1 = (Cat)a2; c1.move(); //判断以下程序运行的时候会出什么问题? //Animal a3 = new Dog(); //向上转型. //强制类型转换 //Cat c2 = (Cat)a3; // java.lang.ClassCastException //在做强制类型转换的时候程序是存在风险的! //为了避免ClassCastException的发生,java引入了 instanceof /* 用法: 1. instanceof运算符的运算结果是 boolean类型 2. (引用 instanceof 类型) --> true/false 例如:(a instanceof Cat) 如果结果是true表示:a引用指向堆中的java对象是Cat类型. */ Animal a3 = new Dog(); System.out.println(a3 instanceof Cat); //false //推荐:在做向下转型的时候要使用instanceof运算符判断,避免ClassCastException if(a3 instanceof Cat){ Cat c2 = (Cat)a3; } } } |
2.5.2 什么是多态
多态性,可以理解为一个事物的多种表型形态,是面向对象中最重要的概念,在java中有两种体现:
①方法的重载(overload)和重写(overwrite)。
②子类对象的多态性:并不适用于属性。调用属性是就看”.”左边的对象。可以直接应用在抽象类和接口上。
2.5.3 子类对象的多态性使用的前提
①要有类的继承
②要有子类对父类方法的重写
补充:
①程序运行分为编译状态和运行状态。
对于多态性来说,编译时,"看左边",将此引用变量理解为父类的类型;运行时,"看右边",关注于真正对象的实体:子类的对象。那么执行的方法就是子类重写的。
②Java引用变量有两个类型:编译时类型和运行时类型。
编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。若编译时类型和运行时类型不一致,就出现多态(Polymorphism)
2.5.4 对象的多态
在Java中,子类的对象可以替代父类的对象使用
①一个变量只能有一种确定的数据类型
②一个引用类型变量可能指向(引用)多种不同类型的对象
Person p = new Student(); Object o = new Person();//Object类型的变量o,指向Person类型的对象 o = new Student(); //Object类型的变量o,指向Student类型的对象 |
③子类可看做是特殊的父类,所以父类类型的引用可以指向子类的对象:向上转型(upcasting)。
④一个引用类型变量如果声明为父类的类型,但实际引用的是子类对象,那么该变量就不能再访问子类中添加的属性和方法。
Student m = new Student(); m.school = “pku”; //合法,Student类有school成员变量 Person e = new Student(); e.school = “pku”; //非法,Person类没有school成员变量 //属性是在编译时确定的,编译时e为Person类型,没有school成员变量,因而编译错误。 |
2.5.5 多态的好处
①使用多态可以使代码之间的耦合度降低。②项目的扩展能力增强。
例子:人喂养宠物
public class Person{//模拟主人 /* public void feed(Dog d){ //喂养 d.eat(); } public void feed(Cat c){ //因为用户的业务改变了,所以软件要升级。 c.eat(); } */ //以上的代码得出:Person类型的扩展能力太差。 //尽量不要面向具体编程,面向父类型编程,面向抽象编程 public void feed(Animal a){ a.eat(); } } |
public class Animal{ public void eat(){} } |
public class Cat extends Animal{//宠物1 public void eat(){ System.out.println("猫吃东西!"); } } |
public class Dog extends Animal{//宠物2 public void eat(){ System.out.println("狗吃东西!"); } } |
public class Test{//多态测试 public static void main(String[] args){ //1.创建主人 Person zhangsan = new Person(); //2.创建宠物 Dog d = new Dog(); Cat c = new Cat(); //3.喂 zhangsan.feed(d); zhangsan.feed(c); } } |
2.5.6 虚拟方法调用(Virtual Method Invocation)
①正常的方法调用
Person e = new Person(); e.getInfo(); Student e = new Student(); e.getInfo(); |
②虚拟方法调用(多态情况下)
Person e = new Student(); e.getInfo(); //调用Student类的getInfo()方法 |
编译时类型和运行时类型:
编译时e为Person类型,而方法的调用是在运行时确定的,所以调用的是Student类的getInfo()方法。——动态绑定
多态小结
1.前提:
- 需要存在继承或者实现关系
- 要有覆盖操作
2.成员方法:
- 编译时:要查看引用变量所属的类中是否有所调用的方法。
- 运行时:调用实际对象所属的类中的重写方法。
3.成员变量:不具备多态性,只看引用变量所属的类。
【记忆】
虚拟方法调用:通过父类的引用指向子类的对象实体,当调用方法时,实际执行的是子类重写父类的方法。
例子:有一个舞池,规定只有人能进入,动物不能进,这时一个男人进去了,是以人的身份,但是跳舞的时候是一个男人的姿势!即调用的方法是那个实体的方法!
1)多态性的表现:①方法的重载与重写 ②子类对象的多态性
2)使用的前提:①要有继承关系 ②要有方法的重写
3)格式:
Person p = new Man();//向上转型 // 虚拟方法调用:通过父类的引用指向子类的对象实体,当调用方法时,实际执行的是子类重写父类的方法 p1.eat(); p1.walk(); // p1.entertainment(); |
4)编译时,认为p是Person类型的,故只能执行Person里才有的结构,即Man里特有的结构不能够调用。子类对象的多态性,并不使用于属性。
5)关于向下转型:
①向下转型,使用强转符:()
②为了保证不报ClassCastException,最好在向下转型前,进行判断: instanceof
// 若a是A类的实例,那么a也一定是A类的父类的实例。 // 格式: 对象a instanceof 类A:判断对象a是否是类A的一个实例.是的话,返回true;否则返回false if (p1 instanceof Woman) { System.out.println("hello!"); Woman w1 = (Woman) p1; w1.shopping(); } if (p1 instanceof Man) { Man m1 = (Man) p1; m1.entertainment(); } |