多态

多态：同一个对象(事物)，在不同时刻体现出来的不同状态。

举例：    猫是猫，猫是动物。    水(液体，固体，气态)。

多态的定义：

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

实现多态的技术称为：

动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态的好处：

1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

多态的前提：

    A:要有继承关系。    B:要有方法重写。        其实没有也是可以的，但是如果没有这个就没有意义。            动物 d = new 猫();            d.show();            动物 d = new 狗();            d.show();    C:要有父类引用指向子类对象。        父 f =  new 子();用代码体现一下多态。多态中的成员访问特点：    A:成员变量        编译看左边，运行看左边。    B:构造方法        创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。    C:成员方法        编译看左边，运行看右边。    D:静态方法        编译看左边，运行看左边。        (静态和类相关，算不上重写，所以，访问还是左边的)    由于成员方法存在方法重写，所以它运行看右边。

class Fu {    public int num = 100;    public void show() {        System.out.println("show Fu");    }    public static void function() {        System.out.println("function Fu");    }}class Zi extends Fu {    public int num = 1000;    public int num2 = 200;    public void show() {        System.out.println("show Zi");    }    public void method() {        System.out.println("method zi");    }    public static void function() {        System.out.println("function Zi");    }}class DuoTaiDemo {    public static void main(String[] args) {        //要有父类引用指向子类对象。        //父 f =  new 子();        Fu f = new Zi();        System.out.println(f.num);        //找不到符号        //System.out.println(f.num2);        f.show();        //找不到符号        //f.method();        f.function();    }}

结果: constructor Fu, constructor Zi, 100, show Zi, function Fu

多态的好处：

    A:提高了代码的维护性(继承保证)    B:提高了代码的扩展性(由多态保证)

多态的弊端：

不能使用子类的特有功能。

我就想使用子类的特有功能?行不行?
行。

怎么用呢?
A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题：

    向上转型：        Fu f = new Zi();    向下转型：        Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。

class Fu {    public void show() {        System.out.println("show fu");    }}class Zi extends Fu {    public void show() {        System.out.println("show zi");    }    public void method() {        System.out.println("method zi");    }}class DuoTaiDemo4 {    public static void main(String[] args) {        //测试        Fu f = new Zi();        f.show();        //f.method();        //创建子类对象        //Zi z = new Zi();        //z.show();        //z.method();        //你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?        //如果可以，但是如下        Zi z = (Zi)f;        z.show();        z.method();    }}

ClassCastException:类型转换异常, 一般在多态的向下转型中容易出现

class Animal {    public void eat(){}}class Dog extends Animal {    public void eat() {}    public void lookDoor() {    }}class Cat extends Animal {    public void eat() {    }    public void playGame() {    }}class DuoTaiDemo5 {    public static void main(String[] args) {        //内存中的是狗        Animal a = new Dog();        Dog d = (Dog)a;        //内存中是猫        a = new Cat();        Cat c = (Cat)a;        //内存中是猫        Dog dd = (Dog)a; //ClassCastException    }}

继承的时候：

    子类中有和父类中一样的方法，叫重写。    子类中没有父亲中出现过的方法，方法就被继承过来了。

看程序写结果:先判断有没有问题，如果没有，写出结果

class A {    public void show() {        show2();    }    public void show2() {        System.out.println("我");    }}class B extends A {    /*    public void show() {        show2();    }    */    public void show2() {        System.out.println("爱");    }}class C extends B {    public void show() {        super.show();    }    public void show2() {        System.out.println("你");    }}public class DuoTaiTest4 {    public static void main(String[] args) {        A a = new B();        a.show();        B b = new C();        b.show();    }}//结果: 爱你