Java 面向对象（十一）：面向对象特性之三：多态性

一、多态概述（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：

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

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

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

　　　　Demo：

Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量

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

　　4、多态的应用案例

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

public class Test {
     public void method(Person e) {
         // ……
         e.getInfo();
     }
     public static void main(Stirng args[]) {
         Test t = new Test();
         Student m = new Student();
         Teacher te = new Teacher();
         t.method(te);
         t.method(m); // 子类的对象m传送给父类类型的参数e
     }
 }

　　5、虚拟方法调用（Virtual Method Invocation）

　　　　（1）正常的方法调用

Person e = new Person();
e.getInfo();
Student s = new Student();
s.getInfo();

　　　　（2）虚拟方法调用（多态情况下）

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

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

　　　　（3）编译时类型和运行时类型

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

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

　　6、多态不适用于属性

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

　　　　Demo：

public class Person {
    String name;
    int age;
    
    int id = 1001;
    
    public void eat(){
        System.out.println("人：吃饭");
    }
    
    public void walk(){
        System.out.println("人：走路");
    }
}
public class Man extends Person{
    
    boolean isSmoking;
    
    int id = 1002;
    
    public void earnMoney(){
        System.out.println("男人负责挣钱养家");
    }
    
    public void eat(){
        System.out.println("男人多吃肉，长肌肉");
    }
    
    public void walk(){
        System.out.println("男人霸气的走路");
    }
}

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.eat();
        
        Man man = new Man();
        man.eat();
        man.age = 25;
        man.earnMoney();
        
        System.out.println("*******************");
        //对象的多态性：父类的引用指向子类的对象
        Person p2 = new Man();
//        Person p3 = new Woman();
        //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
        p2.eat();
        p2.walk();
        
//        p2.earnMoney();
        
        System.out.println(p2.id);//1001
        
    }
}

四、多态小结

　　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:

public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}

public void method1(Person e) {
    if (e instanceof Person)
        // 处理Person类及其子类对象
    if (e instanceof Student)
        //处理Student类及其子类对象
    if (e instanceof Graduate)
        //处理Graduate类及其子类对象
}    

　　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：

// 定义类
abstract class Animal {
    abstract void eat();
}
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void watchHouse() {
        System.out.println("看家");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        Cat c = (Cat)a;
        c.catchMouse(); // 调用的是 Cat 的 catchMouse
    }
}

　　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：

// 定义父类
public abstract class Animal {
    public abstract void eat();
}

// 定义子类
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
}

// 定义测试类
public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Cat c = new Cat();
        Dog d = new Dog();
        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);
    /*
        以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
        而执行效果一致
    */
        showAnimalEat(c);
        showAnimalEat(d);
    }
    public static void showCatEat (Cat c){
        c.eat();
    }
    public static void showDogEat (Dog d){
        d.eat();
    }
    public static void showAnimalEat (Animal a){
        a.eat();
    }
}

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

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

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

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

八、多态的案例

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

public class Test {

    public static void main(String[] args){
        Sub s = new Sub();
        System.out.println(s.count);   //20
        s.display();                   //20
        Base b = s;        
        System.out.println(b == s);    //true
        System.out.println(b.count);   //10
        b.display();                   //20
    }
}

class Base {
    int count = 10;
    public void display() {
        System.out.println(this.count);
    }
}

class Sub extends Base {
    int count = 20;
    public void display() {
        System.out.println(this.count);
    }
}

　　子类继承父类：

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

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

常见面试：方法的重载与重写

　　方法的重载和重写都是实现多态的方式，区别在于重载是编译时的多态性，而重写实现的是运行时的多态性。

　　重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；

　　重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里式替换原则）。重载对返回类型没有特殊的要求。

　　方法重载的规则：

　　　　（1）方法名一致，参数列表中参数的顺序，类型，个数不同；

　　　　（2）重载与方法的返回值无关，存在于父类和子类，同类中；

　　　　（3）可以跑出不同的异常，可以有不同的修饰符；

　　方法重写的规则：

　　　　（1）参数列表必须完全与被重写方法的一致，返回类型必须完全与被重写的方法的返回类型一致；

　　　　（2）构造方法不能被重写，声明为 final 的方法不能被重写；声明为 static 的方法不能被重写，但是能够再次声明；声明为 private 的方法不能被重写；

　　　　（3）访问权限不能比父类的中被重写的访问权限低；

　　　　（4）重写的方法能够抛出任何非强制异常（非运行时异常），无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常。

　　5、从编译和运行角度看：

重载，是指允许存在多个同名方法，而这些方法的参数不同。 编译器根据方法不同的参数表， 对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。 它们的调用地址在编译期就绑定了。 Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。

所以： 对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定” ；而对于多态，只有等到方法调用的那一刻， 解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定” 。
引用一句Bruce Eckel的话： “不要犯傻，如果它不是晚绑定， 它就不是多态。”