——多态

----
多态概述
多态：可以理解为事物存在的多种体现形态。
如：人分为男人和女人。
动物：猫、狗。
猫 x = new 猫();
动物 x = new 猫();
学习多态主要围绕：
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 Pig extends Animal(){
	public void eat(){
		System.out.println("饲料");
	}
	public void gondi(){
		System.out.println("拱地");
	}
}
class DuotaiDemo
{
	public static void main(String[] args){
//		Cat c = new Cat();
//		c.eat();
//		Dog d = new Dog();
//		d.eat();
//		Animal a = new Animal();
//		a.eat();
		function(new Cat());
		function(new Dog());
		function(new Pig());
	}
	public static void function(Animal a){
		a.eat();
	}
}

如何使用子类的特有方法：

class DuoTaiDemo
{
	public static void main(String[] args){
		Animal a = new Cat();//类型提升，向上转型。
		a.eat();//但是不能使用子类的特有方法。
		//如何使用子类特有方法呢？
		//可以强制将父类的引用转换成子类类型。
		Cat c = (Cat)a;//向下转型
		c.CatchMouse();
		//下面这种转型是不对的。我们转的是父类的引用，不可以将父类的对象转型。
		//我们可以转换的是父类的引用指向的自己的子类对象时，可以被提升，也可以被强制转换。
		//多态自始至终都是子类对象在变化
		Animal a = new Animal();
		Cat  c = (Cat)a;
	}
	public static void function(Animal a){
		a.eat();//instanceof用来判断所属类型，然后可以使用所属类型的特有方法。
		if(a instanceof Cat){
			Cat c = (Cat)a;
			c.CatchMouse();
		}
		else if(a instanceof Dog){
			Dog d = (Dog)a;
			d.kanjia();
		}
	}
}

4.多态的应用：
基础班：学习、睡觉。
高级班：学习、睡觉。
对这两类事物进行抽取，

abstract class Student
{
	public abstract void study();
	public void sleep(){
		System.out.println("躺着睡");
	}
}
class BAaseStudent extends Student
{
	public void study(){
		System.out.println("base study");
	}
	public void sleep(){
		System.out.println("坐着睡");
	}
}
class AdvStudent extends Student
{
	public void study(){
		System.out.println("adv study");
	}
}
class DoStudent
{
	public void doSome(Student stu){
		stu.sleep();
		stu.study();
	}
}
class DuotaiTest
{
	public static void main(String[] args){
//		BaseStudent bs = new BaseStudent();
//		bs.sleep();
//		bs.study();
//		AdvStudent as = new AdvStudent();
//		as.sleep();
//		as.study();
		DoStudent ds = new DoStudent();
		ds.doSome(new BaseStudent());
		ds.doSome(new AdvStudent());
	}
}

多态中(父类引用指向子类对象)成员函数（非静态）的特点：
（如果子类静态覆盖父类静态方法，运行时调用的还是父类中的静态方法）不常见但是要知道（与静态的加载方式有关）。
在编译时，参阅引用型变量所属的类中是否有调用的方法，如果有则编译通过，如果没有则编译失败，如代码中的方式2
因为父类中没有Method3方法，所以编译失败。
在运行时：参阅对象所属的类中是否有调用的方法。
总结：成员函数在多态中调用时，编译时期看左边（即父类（引用）中有没有调用的方法），
运行看右边（即子类对象中是否有调用的方法）。
多态中成员变量的特点：无论编译还是运行，都是参阅的引用型变量所属的类（左边）。即父类和子类中出现重名变量时，
在多态的情况下，调用的变量值是父类中的值，

class Fu
{
	public void Method1(){
		System.out.println("method_1");
	}
	public void Method2(){
		System.out.println("method_2");
	}
}
class Zi extends Fu
{
	public void Method1(){
		System.out.println("method_1");
	}
	public void Method3(){
		System.out.println("method_3");
	}
}
class DuoTaiDemo5
{
	public static void main(String[] args){
		//方式2 多态
		Fu f = new Zi();
		f.Method1();
		f.Method2();
		//f.Method3();因为父类中没有这个方法。编译失败
		//方式1
//		Zi z = new Zi();
//		z.Method1();
//		z.Method2();
//		z.Method3();
	}
}

多态的应用，主板以及PCI接口实例体会多态。

/*接口  多态 本实例重点研读
需求：
电脑运行实例  基于主板*/
interface PCI{
	public void open();
	public void close();
}//定义一个主板，可以调用PCI
class MainBoard{
	public void run(){
		System.out.println("mainboard run");
	}
	public void usePCI(PCI p){//接口型引用指向自己的子类对象。
		if(p!=null){
			p.open();
			p.close();
		}
	}
}//电脑的各个模块实现了PCI
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("soundcard open");
	}
	public void close(){
		System.out.println("soundcard close");
	}
}
class  DuotaiDemo1{
	public static void main(String[] args) {
		MainBoard mb=new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
	}
}

Object类：类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 
object:是所有对象的直接或者间接父类，超类
该类中定义的是所有对象都具备的功能,下面演示一个方法equals。

class Demo{  //extends object
	private int num;
	Demo(int num){
		this.num=num;
	}
	public boolean equals(Object obj){//覆盖父类中的方法
		if(!(obj instanceof Demo))//instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。
			return false;
		Demo d=(Demo)obj;//向下转型
		return this.num==d.num;
	}
}
class Person{
}
class ObjectDemo {
	public static void main(String[] args) {
		Demo d1=new Demo(5);
		Demo d2=new Demo(6);
		Person p=new Person();
		System.out.println(d1.equals(p));
	}
}