Java三大特性之多态

如何实现多态

使用父类作为方法的返回值

现有宠物类（父类）、狗狗类（子类）、猫咪类

//动物类 （父类）
public class Pet{
	//定义一个抽象方法，要求子类重写  表示宠物在吃东西
	public abstract void eat();
}

//狗狗类  (子类)
public class Dog extends Anmail{
	//重写吃的方法
	@Override
	public void eat(){
		System.out.println("狗狗在吃东西");
	}
}

//猫咪类 (子类)
public class Cat extends Anmail{
	//重写吃的方法
	@Override
	public void call(){
		System.out.println("猫咪在吃东西");
	}
}

再添加一个主人类，让主人可以喂养宠物

//主人类
public class Master{
	//方法：主人喂养宠物
	//喂养狗狗
	public void feed(Dog dog){
		dog.eat();
	}
	//喂养猫咪
	public void feed(Cat cat){
		cat.eat;
	}
	
}

细想，现在只有两种动物，如果有n个动物那就要在主人类里写n个feed方法，这会大大增加代码量。
这里就可以使用多态的第一种实现方式：“使用父类作为方法的形参”来解决。
就是将Pet(父类)作为feed方法的参数。

//主人类
public class Master{
	//喂养宠物        把父类作为方法的参数
	public void feed(Pet pet){
	pet.eat();
	}
}

创建对象时：
把子类的对象包装成父类的类型(向上转型)
语法为：父类 对象名 = new 子类();
这里属于自动类型转换

//测试类
public class Test1{
	public static void main(String[] args) {
		//把dog对象包装成pet类型
		Pet pet1 = new Dog();
		//把cat对象包装成pet类型
		Pet pet2 = new Cat();
		//创建主人对象
		Master master = new Master();
		//将包装好的pet传入主人类的喂养方法
		master.feed(pet1);
		master.feed(pet2);
		
		/*
		*运行后控制台输出：
		*狗狗的吃东西
		*猫咪在吃东西
		*/
	}
}

使用父类作为方法的返回值

主人还可以领养宠物

//主人类
public class Master{
	//领养宠物
	//领养狗狗
	public Dog getDog(){
		Dog dog = new Dog();
		return dog;
	}
	//领养猫咪
	public Cat getCat(){
		Cat cat = new Cat();
		return cat;
	}
}

和上面喂养一样，宠物多了的话，也会大大增加代码量
这种情况就可以用多态的第二种实现方式：使用父类作为方法的返回值
将方法的返回值改为父类Pet

//主人类
public class Master{
	//将父类作为领养方法的返回值
	public Pet getPet(int petType){
		Pet pet=null;
		//如果为1，领养的是狗狗；为2，领养的是猫咪
		if(petType==1){
			pet = new Dog();
		}else if(petType==2){
			pet = new Cat();
		}
	}
}

测试领养方法，由主人自己选择需要领养的宠物

import java.util.Scanner;
public class Test2 {

	public static void main(String[] args) {
		//扫描器
		Scanner input=new Scanner(System.in);
		//创建主人对象
		Master master=new Master();
		System.out.println("欢迎来到宠物商店！请选择要领养的宠物类型:1.狗狗2.猫咪");
		//创建一个pet对象来接收getPet方法的返回值
		Pet pet=master.getPet(input.nextInt());
		// instanceof  判断一个对象是否属于一个类型 
		if (pet instanceof Dog){  //判断pet对象是否是一个Dog类型
			System.out.println("领养了狗狗");
		}else if (pet instanceof Cat){  //判断pet对象是否是一个Cat类型
			System.out.println("领养了猫咪");
		}else {
			System.out.println("领养失败");
		}
	}

}

向上转型和向下转型

向上转型

1.语法：父类 对象名 = new 子类();
2.属于自动类型转换
3.通过向上转型创建的对象，只能调用父类和子类共有的方法，如果此方法在子类中重写，则调用的是子类中重写过的方法

向下转型

1.语法：子类 对象名 = (子类)包装的对象名
2.属于强制类型转换
3.通过向下转型创建的对象，可以调用子类和父类中的任意方法

instanceof关键字

用来判断一个对象是否是一个类的实例
语法：对象名 intstanceof 类
返回值为boolean类型