多态

今天复习多态的内容，从一下四点开始复习：
1：多态的体现：
多态：什么是多态？就是在同一个方法中个，由于参数类型不同而导致执行效果各异的现象就是多态；
比如要实现一个动物的叫声，由于每种动物的叫声是不同的，因此可以在方法中接受一个动物类型的参数，当传如猫类对象时就发出猫类叫声，传入狗类对象时就发出狗类叫声。
代码：

abstract class Animal
 /*定义动物的叫声，因为每种动物的叫声是不同的，所以用一个抽象类来定义动物的叫  声；当然也可以定义接口类型的类来定义动物的叫声方法。
 */
{
    abstract void shout();// 
}
//定义一个具体的动物类继承Animal
class Cat extends Animal
{
    public void shout()
    {
        System.out.println("喵喵……");
    }
}
class Dog extends Animal
{
    public void shout()
    {
        System.out.println("汪汪……");
    }
}
//定义测试类
class TestDemo
{
    public static void main(String[] a)
    {
        Cat c=new Cat();//创建Cat类的实例调用shout方法；
        c.shout();
        Dog d=new Dog();
        d.shout();
        Animal c1=new Cat();//将Cat对象当做Animal类型使用
        animalShout(c1);
        Animal d1=new Dog();//将Dog对象当做Animal类型使用
        animalShout(d1);
        animalShout(new Cat()); //Animal a=new Cat();父类的引用接受子类对象
    }
    //定义一个静态的animalShout方法，接受Anilmail类型的参数
    public static void animalShout(Animal a)//多态：父类引用指向子类对象
    {
        a.shout();
    }
}

2：对象的类型转换：
把子类对象当做父类使用时不需要任何显式的声明，但是当父类引用指向子类对象，需要调用子类中特有方法时，需要把父类引用进行类型转换，转换成子类引用；

//定义Animal接口
interface Animal
{
    void shout();//定义抽象方法shout()
}
//定义Cat类实现Animal接口
clsaa Cat implements Animal
{
    void shout()//实现抽象方法shout()
    {
        System.out.println("喵喵了……");
    }
    void sleep()
    {
        System.out.println("猫睡觉！");
    }
}
//定义测试类
class TestDemo1
{
    public static void main(String[] a)
    {
        Animal a=new Cat();//类型提升，向上转型，把Cat类型提升为Animal类型

    }
    public static void animalShout(Animal a)
    {
        Cat an=(Cat)a;//强制将父类的引用，转换成子类类型，这是向下转型
        an.shout();
        an.sleep();//因为此处调用了父类中没有定义的方法，没有向下转型的话，父类引用找不到方法会报错
        //多态自始至终都是子类对象在做着变化，
    }

}

3:多态的应用：
需求：
电脑运行实例，
电脑运行基于主板。

interface PCI
{
    public void open();
    public void close();
}
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run ");
    }
    public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
    {
        if(p!=null)
        {
            p.open();
            p.close();          
        }
    }
}
class NetCard implements PCI
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close");
        method();
    }

}
class SoundCard implements PCI
{
    public void open()
    {
        System.out.println("SoundCard open");
    }
    public void close()
    {
        System.out.println("SoundCard close");
    }
}
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
    }
    public void useNetCard(NetCard c)
    {
        c.open();
        c.close();
    }
}

class NetCard
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close");
    }
}
class DuoTaiDemo5 
{
    public static void main(String[] args) 
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());     
    }
}

4：多态的好处与弊端：
多态的好处：多态的出现提高了程序的扩展性；
多态的弊端：提高了扩展性，但只能使用父类的引用访问父类中的成员；
使用多态的前提：必须是类与类之间有关系，要么继承，要么实现，通常还有一个前提：存在覆盖；