黑马程序员—多态

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

人：男人、女人

动物：猫、狗

猫 c = new 猫();

动物 c = new 猫(); 

可理解为父类引用指向子类对象，是多态在对象上的体现性。而重载和覆盖则是多态在函数上的体现性。

下面将从以下四个方面学习多态：

1、多态的表现形式

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

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

2、多态的前提

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

通常还有一个前提就是存在覆盖。

3、多态的好处

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

4、多态的弊端

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

5、多态如何应用

/*
动物
猫，狗。


1、多态的表现形式
	父类的引用指向了自己的子类对象。
	父类的引用也可以接收自己的子类对象。
2、多态的前提
	必须是类与类之间有关系，要么继承，要么实现。
	通常还有一个前提就是存在覆盖。
3、多态的好处
	多态的出现大大的提高了程序的扩展性。
4、多态的弊端
	提高了扩展性，但只能使用父类的引用访问父类中的成员。
5、多态如何应用

*/

abstract class Animal
{
	public 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 Pig extends Animal
{
	public void eat()
	{
		System.out.println("饲料");
	}
	public void gongdi()
	{
		System.out.println("拱地");
	}
}

//----------------------------------------
class duotaiDemo
{
	public static void main(String[] args)
	{
		Animal c = new Cat();//类型提升，向上转型
		Animal d = new Dog();
		Animal p = new Pig();
		
		function(c);
		function(d);
		function(p);
		function(new Cat());
		
		//如果想要调用猫的特有方法时，如何操作？
		//强制将父类的引用转成子类类型
		Cat a = (Cat)c;
		a.catchMouse();
		//千万不要出现将父类对象转成子类类型的操作
		//我们能转换的是父类引用指向子类对象时，该引用可以被提升，也可以被强制转换
		//多态自始至终都是子类对象在做着变化
	}
  
  public static void function(Animal a)
  {
  	a.eat();
  }
}

多态的应用：利用多态的原理，只需要完成基础功能和调用方式，就可以搭建出一个基本的框架，提高了程序的扩展性

/*
多态的应用
*/

abstract class Student
{
	public abstract void study();
	
	public void sleep()
	{
		System.out.println("躺着睡！");
	}
	
}

class DoSome
{
	public void doSome(Student stu)
	{
		stu.sleep();
		stu.study();
	}
}
/*
利用多态只需要完成前面2个类就可以搭建一个框架，提高了程序的扩展性
*/

class BaseStudent extends Student
{
	public void study()
	{
		System.out.println("学基础");
	}
	public void sleep()
	{
		System.out.println("坐着睡");
	}
}

class AdvStudent extends Student
{
	public void study()
	{
		System.out.println("学高级");
	}
	public void sleep()
	{
		System.out.println("站着睡");
	}
}
	
class duotaiDemo2
{
	public static void main(String[] args)
	{
		DoSome ds = new DoSome();
		ds.doSome(new BaseStudent());
		ds.doSome(new AdvStudent());
	}
}

多态中成员函数（非静态）的特点：

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

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

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

多态中成员变量的特点：

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

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

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