多态

多态      函数体现

如方法的重载

多态      对象体现

how

class 猫 extends 动物{public void 吃(){}}
动物 D=new 猫();
D.吃();

扩展：据此增强扩展性
 1 abstract class Animal
{
    abstract void eat();
}

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

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

class  DuoTai
{
    public static void main(String[] args) 
    {
        /*
        Cat c=new Cat();
        c.eat();
        Dog d=new Dog();
        d.eat();
        */
        //改进版，以后要是有pig也是不怕的
        duoTaiEat(new Cat());
        duoTaiEat(new Dog());
    }
    public static void duoTaiEat(Animal a){
        a.eat();
    }
}

 

存在问题：增加一个Pig，岂不是要多写一句duoTaiEat(new Pig());???      反射!!!

上转型与下转型

上转型：Animal a=new Cat();//a可以调用父类中声明过的方法，不能调用Cat的特有方法

下转型：Cat c=(Cat)a;//原本a为上转型对象了，现在强制下转型，c可以掉用Cat的特有方法

/**
*定义抽象类Animal，具有抽象方法eat()
*Cat和Dog继承Animal且均具有各自特有的方法
*/
abstract class Animal
{
    abstract void eat();
}

class Cat extends Animal
{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
class Dog extends Animal
{
    public void eat(){
        System.out.println("狗啃骨头");
    }
    public void kanJia(){
        System.out.println("狗看家");
    }
}

class ZhuanXing 
{
    public static void function(Animal a){
        //动物都具有eat(),当传递进来Cat的时候，相当于Animal a=new Cat();上转型
        a.eat();
        //instanceof判断一个对象是否是某一个类的实例
        if(a instanceof Cat){
            Cat c=(Cat)a;//强制下转型
            c.catchMouse();
        }
        else if(a instanceof Dog){
            Dog d=(Dog)a;
            d.kanJia();
        }
        
    }
    public static void main(String[] args) 
    {
        function(new Cat());
        function(new Dog());

    }
}

 注意：

　　1.上面这种做法明显有弊端，当出现的子类越来越多的时候，必须要不停的去判断，这里只是顺便展示一下instanceof的用法

　　2.当然，在子类有限且很少的情况下可以这么去做，比如说人分为男人和女人的时候

多态定义工具类应用

多态的注意事项