大数据最全Java面向对象三大基本特征之多态_面向对象方法中,多态指的是(3)

public void setName(String name) {
	this.name = name;
}

public int getHealth() {
	return health;
}

public void setHealth(int health) {
	this.health = health;
}

public int getLove() {
	return love;
}

public void setLove(int love) {
	this.love = love;
}

//定义一个方法实现Animal看病
public void lookDoctor(){
	System.out.println("我是Animal类中看病的lookDoctor()方法");
}

}

子类：Cat类

public class Cat extends Animal {

private String color;

public Cat() {
	super();
}

public Cat(String name, int health, int love, String color) {
	super(name, health, love);
	this.color = color;
}

public String getColor() {
	return color;
}

public void setColor(String color) {
	this.color = color;
}

//重写Animal类中的lookDoctor()方法
@Override
public void lookDoctor() {
	System.out.println("猫生病了，打针和吃药.....");
	this.setHealth(85);
}

}

子类：Dog类

public class Dog extends Animal {

private String strain;

public Dog() {
	super();//调用父类Animal类中的无参构造方法
}

public Dog(String name, int health, int love, String strain) {
	super(name, health, love);//调用父类Animal类中的有参构造方法
	this.strain = strain;
}

public String getStrain() {
	return strain;
}

public void setStrain(String strain) {
	this.strain = strain;
}

//重写Animal类中的lookDoctor()方法
@Override
public void lookDoctor() {
	//健康值小于60的时候
	System.out.println("狗生病了，打针.......");
	this.setHealth(70);
}

}

子类：Penguin类

public class Penguin extends Animal {

private char sex;

public Penguin() {
	super();
}

public Penguin(String name, int health, int love, char sex) {
	super(name, health, love);
	this.sex = sex;
}

public char getSex() {
	return sex;
}

public void setSex(char sex) {
	this.sex = sex;
}

// 重写Animal类中的lookDoctor()方法
@Override
public void lookDoctor() {
	// 健康值小于60的时候
	System.out.println("企鹅生病了，吃药.......");
	this.setHealth(75);
}

}

主人类：Master类

public class Master {

//定义给Animal对象看病的方法
public void cure(Animal animal){
	//animal对象健康值小于60的时候需要看病
	if(animal.getHealth()<60){
		animal.lookDoctor();
	}
	
}

}

测试类：Test类

public class Test {

public static void main(String[] args) {
	
	Master master = new Master();
	
	//创建Dog类对象
	Dog dog1 = new Dog("旺财", 30, 99, "藏獒");
	System.out.println(dog1.getHealth());
	
	//调用方法原则一：方法需要什么类型的参数就需要给什么类型的参数---》方法需要什么类型的参数就需要给什么类型的参数（包括其子类）
	master.cure(dog1);
	System.out.println(dog1.getHealth());
	
	System.out.println("----------------");
	
	//创建Penguin类对象
	Penguin penguin1 = new Penguin("QQ", 45, 90, '母');
	System.out.println(penguin1.getHealth());
	
	master.cure(penguin1);
	System.out.println(penguin1.getHealth());
	
	System.out.println("----------------");
	
	Animal animal = new Dog("来福", 20, 100, "拉布拉多");
	System.out.println(animal.getHealth());
	master.cure(animal);
	System.out.println(animal.getHealth());
	
	System.out.println("---------------------------------");
	
	animal = new Penguin("QQ", 50, 92, '公');
	System.out.println(animal.getHealth());
	master.cure(animal);
	System.out.println(animal.getHealth());
}

}

结果：


![](https://img-blog.csdnimg.cn/fefd9d710de94da48ffdf7eac8350803.png)


 可以看到在Master类中将Animal类对象作为一个形参，来进行方法的调用；


### 2.使用父类作为方法的返回值：


父类：Animal类

public abstract class Animal {
//定义一个动物叫的方法
public abstract void shout();

}

子类：Cat类

public class Cat extends Animal {

@Override
public void shout() {
	System.out.println("喵喵喵");
}

}

子类：Dog类

public class Dog extends Animal {

@Override
public void shout() {
	System.out.println("汪汪汪");
}

}

主人类：Master类

public class Master {
//将父类Animal作为方法的形参使用，是多态的使用方式之一

//定义一个方法：实现让动物叫
public void letShout(Animal animal){
	animal.shout();
}

//将父类Animal作为方法的返回值，也是多态的使用方式之一
public Animal giveAnimal(String type){
	Animal animal = null;
	if(type.equals("狗")){
		animal = new Dog();
	}else{
		animal = new Cat();
	}
	
	return animal;
}

}

测试类：Test类

public class Test {

public static void main(String[] args) {

	Master master = new Master();

	// Animal是抽象类。不能直接实例化，可以使用多态的形式，将animal引用指向子类实例
	// Animal animal = new Animal();
	Animal animal = new Dog();
	
	master.letShout(animal);
	
	animal = new Cat();
	master.letShout(animal);
	
	System.out.println("-----------------------");
	
	//赠送动物
	Scanner sc = new Scanner(System.in);
	System.out.println("你想要什么动物？(猫/狗)");
	String pet =sc.next();
	Animal ani=master.giveAnimal(pet);
	ani.shout();
}

}

可以看到Master类中父类Animal类作为方法的返回值。


## 四、多态的必要性


使用多态的好处：


**1.提高了代码的可维护性**


**2.可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。**


## 五、多态的局限性


1.当父类引用指向子类对象时，父类引用是不能直接调用子类特有的方法的。需要**向下转型（强制类型转换）。**


**向下转型（强制类型转换）格式：**



> 
> **父类类型 父类对象引用=new 子类类型();//向上转型（自动类型转换）：父类的引用指向子类的实例（对象**
> 
> 
> **子类类型  子类对象引用=（子类类型）父类对象引用；//向下转型（强制类型转换）：子类的引用指向父类的引用**
> 
> 
> 


向下转换后才能调用子类特有的方法。


2.同时，在向下转型的过程中，容易出现**类型转换异常ClassCastException**，将父类引用转换成了其它的子类对象，所以在转换之前需要对父类引用类型进行判断


这时就需要用到**instanceof**关键字进行判断



> 
>  if(animal instanceof Dog){  
>              Dog dog =(Dog)animal;  
>              dog.eat();//Dog类中独有方法  
>          }else if(animal instanceof Cat){  
>              Cat cat =(Cat)animal;  
>              cat.play();//Cat类中独有方法  
>          }
> 
> 
> 


![img](https://img-blog.csdnimg.cn/img_convert/08da3c46ca86728690c00979d8cc4ae0.png)
![img](https://img-blog.csdnimg.cn/img_convert/ebeafabd055206a7456572cffc6611a3.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

      cat.play();//Cat类中独有方法  
>          }
> 
> 
> 


[外链图片转存中...(img-S68kNX2o-1714768489056)]
[外链图片转存中...(img-OoBc7PFC-1714768489056)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**