黑马程序员——多态

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、定义

某一类事物的多种存在形态

二、动态绑定

是指“在执行期间”（而非编译期间）判断所引用对象的实际类型，根据实际类型调用相应的方法。

三、程序中体现

父类或者接口的引用指向或者接收自己的子类对象。

四、好处和作用

多态的存在提高了程序的扩展性和后期可维护性

/*

对象的多态性。

class 动物
{}

class 猫 extends 动物
{}

class 狗 extends 动物
{}



猫 x = new 猫();

动物 x = new 猫();//一个对象，两种形态。



猫这类事物即具备者猫的形态，又具备着动物的形态。
这就是对象的多态性。 

简单说：就是一个对象对应着不同类型. 

多态在代码中的体现：
	父类或者接口的引用指向其子类的对象。


多态的好处：
	提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：
	前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：
	1，必须有关系，继承，实现。
	2，要有覆盖。 



*/

abstract class Animal
{
	abstract void eat();

}

class Dog extends Animal
{
	void eat()
	{
		System.out.println("啃骨头");
	}
	void lookHome()
	{
		System.out.println("看家");
	}
}

class Cat extends Animal
{
	void eat()
	{
		System.out.println("吃鱼");
	}
	void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}

class Pig extends Animal
{
	void eat()
	{
		System.out.println("饲料");
	}
	void gongDi()
	{
		System.out.println("拱地");
	}
}



class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。
							//作用就是限制对特有功能的访问。
							//专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。


		//如果还想用具体动物猫的特有功能。 
		//你可以将该对象进行向下转型。
//		Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
//		c.eat();
//		c.catchMouse();

//		注意：对于转型，自始自终都是子类对象在做着类型的变化。
//		Animal a1 = new Dog();
//		Cat c1 = (Cat)a1;//ClassCastException

		method(new  Dog());

	}

	public static void method(Animal a)//Animal a = new Dog();
	{
		a.eat();

		if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
				//通常在向下转型前用于健壮性的判断。

		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.lookHome();
		}
		else
		{
		
		}
		
	}
	
}

五、多态三个必要条件

1、父类引用指向子类对象

2、要有覆盖操作，也就是重写

3、需要存在继承或者实现关系

六、弊端

父类调用的时候只能调用父类里的方法,不能调用子类的特有方法,因为你并不清楚将来会有什么样的子类继承你。

/*
毕老师和毕姥爷的故事。
*/

class 毕姥爷
{
	void 讲课()
	{
		System.out.println("管理");
	}
	void 钓鱼()
	{
		System.out.println("钓鱼");
	}
}

class 毕老师 extends 毕姥爷
{
	void 讲课()
	{
		System.out.println("Java");
	}
	void 看电影()
	{
		System.out.println("看电影");
	}
}





class  DuoTaiDemo2
{
	public static void main(String[] args) 
	{
//		毕老师 x = new 毕老师();
//		x.讲课();
//		x.看电影();

		毕姥爷 x = new 毕老师();
		x.讲课();
		x.钓鱼();

		毕老师 y = (毕老师)x;//ClassCastException
		y.看电影();

	}
}

七、多态的细节

1、成员变量：编译时期:看的引用型变量所属的类中是否有所调用的变量，运行时期:也是看引用型变量所属的类是否有调用的变量，成员变量无论编译还是运行都看引用型变量所属的类,简单记成员变量,编译和运行都看等号左边。

2、成员函数：编译时：要查看引用变量所属的类中是否有所调用的成员，在运行时：要查看对象所属的类中是否有所调用的成员。如果父子出现同名的方法,会运行子类中的方法,因为方法有覆盖的特性，编译看左边运行看右边。

3、静态函数:：编译时期:看的引用型变量所属的类中是否有所调用的变量，运行时期:也是看引用型变量所属的类是否有调用的变量，编译和运行都看等号左边

class Fu
{
//	int num = 3;
	void show()
	{
		System.out.println("fu show");
	}

	static void method()
	{
		System.out.println("fu static method");
	}
}

class Zi extends Fu
{
//	int num = 4;
	void show()
	{
		System.out.println("zi show");
	}

	static void method()
	{
		System.out.println("zi static method");
	}
}



class  DuoTaiDemo3
{
	public static void main(String[] args) 
	{
		Fu.method();
		Zi.method();
		Fu f = new Zi();//
//		f.method();
//		f.show();
//		System.out.println(f.num);


//		Zi z = new Zi();
//		System.out.println(z.num);
	}
}