多态的概念，特点与使用

多态：可以理解为事物存在的多种体现形态

如：人：男人，女人

　　动物：猫，狗，鸟

猫这个动物应该是猫类型的：猫 cat = new 猫();

同时猫也是动物的一种：动物 y = new 猫();  动物是猫和狗具体事物抽取出来的父类型，父类型指向了子类对象　

 

1、多态的体现

　　父类的引用指向了自己的子类对象

　　父类的引用也可以接收自己的子类对象

2、多态的前提

　　必须是类与类之间有关系，要么继承，要么实现

　　还有一个前提：存在覆盖　　

3、多态的好处

　　多态的出现大大的提高了程序的扩展性

4、多态的弊端

　　虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员

5、多态的应用

6、多态使用的注意事项　　

 

看一个关于多态的例子：

abstract class Teacher
{
    public abstract void teach();
    public void sleep()
    {
        System.out.println("睡觉");
    }
}
class MathTeacher extends Teacher
{
    public void teach()
    {
        System.out.println("教数学");
    }
}
class ChineseTeacher extends Teacher
{
    public void teach()
    {
        System.out.println("教语文");
    }
    public void sleep()
    {
        System.out.println("睡觉在沙发上");
    }
}
//将代码进一步优化，定义一个工具类，这样就不需要实例化每一个老师对象，直接调用工具类，然后把各种类型的Teacher传进去既可
class TeachTest
{
    public static void teach(Teacher t)//Teacher t类型是Teacher由于多态可以直接传MathTeacher等
    {
        t.teach();
        t.sleep();
    }
}
class Test
{
    public static void main(String[] args)
    {
        /*
        实例化一个新的数学老师
        Teacher t = new MathTeacher(); 类型提升，向上转型
        t.sleep();
        如果想要调用猫的特有方法该怎么做？
        强制将父类引用转成子类类型，向下转型
        MathTeacher mt = (MathTeacher)t;
        mt.teach();  就可以调用数学老师里面的教学方法
        */
        /*
        如果要调用类的方法，先实例化一个类，然后分别调用
        MathTeacher mt = new MathTeacher();
        mt.teach();
        mt.sleep();
        ChineseTeacher ct = new ChineseTeacher();
        ct.teach();
        ct.sleep();
        发现这样比较麻烦，向上抽取，定义一个新的工具类TeachTest，将方法封装进去
        */
        TeachTest tt = new TeachTest();
        tt.teach(new MathTeacher());
        tt.teach(new ChineseTeacher());
    }
}

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败

在运行时期：参阅对象所属的类中是否有调用的方法

简单总结：成员函数在多态调用时，编译看左边，运行看右边

 

（面试）在多态中成员变量，静态成员函数的特点：

无论编译或运行，都参考左边（引用型变量所属的类）

如：

Fu f = new Zi();
System.out.println(f.num);//打印的是父类里面的变量num
Zi z = new Zi();
System.out.println(z.num);//打印的是子类里面的变量num
//静态的方法也是一样。

 

一个集合了接口，多态的例子

/*
类 主板，主板有运行方法run()
一段时间后想要上网 加入网卡类
想要听音乐 加入 声卡类

但是这样一个一个的加入使得代码的扩展性很差，每次都要重新修改很多代码

于是引入一个通用的接口PCI类
所有设备都有打开和关闭功能
让网卡和声卡分别取实现PCI接口，重写成自己的打开和关闭功能

给主板加上一个实现pcirun的方法，传递参数的值为PCI类型的
可以利用多态PCI p = new NetCard();

所以在下面主函数中运行时 创建新的主板对象以后
        mb.pcirun(new NetCard());
        mb.pcirun(new SoundCard());
就可以分别使用网卡和声卡了，如果以后还要再加入比如显卡
就只需要建立一个显卡类去实现PCI接口，然后直接用主板中的pcirun方法就可以了。

*/
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
    }
    public void pcirun(PCI p)
    {
        p.open();
        p.close();
    }
}
interface PCI
{
    public abstract void open();
    public abstract void close();
}
class NetCard implements PCI
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close");
    }
}
class SoundCard implements PCI
{
    public void open()
    {
        System.out.println("SoundCard open");
    }
    public void close()
    {
        System.out.println("SoundCard close");
    }
}
class Test
{
    public static void main(String[] args)
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.pcirun(new NetCard());
        mb.pcirun(new SoundCard());
    }
}
/*
这样做的好处：
大大的降低了主板和各种独立设备直接的耦合性
中间用一个PCI接口来连接起来
程序日后非常方便扩展
*/