多态的使用和概述以及弊端和好处

多态的概述

多态的概述

多态：同一个对象(事物)，在不同时刻体现出来的不同状态。
举例：
    猫是猫，猫是动物。
    水(液体，固体，气态)。

多态的前提：
    A:要有继承关系。
    B:要有方法重写。
        其实没有也是可以的，但是如果没有这个就没有意义。
            动物 d = new 猫();
            d.show();
            动物 d = new 狗();
            d.show();
    C:要有父类引用指向子类对象。

代码体现

        父 f =  new 子()；
    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();
}

}
多态的代码理解

多态的问题理解：
class 孔子爹 {
    public int age = 40;

    public void teach() {
        System.out.println("讲解JavaSE");
    }
}

class 孔子 extends 孔子爹 {
    public int age = 20;

    public void teach() {
        System.out.println("讲解论语");
    }

    public void playGame() {
        System.out.println("英雄联盟");
    }
}

//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
//向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语
//k爹.playGame(); //这是儿子才能做的


//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
//向下转型
孔子 k = (孔子) k爹; 
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟

多态的好处

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

多态的弊端

 不能使用子类的特有功能。   因为调用method方法的时候首先回去找父类中有没有这个方法   结果父类中没有这个方法  所以就会报错

弊端的解决办法

不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
    行。
怎么用呢?
    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();这个是可以调用show和method方法的 但是又要为新的对象Zi开辟内存空间  这样的做法显然是不合理的  

    //你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
    //如果可以，但是如下
    Zi z = (Zi)f;
    z.show();
    z.method();
}

}

多态继承中的内存图解

多态中对象变化内存图解