Java-面向对象-多态

Java-面向对象-多态

概念

简单的说，是同一种事物，在不同时刻表现不同状态

定义

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

“多态”名词详解

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

对多态的概述及作用

Java语言的三大特征：封装、继承、多态。多态是其三大特征之一。

多态的体现为：父类引用变量可以指向子类对象。

多态的意义（为什么要使用多态）：

• 可替换性（substitutability）：多态对已存在代码具有可替换性。例如，多态对圆Circle类有效，对其他任何圆形几何体，如圆环，也同样有效。

• 可扩充性（extensibility）：多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

• 接口性（interface-ability）：多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

• 灵活性（flexibility）：它在应用中体现了灵活多样的操作，提高了使用效率。

• 简化性（simplicity）：多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

多态存在的三个条件

• 要有继承（包括接口），这是前提条件。
• 要有重写，也是前提条件。子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
• 父类引用指向子类对象。在多态中需要将子类的引用赋给父类对象，只有这样才能够具备技能调用父类的方法和子类的方法。

举例说明

比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：

酒 a = 剑南春

酒 b = 五粮液

酒 c = 酒鬼酒

…

这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

诚然，要理解多态我们就必须要明白什么是“向上转型”。在继承中我们简单介绍了向上转型，这里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父类，剑南春（JNC）、五粮液（WLY）、酒鬼酒（JGJ）是子类。我们定义如下代码：

JNC a = new JNC();

对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛！但是这样呢？

Wine a = new JNC();

在这里我们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。由于JNC是继承与Wine，所以JNC可以自动向上转型为Wine，所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，它可以提供比父类更加强大的功能，如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。

但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在与子类中的方法和属性它就不能用了。

public class Wine {
    public void fun1(){
        System.out.println("Wine 的Fun.....");
        fun2();
    }
    
    public void fun2(){
        System.out.println("Wine 的Fun2...");
    }
}

public class JNC extends Wine{
    /**
     * @desc 子类重载父类方法
     *        父类中不存在该方法，向上转型后，父类是不能引用该方法的
     * @param a
     * @return void
     */
    public void fun1(String a){
        System.out.println("JNC 的 Fun1...");
        fun2();
    }
    
    /**
     * 子类重写父类方法
     * 指向子类的父类引用调用fun2时，必定是调用该方法
     */
    public void fun2(){
        System.out.println("JNC 的Fun2...");
    }
}

public class Test {
    public static void main(String[] args) {
        Wine a = new JNC();
        a.fun1();
    }
}
-------------------------------------------------
Output:
Wine 的Fun.....
JNC 的Fun2...

从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。

分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。

所以对于多态我们可以总结如下：

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

对于面向对象而言，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

多态环境下对成员方法的调用

class Animal{
    void show(){
        System.out.println("Animal");
    }
}
class Cat extends Animal{
    void show(){
        System.out.println("Cat");
    }
}

--------------------
    Animal x = new Cat()
    x.show()  //调用的是子类中的方法
    

简而言之：编译看左边，运行看右边。

多态环境下对静态成员方法的调用

class Aminal{
    static void show(){
        System.out.println("Animal");
    }
}
class Cat extends Animal{
    static void show(){
        System.out.println("Cat");
    }
}

--------------------
    Animal x = new Cat();
	x.show()  //调用的是动物类中的静态成员方法。

简而言之：编译和运行都看左边。

多态环境下对成员变量的调用

class Animal{
    int unm = 3;
}
class Cat extends Animal{
    int num = 4;
} 

----------------------
    Animal x = new Cat()
    x.num;   //调用的是动物类中的成员方法

简而言之：编译和运行都看左边。

因为变量不存在被子类覆写这一说法，只有方法存在覆写。

方法参数具有多态性

class Animal{
    void eat(){}
}
class Cat extends Animal{
    void eat(){}
}
class Dog extends Animal{
    void eat(){}
}
//方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象

method(Animal animal){
    animal.eat();
}

方法参数动态性的好处：提高代码的扩展性

向上转型

classAnimal{
    void eat(){}
}
class Cat extends Animal{
    void look(){
        System.out.println("看家");
    }
}

-----------------
    Animal x = new Cat()   //向上转型，Cat对象提升到Animal对象。
    x.eat();  //只能使用父类中的方法。
	x.look  //报错！不能使用子类中的方法。

向上转型的作用是提高程序的扩展性。

向下转型

classAnimal{
    void eat(){}
}
class Cat extends Animal{
    void look(){
        System.out.println("看家");
    }
}

-----------------
    Animal x = new Cat();   //向上转型，Cat对象提升到Animal对象。
	Cat m = (Cat)x;  //向下转型
	m.eat();
	m.look();  //子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。