多态

package org.westos_02_多态;
/**
 * 多态:一个事物在不同时刻体现出来的不同状态:
 * 
 *      水:固态,汽态 ,液态
 *      Animal a = new Cat() ;
 *      
 *对于多态的三个前提条件
 *
 *      1)条件1:必须有继承关系(如果没有继承关系,谈不上多态!)
 *      2)条件2:必须有方法重写
 *              子类出现了父类一样的 方法声明
 *      3)有父类引用指向子类对象:向上转型
 *          Fu f = new Zi() ;
 *      多态的三个条缺一不可!
 *      
 *
 *
 *多态的成员访问特点:
 *      成员变量:
 *              编译看左边,运行看左边
 *      成员方法(非静态的成员方法):
 *              编译看左,运行看右;由于存在方法重写,所以就运行最终的就是子类的成员方法
 *      静态成员方法:(静态方法算不上方法重写,静态直接跟类有关系!)
 *              编译看左,运行看左
 *      构造方法:还是对象进行初始化,由于是一种继承关系,还是分层初始化!
 *      
 *      
 *          
 * */
//父类
class Fu{
    public int num = 10 ;

    //父类的成员方法
    public void show(){
        System.out.println("show Fu...");
    }

    //静态方法
    public static void function(){
        System.out.println("function Fu....");
    }
}
//子类
class Zi extends Fu{
    int num = 20 ;

    public void show(){
        System.out.println("show Zi...");
    }

    public static void function(){
        System.out.println("function Zi....");
    }
}

//测试类
public class DuoTaiDemo {
    public static void main(String[] args) {
        //创建父类的对象:多态的形式
//      有父类引用指向子类对象:向上转型
        Fu f = new Zi() ;
        //访问成变量
        System.out.println(f.num);

        //调用成员方法:show()
        f.show() ;

        //静态方法
        f.function() ;
    }
}

多态的好处(特点):

• 1)提高代码的维护性(由继承保证)

• 2)提高代码的扩展性(由多态保证)

• java的开发原则:低耦合,高内聚

  多态的弊端:

• 不能访问子类的特有功能

package org.westos_02_多态;
/**
 * 多态的弊端是不能访问子类的特有功能:如何解决?
 *      异常:OOM异常:严重:OutOfMemory:内存溢出!
 *  
 *      解决方案:
 *              1)创建子类的具体对象,来访问自己的特有功能;虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆内存开辟空间,
 * 耗费内存,浪费空间!
 *              2)既然多态的第三个前提条件:父类引用指向子类对象,那么可不可以将子类的引用指向父类对象呢?
 *                      可以的:向下转型:将父类的引用强制转换为子类的引用:前提必须有父类的引用存在;
 *                      向下转型必须依赖于向上转型!
 *      
 * */
class Animal3{
    public void show(){
        System.out.println("show Animal2...");
    }
}

//子类
class Cat3 extends Animal3{
    public void show(){
        System.out.println("show Cat2....");
    }

    //特有功能
    public void playGame(){
        System.out.println("猫玩毛线...");
    }
}
public class DuoTaiDemo4 {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal3 a = new Cat3() ; //向上转型

        a.show() ;
        //不能访问子类特有功能
//      a.playGame();

        //创建子类具体对象
    /*  Cat3 c = new Cat3() ;
        c.playGame() ;*/

        //父类的引用强制转换为子类的引用:向下转型
        Cat3 c = (Cat3) a ;
        c.playGame() ;
    }
}

package org.westos_02_多态;
/**
 * 一般情况下:向下转型使用不当会造成一个异常:
 *      Throwable:
 *              error:严重问题
 *              Exception:
 *                      编译时期异常:
 *                      运行时期异常:RuntimeException
 *              
 *      运行时期异常:
 *      ClassCastException:类转换异常:org.westos_02_多态.Cat4 cannot be cast to org.westos_02_多态.Dog4
 * */
class Animal4{
    public void eat(){}
}

class Cat4 extends Animal4{
    public void eat(){}

    public void playGame(){}
}

class Dog4 extends Animal4{
    public void eat(){}

    public void lookDoor(){}
}

//测试类:
public class DuoTaiDemo5 {
    public static void main(String[] args) {
        //内存是狗
        Animal4 a = new Dog4() ;
        //向下转型:还原成狗
        Dog4 d = (Dog4)a ;

        //内存是猫
        a = new Cat4() ;
        //还原成猫
        Cat4 c = (Cat4) a ;

        //编译通过了
        Dog4 dd = (Dog4)a ; //不能将内存猫转换为狗
    }
}

多态向下转换内存图解：

我觉得比较简单的理解就是：可以从父到子转换，但是同级之间无法强行转换。
package org.westos_02_多态;
//看程序写结果:先判断有没有问题，如果没有，写出结果
/**
 * 有继承关系:
 *      分层初始化:父类先初始化,然后子类初始化
 * 多态的访问特点:
 *      成员方法:(非静态的):编译看左,运行看右(方法重写)
 * */
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 DuoTaiTest {
    public static void main(String[] args) {
        A a = new B();
        a.show();
        B b = new C();
        b.show();
        //  2)爱你 
    }
}