Java——面向对象的特征三：多态性

2.5面向对象的特征三：多态性

2.5.1 关于java语言中的向上转型和向下转型

①向上转型(upcasting) :  子--->父（自动类型转换）

②向下转型(downcasting) :  父--->子（强制类型转换）

注意：无论是向上转型还是向下转型，两个类之间必须要有继承关系。

public class Animal{

//成员

public void eat(){

System.out.println("动物在吃！");

}

}

public class Cat extends Animal{

//重写

public void eat(){

System.out.println("猫吃鱼");

}

//Cat特有的方法.

public void move(){

System.out.println("猫走猫步！");

}

}

public class Test02{

public static void main(String[] args){

  //向上转型又被称作：自动类型转换.

              //父类型的引用指向子类型对象.

              //程序分两个阶段：编译阶段，运行阶段。

              //程序编译阶段只知道a1是一个Animal类型。

              //程序在运行的时候堆中的实际对象是Cat类型。

Animal a1 = new Cat();

  //程序在编译阶段a1被编译器看做Animal类型.

              //所以程序在编译阶段a1引用绑定的是Animal类中的eat方法.(静态绑定)

              //程序在运行的时候堆中的对象实际上是Cat类型，而Cat已经重写了eat方法。

              //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法.(动态绑定)

a1.eat(); //猫吃鱼

  //向下转型：强制类型转换

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();

}