Java基础——面向对象（五）多态

一、概述

对象的多态性

class 动物
{}

class 猫 extends 动物
{}

class 狗 extends 动物
{}

class Demo{
    public static void main(String[] args){
        猫 x = new 猫();

        动物 y = new 猫();//表象：父类创建对象指向了子类，体现了多态
    }
}

       猫这类食物既具备猫的形态，又具备动物的形态。这就是多态性。
       简单说：就是一个对象对应着不同类型

二、优点

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

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) 
	{
		
//		Cat c = new Cat();
//		c.eat();
//		c.catchMouse();

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


//		a.eat();

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

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


		/*
		Cat c = new Cat();

//		Dog d = new Dog();

//		c.eat();
		method(c);
//		method(d);
//		method(new Pig());
		*/

		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
		{
		
		}
		
	}
	/*
	public static void method(Cat c)
	{
		c.eat();
	}
	public static void method(Dog d)
	{	
		
	}
	*/	
}

三、多态的前提&弊端

1.弊端：前期定义的内容不能使用（调用）后期子类的特有内容。 定义了animal不能使用猫的catchMouse

2.前提：

• 必须有关系，继承，实现。
• 必须有覆盖

 四、转型

1.向上转型：作用就是限制对特有功能的访问。
                  专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。

2.向下转型：向下转型的目的是为了使用子类中的特有方法。

 注意：对于转型，自始自终都是子类对象在做着类型的变化。

 3.类型判断instanceof

用于判断对象的具体类型。

                if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
						//通常在向下转型前用于健壮性的判断。
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.lookHome();
		}

五、多态后成员变化特点（重点）

1.成员变量。

编译时，参考引用型变量所属的类中是否有调用的成员变量？有，编译通过；没有，编译失败。

运行时，参考引用型变量所属的类中是否有调用的成员变量？并运行该所属类中的成员变量。

简单说，就是编译和运行都参考左边。

2.成员函数。

编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

简单说：编译看左边，运行看右边。

因为成员函数存在覆盖特性。

3.静态函数。

编译时：参考引用型变量所属的类中的是否有调用的静态方法。

运行时：参考引用型变量所属的类中的是否有调用的静态方法。

简单说，编译和运行都看左边。

其实对于静态方法，是不需要对象的。直接用类名调用即可。