java基础：多态

多 态（面向对象特征之一）：函数本身就具备多态性，某一种事物有不同的具体的体现。

 

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = newCat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

    1：必须要有关系，比如继承、或者实现。

    2：通常会有覆盖操作。

 

多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

class 爷
{
    void 讲课()
    {
        System.out.println("企业管理");
    }
    void 钓鱼()
    {
        System.out.println("钓鱼");
    }
}
class 我 extends 爷{
    void 讲课()
    {
        System.out.println("JAVA");
    }
    void 看电影()
    {
        System.out.println("看电影");
    }
}
class {
    public static voidmain(String[] args) 
    {
        爷 x = new 我(); //我对象被提升为了爷类型。
//      x.讲课();
//      x.看电影(); //错误.
        我 y = (我)x; //将爷类型强制转换成我类型。
        y.看电影();//在多态中，自始自终都是子类对象在做着类型的变化。
    }
}

多态的扩展例子：

*/

interface  PCI						//接口 
{
	public void open();
	public void close();
}

class Mainboard						//电脑主板运行
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void useNetcard(PCI p)
	{
		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");
	}

}

class  Demo3
{
	public static void main(String[] args) 
	{
		Mainboard mb = new Mainboard();	//引用Mainboard创建Mainboard
		mb.run();
		mb.useNetcard(new Netcard());<span style="white-space:pre">	</span>//后期出现的网卡，显卡等只要实现了PCI接口，都可以使用，提高程序扩展
	}
}

如果想用子类对象的特有方法，如何判断对象是哪个具体的子类类型呢？

可以通过一个关键字instanceof; //判断对象是否实现了指定的接口或继承了指定的类

 

格式：<对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。

Student instanceof Person =true;//student继承了person类

 

多态在子父类中的成员上的体现的特点：

1，成员变量：

    在多态中，子父类成员变量同名。

    在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

    再说的更容易记忆一些：成员变量 --- 编译运行都看 = 左边。

2，成员函数。

    编译时期：参考引用型变量所属的类中是否有调用的方法。

    运行事情：参考的是对象所属的类中是否有调用的方法。

    为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

    简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

    更简单：成员函数 --- 编译看 = 左边，运行看= 右边。

3，静态函数。

    编译时期：参考的是引用型变量所属的类中是否有调用的成员。

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

    调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。

    简单说：静态函数 --- 编译运行都看 = 左边。