最全Java面向对象三大基本特征之多态_面向对象方法中,多态指的是，2024年最新从入门到真香

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

父类：Animal类

public class Animal {
	private String name;
	private int health;//健康值
	private int love;

	public Animal() {
		super();
	}

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

	public String getName() {
		return name;
	}

	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());
	}

}

结果：

可以看到在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 子类类型();//向上转型（自动类型转换）：父类的引用指向子类的实例（对象

子类类型  子类对象引用=（子类类型）父类对象引用；//向下转型（强制类型转换）：子类的引用指向父类的引用

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

类类型  子类对象引用=（子类类型）父类对象引用；//向下转型（强制类型转换）：子类的引用指向父类的引用**

[外链图片转存中…(img-5vbb1Zaj-1715795824947)]
[外链图片转存中…(img-sZ9WbqLI-1715795824948)]
[外链图片转存中…(img-fg9ibrCM-1715795824948)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取