Java_多态

多态一（基础）：

//Demo类：
package com.hb2.多态;
//多态前提：方法被重写
public class Demo {
    public static void main(String[] args) {
        //引用父类指向子类对象
        Animal a = new Cat();

        //成员：编译看左边，运行也要看左边
        //显示的是父类的成员变量
        System.out.println(a.age);
//输出:40
        //System.out.println(a.weight);错误

        //！重写的！成员方法：编译看左边，执行看右边
        a.eat();
//输出：猫吃鱼
        //a.playGame();错误
    }
}


//Animal类：
package com.hb2.多态;

public class Animal {
    public int age= 40;

    public void eat(){
        System.out.println("动物要吃东西");
    }
}


//Cat类
package com.hb2.多态;

public class Cat extends Animal{
    public int age= 3;
    public int weight= 10;

    //输入eat自动重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫猫捉迷藏");
    }
}

多态二（应用1）：

        多态好处：提高了程序的扩展性
                          具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，
                          使用具体的子类型参与操作。

        多态弊端：不能使用子类的的特有功能

//Deom类
package com.hb2.多态2;
/*
    多态好处：提高了程序的扩展性
    具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，
    使用具体的子类型参与操作。

    多态弊端：不能使用子类的的特有功能
 */
public class Demo {
    public static void main(String[] args) {
        AnimalOperater ao = new AnimalOperater();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);

    }
}


//Animal类
package com.hb2.多态2;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
    public void kanmen(){
        System.out.println("动物看门");
    }
}


//AnimalOperate类
package com.hb2.多态2;

public class AnimalOperater {
    /*

    public void useAnimal(Cat c){//Cat C = new Cat()
        c.eat();
    }
    public void useAnimal(Dog c){//Dog d = new Dog()
        c.eat();
    }
    若要再添加一个动物，则要再写一个新的，很麻烦
    */


    //运用多态的方法
    public void useAnimal(Animal a){
        //Animal a = new Cat，使用父类声明，指向子类
        //用父类型作为参数，子类型作为操作
        //编译看左边，运行看右边
        //执行cat类的eat
        a.eat();
//        a.kanmen();
    }
}


//Cat类
package com.hb2.多态2;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


//Dog类
package com.hb2.多态2;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

//    public void kanmen(){
//        System.out.println("狗看门");
//    }
}

多态三（向上、下转型）： 

        向上转型：
                    从子到父
                    父类引用指向子类对象
        向下转型：
                    从父到子
                    父类引用转为子类对象

//Demo类
package com.hb2.多态3;
/*
    向上转型：
            从子到父
            父类引用指向子类对象
    向下转型：
            从父到子
            父类引用转为子类对象
 */
public class Demo {
    public static void main(String[] args) {
        Animal a = new Cat();//向上转型
        a.eat();

        /*
        Cat c = new Cat();
        c.eat();
        c.playGame();
         */

        Cat c = (Cat) a; //向下转型，父类引用转为子类对象，使用子类特有方法, 节省空间
        c.eat();
        c.playGame();

    }

}


//Animal类
package com.hb2.多态3;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");

    }
}


//Cat类
package com.hb2.多态3;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }

}

多态优缺点：

 

判断强转（向下转型）正误（快速强转）：