多态

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

例如：

人：男人、女人；

动物：猫、狗、猪等；

 

1：多态基本体现；

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

      父类的引用也可以接受自己的本类对象；

2：多态的前提；

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

       通常还有一个前提：存在覆盖；

3：多态的好处；

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

4：多态的弊端；

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

5：多态的应用；

 6：多态成员的特点

非静态成员函数：

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

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

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

成员变量：

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

静态成员函数：

          编译和运行都参考左边；

 

/*
动物
猫，狗
*/
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 DuoTaiDemo
{
	public static void main(String[] ags)
	{
		Cat c=new Cat();
		function(c);
		Dog c1=new Dog();		
                  function(c1);
	}
	public static void function(Cat c)
		{
			c.eat();
		}
		public static void function(Dog d)
		{
			d.eat();
		}
}

好！！！程序实现了

注意：看下面代码

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 DuoTaiDemo
{
	public static void main(String[] ags)
	{
		Animal c=new Cat();//类型提升，向上转型
		function(c);
		function(new Dog());
		
	}
	public static void function(Animal c)
		{
			c.eat();
		}
}

这就是利用了多态的特性；

虽然感觉简便了，但只调用了共性功能，但特有功能没调用出来；有人就想再创建一个对象不就完啦，可这样对象就不是以前的对象；

既然上面的代码向上转型了；

那么我们就可以向下转型； 这是就强制将父类的引用，转成子类类型；

代码体现：

Animal a=new Cat();
a.eat();
Cat c=(Cat)a;
c.catchmouse();

 

注意：！！！！

Animal a=new Animal();
Cat c=(Cat)a;

这种将父类对象转成子类类型错误的，这不叫向下转型；
我们能转换的是父类引用指向了子类的对象时，该引用可以被提升，也可以被强制转换；

多态自始至终都是子类对象在做着变化；

这时在往深点想，既然能强制转换，何不在function()功能上做点手脚；

 

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 DuoTaiDemo
{
	public static void main(String[] ags)
	{
		Animal c=new Cat();
		function(c);
		function(new Dog());
		
	}
	public static void function(Animal c)
		{
			c.eat();
			if(c instanceof Cat)//instance 用于判断<span style="color:#333333;TEXT-ALIGN: left; WIDOWS: 1; TEXT-TRANSFORM: none; BACKGROUND-COLOR: rgb(255,255,255); TEXT-INDENT: 0px; DISPLAY: inline !important; FONT: 14px/26px Arial; WHITE-SPACE: normal; FLOAT: none; LETTER-SPACING: normal; WORD-SPACING: 0px; -webkit-text-stroke-width: 0px">是否是这个特定类或者是它的子类的一个实例</span>
		{
				Cat a=(Cat)c;
				a.catchmouse();
			}
			else if(c instanceof Dog)
			{
				Dog a=(Dog)c;
				a.kanjia();
			}
		}
}

 

 

多态成员特点：

1：

class Fu
{
	void method1()
	{
		System.out.println("fu method-1");
	}
	void method2()
	{
		System.out.println("fu method-2");
	}
}
class Zi extends Fu
{
	void method1()
	{
		System.out.println("fu method-3");
	}void method3()
	{
		System.out.println("fu method-4");
	}
}
class DuoTaiDemo4
{
	public static void main(String[] args)
	{
		Fu z=new Zi();
		z.method1();
		z.method2();
		z.method3();
	}
}

多态中成员函数编译看左边，运行看右边！！！

 

2：

class Fu
{
	int num=4;
	void method1()
	{
		System.out.println("fu method-1");
	}
	void method2()
	{
		System.out.println("fu method-2");
	}
}
class Zi extends Fu
{
	int num=5;
	void method1()
	{
		System.out.println("fu method-3");
	}void method3()
	{
		System.out.println("fu method-4");
	}
}
class DuoTaiDemo4
{
	public static void main(String[] args)
	{
		Fu z=new Zi();
		System.out.println(z.num);
	}
}

多态中成员变量编译，运行都看左边；

 

 

3：

class Fu
{
	 void method1()
	{
		System.out.println("fu method-1");
	}
	static void method2()//!!!!!!
	{
		System.out.println("fu method-2");
	}
}
class Zi extends Fu
{
	 static void method2()//!!!!!
	{
		System.out.println("zi method-3");
	}void method3()
	{
		System.out.println("zi method-4");
	}
}
class DuoTaiDemo4
{
	public static void main(String[] args)
	{
		Fu z=new Zi();
		z.method2();
	}
}

静态函数

并未覆盖；

但代码改了后

.........
class DuoTaiDemo4
{
	public static void main(String[] args)
	{
		Zi z=new Zi();
		z.method2();
	}
}
.....

多态中静态成员函数编译，运行都看左边；

 

 

 

多态应用：

例子：

需求：

电脑运行实例，电脑运行基于主板；

主板上PCI可插网卡；

interface PCI
{
	public void run();
	public void close();
}
class MainBord
{
	public void run()
	{
		System.out.println("mainbord run");
	}
	public void use(PCI p)
	{
		if(p!=null)
		{
			p.run();
			p.close();
		}
	}
}
class NetCard implements PCI
{
	public void run()
	{
		System.out.println("net run");
	}
	public void close()
	{
		System.out.println("net close");
	}
}

class DuoTaiDemo5
{
	public static void main(String[] args)
	{
		MainBord mb=new MainBord();
		mb.run();
		mb.use(new NetCard());

	}
}