黑马程序员----------面向对象三大特性之多态

                         ----------------------android培训、java培训、期待与您交流！ ----------------------

           面向对象的继承其实也是为了多态奠定了基础条件，多态其实也不难理解，面向对象既然是由现实生活，那么我们可以想想平时的水，水其实有几种形式，当水的温度低于0度时，它就成了冰，也就是固态，当它蒸发了的时候，就成了水蒸气，算是气态了，那么像这样一个事物有多样的形态，在java中也就称之为多态。
  

 (1)某一类事物的多种存在形态。

        **方法重载(静态多态)

        **方法重写(动态多态,对象多态)

    (2)对象多态的前提

        A：类与类(或接口)要有继承(或实现)关系。

        B：一定要有方法的重写。

        C：一定要有父类或者接口的引用指向子类的对象。

    (3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。

        A：Animal Cat Dog

            **method(Animal a){a.eat();}

        B：同学们吃饭

        C：士兵打仗(抬枪，瞄准，射击)。

    (4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)

        Fu f = new Zi();

        A：成员变量：编译和运行都看Fu。

        B：非静态方法：编译看Fu，运行看Zi。

        C：静态方法：编译和运行都看Fu。

       

        举例：    动物的例子：
            向上转型
            Animal a = new Cat();
            a.eat();
            //a.catchMouse();

            向下转型
            Cat c = (Cat)a;
            c.eat();
            c.catchMouse();

            //向上转型
            Animal a = new Dog();
            //向下转型 转换异常
            //Cat c = (Cat)a;
            Dog d = (Dog)a;

            孔爹的例子：
            孔爹:教课(Java)
            孔子:教课(论语),看小说(),打游戏()。

            孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了
            k.教课(论语)。
            //k.看小说();

            孔子 kz = (孔子)k;//把衣服脱了
            kz.教课(论语);
            kz.看小说();
            kz.打游戏();

下面写两个多态的具体代码。

//final class Fu {//错误: 无法从最终Fu进行继承class Fu {//public final void show(){//错误: Zi中的show()无法覆盖Fu中的show()   被覆盖的方法为finalpublic final void show(){System.out.println("一夫一妻制");}}class Zi extends Fu{final int num;/*扩展： 如果final修饰的变量没有默认值，可以在构造方法中给num 赋值一次*/public Zi(){num = 20;}public void show(){System.out.println("一夫多妻制");}}class FinalDemo {public static void main(String[] args){Zi z = new Zi();z.show();//z.num = 30;//错误: 无法为最终变量num分配值//System.out.println(z.num);}}

   
-多态的成员特点(成员变量)
-多态的成员特点(成员变量图解)
    | 编译看左边的父类
    | 执行看左边的父类
    | 只有创建对象， 才能调用构造方法
    /*
    多态的成员
        成员变量
            编译看左边的父类，执行看左边的父类

class Fu {int num = 10;}class Zi extends Fu {int num = 20;int num2 = 30;}class DuoTaiDemo2 {public static void main(String[] args){//Zi z = new Zi();//System.out.println(z.num);//Fu f = new Fu();//System.out.println(f.num);//多态的方式Fu f2 = new Zi();System.out.println(f2.num);// 错误: 找不到符号  位置: 类型为Fu的变量 f2//System.out.println(f2.num2);}}

多态的成员特点(成员方法)
    | 编译看左边的父类
    | 执行看右边的子类
    /*
    多态的成员
        成员方法：
            编译看左边的父类
            执行看右边的子类
*/

class Fu {        public void show(){        System.out.println("Fu show");    }}class Zi extends Fu {        public void show(){        System.out.println("Zi show");    }}class DuoTaiDemo3 {    public static void main(String[] args)    {        //Fu f = new Fu();        //f.show();        //Zi z = new Zi();        //z.show();        //多态的方式        Fu f2 = new Zi();        f2.show();    }}

多态的成员特点(静态方法)
    | 编译看左边的父类
    | 执行看左边的父类
    | 静态是随着类的加载而存在，对象还没有创建，所以调用的时候，使用的Fu中的静态方法
    /*
    多态的特点
        静态方法
        编辑看左边的父类
        执行看左边的父类

    关于多态的特点的总结：

        成员方法执行看右边，其他都看左边.

class Fu{public static void show(){System.out.println("Fu show");}}class Zi extends Fu {public static void show(){System.out.println("Zi show");}}class DuoTaiDemo4 {public static void main(String[] args){//Fu f = new Fu();//f.show();//Fu.show();//Zi z = new Zi();//z.show();//Zi.show();//多态的方式Fu f2 = new Zi();f2.show();//Fu.show();/*在调用静态show方法的时候，对象可能还没有创建出来，所以，当前的静态方法可以通过类名.方法名来调用这个show方法  Fu.show(); 当前的f2.show();中的f2 它Fu类型,它可以通过Fu.show()来调用，效果是等价的*/}}

多态的好处
    | 提高了程序的扩展性
    /*
    好处和作用：
        多态的存在提高了程序的扩展性和后期可维护性
        
        后期可维护性(父类Person 来完成的)

    多态的弊端：
        父类不能访问子类特有方法

class Person {public void eat(){System.out.println("吃饭");}public void sleep(){System.out.println("睡觉");}}class Girl extends Person {public void eat(){System.out.println("女生 吃饭少");}public void sleep(){System.out.println("女生 睡觉早");}public void goShopping(){System.out.println("带着男朋友逛商场");}}class Boy extends Person{public void eat(){System.out.println("男生 吃饭多");}public void sleep(){System.out.println("男生 睡觉晚");}}class Other extends Person{public void eat(){System.out.println("other 吃饭");}public void sleep(){System.out.println("other 睡觉");}}class DuoTaiDemo5 {public static void main(String[] args){/*Girl g = new Girl();g.eat();g.sleep();Girl g2 = new Girl();g2.eat();g2.sleep();*/Girl g3 = new Girl();girlMethod(g3);Boy b = new Boy();boyMethod(b);Other o = new Other();otherMethod(o);//------------------------//多态的方式Person g4 = new Girl();personMethod(g4);Person b2 = new Boy();personMethod(b2);Person o2 = new Other();personMethod(o2);//------------------------//多态的弊端Girl g5 = new Girl();g5.goShopping();Person g6 = new Girl();g6.goShopping();}//多态方式的方法public static void personMethod( Person p ){p.eat();p.sleep();}//其他人方法public static void otherMethod( Other o ){o.eat();o.sleep();}//男生方法public static void boyMethod( Boy b ){b.eat();b.sleep();}//女生方法public static void girlMethod( Girl g ){g.eat();g.sleep();}}

多态的弊端
    | 父类不能访问子类特有方法

多态的案例(向上转型、向下转型)
    | 向上转型: 提高了程序的扩展性  
        Person g = new Girl();
    | 向下转型：为了使用子类的特有方法
        Girl girl = (Girl)g;
    /*
    多态的案例
        向上转型: 提高了程序的扩展性
        
        Person p = new UltraMan();
        子类 转型 父类使用
        小   -->    大        隐式转换  自动类型提升
        
        //--------------------------------------------------

        向下转型: 为了使用子类的特有方法

        UltraMan ultra = (UltraMan)p;
        父类 强转 子类使用
        大   --->   小        强制转换

    案例： 奥特曼打小怪兽

    人： name , 吃饭eat()
    奥特曼: name , 吃饭eat() ,打架fight()
*/

class Person {String name = "成龙";public void eat(){System.out.println("成龙 吃饭");}}class UltraMan extends Person{//特有方法public void fight(){System.out.println("奥特曼打小怪兽");}}class DuoTaiDemo6 {public static void main(String[] args){Person p = new UltraMan();//向上转型System.out.println(p.name);p.eat();UltraMan ultra = (UltraMan)p;//向下转型ultra.fight();}}

                       ----------------------android培训、java培训、期待与您交流！ ----------------------