【Java-----多态详解】

多态的概念

多态是面向对象的三大特征之一，多态是指同一个对象在不同时刻表现出来的不同形态。

实现多态的条件

• 有继承：必须要有子类继承父类的关系
• 有方法重写：子类需要对父类中的一些方法进行重写
• 有向上转型：向上转型也就是有父类引用指向子类对象，如Animal a=new cat()，cat是Animal的子类

多态的好处和弊端

好处：提高了程序的可扩展性和可维护性

具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

弊端：不能使用子类的特有功能（可以通过转型来弥补这个弊端）

多态中的转型

向上转型：

父类引用指向子类对象，如：Animal a=new cat()

向上转型可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类中声明过的方法，方法体执行的就是子类重写过后的功能，但是此时对象是把自己看作是父类类型的，所以其他资源使用的还是父类类型的。

向下转型：

父类引用转为子类对象，如：cat c=(cat) a

向下转型时子类引用指向子类对象，但过程中必须要采取强制转型，是之前向上转型时的子类对象仍然想执行子类的特有功能，所以需要重新恢复子类对象

说明：向下转型是为了方便使用子类的特殊方法

多态的具体案例

多态的特点是编译看左边，执行看右边

//定义测试类
public class demo {
	public static void main(String[] args) {
		/*向上转型
		 父类引用指向子类对象*/
		Animal a=new Cat();
		a.eat();    //执行的是子类重写后的方法
		//a.catchMouse();会报错，因为是子类特有的方法
		/*向下转型
		 父类引用转为子类对象
		 */
		Cat c=(Cat)a;
		c.catchMouse();  //不再报错，可以调用

        //Dog类读者可自行尝试
	}
}

//定义动物类作为父类
public class Animal {
	private String name;
	private int age;
	public Animal() {
		
	}
	public Animal(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return age;
	}
	public void eat() {
		System.out.println("动物吃东西");
	}
}

//猫类继承动物类
public class Cat extends Animal {
	public Cat() {
		
	}
	public Cat(String name,int age) {
		super(name,age);
	}

    //重写了父类的eat方法
	public void eat() {
		System.out.println("猫吃鱼");
	}

    //自己特有的方法
	public void catchMouse() {
		System.out.println("猫抓老鼠");
	}
	
}

//狗类继承动物类
public class Dog extends Animal {
	public Dog() {
		
	}
	public Dog(String name,int age) {
		super(name,age);
	}

    //重写了父类的eat方法
	public void eat() {
		System.out.println("狗吃骨头");
	}

    //自己特有的方法
	public void lookDoor() {
		System.out.println("狗会看门");
	}
}

多态的应用

当以父类对象作为方法的参数时，可以在调用方法时传入上转型对象，子类对象

//定义测试类
public class demo {
	public static void main(String[] args) {
        animalOperate ao=new animalOperate();
        Animal a1=new Cat();
        Animal a2=new Dog();
        //传入上转型对象
        ao.useAnimal(a1);
        ao.useAnimal(a2);
        Cat c=new Cat();
        Dog d=new Dog();
        //传入子类对象
        ao.useAnimal(c);
        ao.useAnimal(d);
	}
}

//创建动物类作为父类
public class Animal {
	
	public void eat() {
		System.out.println("动物吃东西");
	}
}

//创建猫类继承动物类
public class Cat extends Animal {
	
	//重写了eat方法
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

//创建狗类继承动物类
public class Dog extends Animal {
	
    //重写了eat方法
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

//创建动物操作类
public class animalOperate {

	//该方法的参数是一个对象
    public void useAnimal(Animal a) {
		a.eat();
	}
}