面向对象—多态（1）

多态的引出

//描述dog
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("bone");
    }
    public void watchHome()
    {
        System.out.println("watchHome");
    }
}

//描述cat
class Cat extends Animal
{
    public void eat()
    {
        System.out.println("fish");
    }
    public void watchHome()
    {
        System.out.println("catchMouse");
    }

}
class DuoTaiDemo
{
    public static void main(String[] args)
    {
        Dog d =new Dog();
        // d.eat();
        method(d);
        Cat c =new Cat();
        method(c);
    }
    //接收Dog，让dog做事
    public static void method(Dog d)
    {
        d.eat();
    }
    //接收Cat，让Cat做事
    public static void method(Cat c)
    {
        c.eat();
    }   
}

发现，每多一个动物，都需要为这个动物单独定义一个功能。
让这个动物的对象去做事。
这个程序扩展性很差。
如何提高扩展性呢？
发现既然是让这个动作去eat，无论是dog，还是cat,
eat是它们的共性，就将eat进行抽取，抽取到父类Animal中。
Dog 是Animal中的一种。
Dog d =new Dog();
Animal a=new Dog();
只要建立Animal的引用就可以接受所有的dog cat 对象进来，让它们去eat。

abstract class Animal
{
    public abstract void eat();  
}
//描述dog
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("bone");
    }
    public void watchHome()
    {
        System.out.println("watchHome");
    }
}

//描述cat
class Cat extends Animal
{
    public void eat()
    {
        System.out.println("fish");
    }
    public void watchHome()
    {
        System.out.println("catchMouse");
    }

}
class DuoTaiDemo
{
    public static void main(String[] args)
    {
        Dog d =new Dog();
        method(d);
        Cat c =new Cat();
        method(c);
    }
    public static void method(Animal a)
    {
            a.eat();
    }

}

多态

:

【体现】

父类的引用或者接口的引用指定了自己的子类对象。
Dog d=new Dog();Dog对象的类型是Dog类型。
Animal a= new Dog;Dog对象的类型右边是Dog类型，左边是Animal类型。

【好处】

提高了程序的扩展性。

【弊端】

通过父类引用操作子类对象时，只要使用父类中已有的方法，不能操作子类的方法。

【前提】

1，必须有关系，继承或实现
2，通常都有重写操作。

【子类的特有方法如何调用呢?】

Animal a =new Dog();Animal 是父类型，new Dog()是子对象。
但是父类型引用指向子类对象时，隐藏了子类型，弊端：不能使用子类型的特有方法。
若果要想要使用子类的特有方法，只有子类型可以用。
可以向下转型，强制转换。
Animal a new Dog();
a.eat();
Dog d= (Dog)a;//将a转型为Dog类型，向下转型。
d.watchHome();
向下转型什么时候用？当需要使用子类型的特有内容时。

注意：无论向上还是向下转型，最终是子类对象做着类型的变化。

【向下转系的注意事项】

 Animal a=new Dog();
 Cat c =(Cat)a ;向下转系因为不明确具体子类对象类型。所以容易引发ClassCastException异常。
 所以为了避免这个问题，需要在向下转型前，做类型的判断。
 判断类型用的是关键字 instanceof
 if(a instanceof Cat)//a指向的对象的类型是Cat类型。
 {
     Cat c=(Cat)a;
     c.catchMouse();
 }
 else if(a instanceof Dog)
 {
     Dog d=(Dog)a;
     a.watchHome();
 }

【转型总结】

 1，什么时候向上转型？
     提高程序的扩展性，不关心子类型（子类型被隐藏）。
     需要用子类的特有方法？不需要，即向上转型。
 2，什么时候向下转型？
    需要用子类的特有方法时。
    但是一定要使用 instanceof进行类型的判断，避免发生ClassCastException