Java 多态【JAVA基础】

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

1. 多态的体现
父类的引用指向了自己的子类对象
父类的引用也可以接受自己的子类对象

2. 多态的前提
必须是类与类之间有关系
通常还有一个前提：存在覆盖
3. 多态的好处
多态的出现大大的提高程序的扩展性

4. 多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员。

       想要访问子类中的成员的方法

Animal a=new Cat();//向上转型
 Cat c=(Cat)a;//（向下转型）强制将父类的引用，转成子类类型，就可以调用猫的特有方法       

5.多态的应用

 注意：在多态中，成员函数的特点：(例子      Fu x=new Zi();)
 在编译时期：参阅引用型变量(父类)所属的类中是否有调用方法，如果有，编译通过，没有，编译失败
 在运行时期：参阅对象所属的类中是否有调用的方法。
 简单来说就是：成员函数在多态调用时，编译看左边，运行看右边。Fu x=new Zi();
 
 在多态中，成员变量的特点
 无论编译或者是运行，都参考左边（引用型变量所属的类）
 
 在多态中，静态成员函数的特点
 无论编译或者是运行，都参考左边（引用型变量所属的类）

具体的代码案例
1.DuoTaiDemo1

package 黑马;
/*
 * 多态-示例
 * 基础班学生：
 *       学习，睡觉
 * 高级班学生
 *       学习，睡觉
 * 可以将这两类事物进行抽取   
 * */
public class DuoTaiDemo5 {
	public static void main(String[] args) {
		DoStudent ds=new DoStudent();
		ds.DoSome(new BaseStudent());
		ds.DoSome(new AdvStudent());
//		BaseStudent bs=new BaseStudent();
//		bs.study();
//		bs.study();
//		AdvStudent as=new AdvStudent();
//		as.study();
//		as.study();
	}
	
}
abstract class StudentDemo
{
	public abstract void study();
	public void sleep() 
	{
		System.out.println("躺着睡");
	}
}
class DoStudent
{
	public void DoSome(StudentDemo stu)
	{
		stu.study();
		stu.sleep();
	}
}
class BaseStudent extends StudentDemo
{
	public void study()
	{
		System.out.println("base study");	
	}
	public void sleep() 
	{
		System.out.println("坐着睡");
	}
}
class AdvStudent extends StudentDemo
{
	public void study()
	{
		System.out.println("adv study");	
	}
}

2.DuoTaiDemo2

package 黑马;
//需求
//电脑运行多态的实例
//电脑运行基于主板
public class DuoTaiDemo3 {
	public static void main(String[] args) {
		MainBord mb=new MainBord();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());//PCI p=new NetCard//接口型引用多态
		mb.usePCI(new SoundCard());//PCI p=new SoundCard//接口型引用多态
	}
}
class MainBord
{
	public void run()
	{
		System.out.println("mainbord run");
	}
	public void usePCI(PCI p)
	{
		if(p!=null)
		{
		p.open();
		p.close();
		}
	}
}
interface PCI
{
	public void open();
	public 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("Sound open");
	}
	public void close()
	{
		System.out.println("Sound close");
	}
}

3.DuoTaiDemo3

package 黑马多态;

public class DuoTaiDemo1 {

	public static void main(String[] args) {
		//Animal c1=new Cat();//对象的多态-代码体现形式
		function(new Cat());
		function(new Dog());
		function(new Pig());
		Animal a=new Cat();//向上转型
		a.eat();
		Cat c=(Cat)a;//（向下转型）强制将父类的引用，转成子类类型，就可以调用猫的特有方法
		c.catchMouse();//自始至终只有子类对象在发生变化
		
	}
	public static void function(Animal a) {
		a.eat();
		if(a instanceof Cat)//数据类型判断
		{
		Cat x=(Cat)a;
		x.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog x=(Dog)a;
			x.kanJia();
		}
	}
}
//动物：猫，狗
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 Pig extends Animal
{
	public void eat()
	{
		System.out.println("饲料");
	}
	
	public void gongDi()
	{
		System.out.println("拱地");
	}
}