学习java的第二十天。。。(多态)

最新推荐文章于 2024-09-16 13:36:19 发布

放在糖果旁的是我很想回忆的甜

最新推荐文章于 2024-09-16 13:36:19 发布

阅读量128

点赞数 7

分类专栏： java学习文章标签：学习 java

本文链接：https://blog.csdn.net/qihaojinqiuma/article/details/126177106

版权

java学习专栏收录该内容

37 篇文章 1 订阅

订阅专栏

本文探讨了Java中的多态性概念及其重要性，指出它能提高代码的可扩展性和可维护性。通过示例展示了如何通过抽象方法和重写实现多态，以及在Master类中统一处理不同宠物类的`cure`方法。同时，文章还讨论了类型转换、向上转型和向下转型，以及`instanceof`关键字在避免类型转换异常中的作用。最后，抽象方法和抽象类的概念也被提及，强调了它们在继承和抽象行为中的角色。

摘要由CSDN通过智能技术生成

多态

为什么使用多态

如果子类中需要添加什么方法需要频繁修改代码，代码可扩展性、可维护性差。

public class Pet {
	private String name;
	private int health;
	private int love;
	
	public Pet(){
		super();
	}

	public Pet(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;
	}

	@Override
	public String toString() {
		return "宠物信息：name=" + name + ", health=" + health + ", love=" + love;
	}
}
public class Master {
	//定义给各种宠物看病的方法
	
	//定义给Dog看病的方法
	public void cure(Dog dog){
		//传递过来的dog对象健康值<60时要看病
		if(dog.getHealth()<60){
			System.out.println("准备后事⑧。。。。");
			//dog打针以后，健康值要回复一点
			dog.setHealth(70);
			System.out.println("已经埋好了");
		}
	}
	
	//定义给Penguin类看病的方法
	public void cure(Penguin penguin){
		if(penguin.getHealth()<60){
			System.out.println("直接埋。。。。");
			//dog打针以后，健康值要回复一点
			penguin.setHealth(70);
			System.out.println("开席！！！");
		}
	}
}

public class Dog extends Pet {
	private String strain;

	public Dog() {
		super();
	}

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

	public String getStrain() {
		return strain;
	}

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

	@Override
	public String toString() {
		return "宠物信息：name=" + this.getName() + ", health=" + this.getHealth() + ", love=" + this.getLove()+",strain=" + strain ;
	}
	
}

上面的代码如果在引入别的宠物类的话，要修改很多东西。如果后续要加东西的话操作繁杂，而且要修改很多东西。牵一发动全身，所以可以使用多态

什么是多态

同一个事物，作用条件不一样，结果不一样。同一个父类引用，指向不同的子类实例，执行不同的操作。方法重写是实现多态的前提

多态实现步骤

1）在抽象父类中定义抽象方法
2）子类继承抽象父类并重写父类中所有的抽象方法
3）测试类中创建父类引用指向不同的子类实例，父类引用调用方法，调用的是子类重写后的那些方法

代码如下：

public class Pet {
	private String name;
	private int health;
	private int love;
	
	public Pet(){
		super();
	}

	public Pet(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;
	}

	@Override
	public String toString() {
		return "宠物信息：name=" + name + ", health=" + health + ", love=" + love;
	}
	
	public void toHospatil(){
		System.out.println("宠物生病了，带宠物去看病....");
	}
	
}
public class Master {
	//定义给pet类对象看病的方法
	public void cure(Pet pet){
		if(pet.getHealth()<60){
			System.out.println("宠物生病了需要去医院看病");
			pet.toHospatil();
		}
	}
}

在各个子类中重写toHospatil方法

@Override
	public void toHospatil(){
		if(this.getHealth()<60){
			System.out.println("打针……");
			this.setHealth(80);
		}
	}
@Override
	public void toHospatil(){
		if(this.getHealth()<60){
			System.out.println("打针吃药…………");
			this.setHealth(80);
		}
	}

测试类方法

Dog dog1 = new Dog("旺旺", 50, 99, "泰迪");
		System.out.println(dog1.getHealth());
		master.cure(dog1);
		System.out.println(dog1.getHealth());

类型转换

同时也可以使用类型转换的方式

Pet pet1;
		pet1 = new Cat("喵喵", 45, 100, "绿色");
		master.cure(pet1);
		
		pet1 = new Dog("雷雷", 20, 1, "牛头梗");
		master.cure(pet1);
		
		pet1 = new Tiger("赔钱虎", 50, 100, 1000);
		System.out.println(pet1.getHealth());
		master.cure(pet1);
		System.out.println(pet1.getHealth());

向上转型：父类的引用指向子类的实例

类名对象名 = new 子类类名();
如： Pet pet1 = new Cat("喵喵", 45, 100, "绿色");
master.cure(pet1);
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法

关于引用的问题

父类的引用指向子类的实例，通过父类的引用去调用方法的时候，如果重写了父类引用调用的哪个方法，那么父类引用调用的是子类重写后的那个方法，如果父类引用调用的那个方法在子类中没有被重写，那么父类引用调用的就是父类里的那个方法

比如这里把Cat类中重写的方法注释掉

这里输出的就是调用的父类中的方法了

而没有注释掉的时候调用的是cat中重写的方法，结果输出是这样的

除了向上转型还有向下转型

向上转型就相当于自动类型转换

向下转型就相当于强制类型转换

向下转型，子类的引用指向父类的引用

<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
   Son1 son = (Son1) father;
    son.sonMethod();
   在向下转型的时候，容易出现ClassCastException（类型转换异常），原因是将父类引用转换成了不匹配的子类对象

public abstract class Father {
	private String name;
	private int age;
	public Father() {
		super();
	}
	public Father(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Father [name=" + name + ", age=" + age + "]";
	}
	
	public abstract void test();

public class Son1 extends Father {
	private double height;

	public Son1() {
		super();
	}

	public Son1(String name, int age, double height) {
		super(name, age);
		this.height = height;
	}

	public double getHeight() {
		return height;
	}

	public void setHeight(double height) {
		this.height = height;
	}

	@Override
	public String toString() {
		return "Son1 [name=" + this.getName() + ", age=" + this.getAge() + "height=" + height + "]";
	}
	
	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("我是son1类中重写father类的test方法");
	}
	
	public void sonMethod(){
		System.out.println("我是Son1里的独有方法sonMethod()");
	}
}

public class Son2 extends Father {
	private double weight;
	
	public Son2() {
		super();
	}

	public Son2(String name, int age, double weight) {
		super(name, age);
		this.weight = weight;
	}

	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}

	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("我是son1类中重写father类的test方法");
	}
	
	public void son2Method(){
		System.out.println("我是Son2里的独有方法son2Method()");
	}

}

public class Test {
	public static void main(String[] args) {
		// Father father =new Father() {
		// }
		// 抽象类不能实例化，因为没有意义

		Father father = new Son1("刘能", 21, 175);
		father.test();

		father = new Son2("赵四", 12, 122);
		father.test();
		// 向下转型，子类的引用指向父类的引用
		 Son2 son = (Son2)father;
		 son.son2Method();
    }
}

instanceof

但是在向下输出是也有问题，比如这样的代码

将代码改为调用Son1类中的方法，尽管代码没有报错但是运行之后

就出现了异常

在向下转型的时候，容易出现ClassCastException（类型转换异常），原因是将父类引用转换成了不匹配的子类对象

所以这个时候可以使用instanceof

代码如下

        if (father instanceof Son1) {
			Son1 son = (Son1) father;
			son.sonMethod();
		} else if (father instanceof Son2) {
			Son2 son = (Son2) father;
			son.son2Method();
		}

通过instanceof关键字类可以判断父类引用指向的是哪一个子类实例，从而避免类型转换异常

这样就好了。

抽象方法

使用abstrcat修饰方法位抽象方法
   1）抽象方法没有方法体
   2）抽象方法所在的类需要声明为抽象类
   3）子类继承一个抽象类后，子类必须重写抽象父类中所有的抽象类方法，如果不重写，那么子类也需要定义为抽象类
抽象类：使用abstract修饰的类为抽象类
   1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXXX()/setXXX()方法、重写toString()方法等
   2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类）
   3）抽象类不能实例化（不能通过new的方式来创建对象）