day15 方法重写和多态（三）

最新推荐文章于 2024-07-11 17:24:34 发布
最新推荐文章于 2024-07-11 17:24:34 发布
阅读量228 收藏
点赞数 1
分类专栏： java学习计划 文章标签： java 开发语言 后端 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44982904/article/details/123214971
版权

1. 概念

生活中的多态：同一个动作，指令在不同的环境下，产生不同的效果

程序中的多态：同一段代码，因为实际参数或者具体返回值的不同，产生不同的效果，提升代码的灵活性

2. 表现形式1

1.父类作为形参，子类作为实参

  • 这种方式属于父类引用指向子类对象，属于自动向上转型 Pet pet = new Dog()/new Penguin(); double a = 20;

  • 此时，通过父类的引用，可以访问的是子类重写父类的方法(以及继承父类的方法)，不能访问子类独有方法

package com.qfedu.test2;
/**
 * 	生活中的多态：统一个动作，指令在不同的环境下，产生不同的效果
 * 
 * 	程序中的多态：同一段代码，因为实际参数或者具体返回值的不同，产生不同的效果，提升代码的灵活性
 * 
 * 	多态的方式：
 * 		1.父类作为形参，子类作为实参
 * 			这种方式属于父类引用指向子类对象，属于自动向上转型  Pet pet = new Dog()/new Penguin();  double a =  20;
 * 			此时，可以通过父类的引用，可以访问的是子类重写父类的方法(以及继承父类的方法)，不能访问子类独有方法
 * 		2.父类作为返回值，子类为实际返回值
 * @author WHD
 *
 */
public class Pet {
	protected String name;
	protected int health;
	protected int 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;
	}
	
	public void cure() {
		System.out.println("宠物看病");
	}
	
	
	void print() {
		System.out.println("宠物的名字是：" + name + "，健康值是：" + health + "，爱心值是：" + love);
	}
}
package com.qfedu.test2;
/**
 * 	Dog类
 * 	品种
 * 
 * 	无参构造
 * 	打印信息方法
 * @author WHD
 *
 */
public class Dog extends Pet{
	private String strain;
	public String getStrain() {
		return strain;
	}
	public void setStrain(String strain) {
		this.strain = strain;
	}
	
	public Dog() {
	}
	
	
	public Dog(String name,int health,int love,String strain) {
		this.strain = strain;
		super.name = name;
		super.health = health;
		super.love = love;
	}
	@Override
	public void print(){
		super.print();
		System.out.println("狗狗的品种是：" + strain);
	}
	
	public void cure() {
		System.out.println("-------Dog子类重写Pet父类cure方法-------");
		super.cure();
		System.out.println("狗狗看病，吃药，打针，健康值恢复！");
		this.setHealth(100);
		this.setLove(100);
	}
	
	public void dogM1() {
		System.out.println("Dog类m1方法");
	}
}
package com.qfedu.test2;
/**
 * 	企鹅类
 * 	性别
 * 
 * 	无参构造
 * 	打印信息方法
 * @author WHD
 *
 */
public class Penguin extends Pet{
	private String sex;
	
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Penguin() {
	}
	
	public Penguin(String name,int health,int love,String sex) {
		this.sex = sex;
		this.name = name;
		this.health = health;
		this.love = love;
	}
	
	public void print() {
		super.print();
		System.out.println("企鹅的性别是：" + sex);
	}
	
	public void cure() {
		System.out.println("企鹅看病，打针，疗养，健康值恢复！");
		this.setHealth(100);
		this.setLove(100);
	}
	
}
package com.qfedu.test2;
/**
 * 	主人类  
 * 	1.提供有可以带宠物去看病的方法
 * @author WHD
 *
 */
public class Master {
	private String name;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
	public void toHospitalWithDog(Dog dog) {
		dog.cure();
	}
	public void toHospitalWithPenguin(Penguin penguin) {
		penguin.cure();
	}
	
	// 分析：以上两个方法可以实现给宠物看病，但是这种方式存在问题，后续如果有新的宠物子类
	// 那么必须再次添加新的给宠物看病的方法 ，这种情况不符合"开闭原则"
	// 开：对扩展开放
	// 闭：对修改源代码关闭
	// 所以我们应该考虑编写一个方法  用于实现给所有的宠物看病
	
	public void toHospitalWithPet(Pet pet) { // Pet pet = new Dog();  double a =  20;
		pet.cure();
	}

}
package com.qfedu.test2;

public class TestPet2 {
	public static void main(String[] args) {
		Dog dog2 = new Dog("小黄", 65, 30, "金毛");
		Penguin p2 = new Penguin("小白", 50, 50, "雌性");
		Master guangkun = new Master();
		guangkun.toHospitalWithPet(dog2);
		guangkun.toHospitalWithPet(p2);
		
		System.out.println(dog2.getHealth() + "---" + dog2.getLove());
		System.out.println(p2.getHealth() + "---" + p2.getLove());
		
		
	}
}

3. 表现形式2

父类作为返回值，子类为实际返回值

这种方式依然属于是向上转型，父类引用指向子类对象

package com.qfedu.test3;
/**
 * 	生活中的多态：同一个动作，指令在不同的环境下，产生不同的效果
 * 
 * 	程序中的多态：同一段代码，因为实际参数或者具体返回值的不同，产生不同的效果，提升代码的灵活性
 * 
 * 	多态的方式：
 * 		2.父类作为返回值，子类为实际返回值
 * @author WHD
 *
 */
public class Pet {
	protected String name;
	protected int health;
	protected int 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;
	}
	
	public void cure() {
		System.out.println("宠物看病");
	}
	
	
	void print() {
		System.out.println("宠物的名字是：" + name + "，健康值是：" + health + "，爱心值是：" + love);
	}
}
package com.qfedu.test3;
/**
 * 	Dog类
 * 	品种
 * 
 * 	无参构造
 * 	打印信息方法
 * @author WHD
 *
 */
public class Dog extends Pet{
	private String strain;
	public String getStrain() {
		return strain;
	}
	public void setStrain(String strain) {
		this.strain = strain;
	}
	
	public Dog() {
	}
	
	
	public Dog(String name,int health,int love,String strain) {
		this.strain = strain;
		super.name = name;
		super.health = health;
		super.love = love;
	}
	@Override
	public void print(){
		super.print();
		System.out.println("狗狗的品种是：" + strain);
	}
	
	public void cure() {
		System.out.println("-------Dog子类重写Pet父类cure方法-------");
		super.cure();
		System.out.println("狗狗看病，吃药，打针，健康值恢复！");
		this.setHealth(100);
		this.setLove(100);
	}
	
	public void dogM1() {
		System.out.println("Dog类m1方法");
	}
	@Override
	public String toString() {
		return "Dog [strain=" + strain + ", name=" + name + ", health=" + health + ", love=" + love + "]";
	}

}
package com.qfedu.test3;
/**
 * 	企鹅类
 * 	性别
 * 
 * 	无参构造
 * 	打印信息方法
 * @author WHD
 *
 */
public class Penguin extends Pet{
	private String sex;
	
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Penguin() {
	}
	
	public Penguin(String name,int health,int love,String sex) {
		this.sex = sex;
		this.name = name;
		this.health = health;
		this.love = love;
	}
	
	public void print() {
		super.print();
		System.out.println("企鹅的性别是：" + sex);
	}
	
	public void cure() {
		System.out.println("企鹅看病，打针，疗养，健康值恢复！");
		this.setHealth(100);
		this.setLove(100);
	}
	@Override
	public String toString() {
		return "Penguin [sex=" + sex + ", name=" + name + ", health=" + health + ", love=" + love + "]";
	}

}
package com.qfedu.test3;
/**
 * 	主人类  
 * 	1.提供有可以带宠物去看病的方法
 * @author WHD
 *
 */
public class Master {
	private String name;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void toHospitalWithPet(Pet pet) { 
		pet.cure();
	}
	// 需求：宠物店开业活动大酬宾  抽奖送宠物
	// 一等奖 送雌性企鹅一只
	// 二等奖 送雄性狗狗一只
	// 三等奖 送猫咪一只
	// 幸运奖 送成年东北虎一只
	
	public Penguin givePenguin(){
		Penguin p1 = new Penguin("大白", 100, 100, "雌性");
		return p1;
	}
	
	public Dog giveDog(){
		Dog dog = new Dog("大黄", 100, 100, "藏獒");
		return dog;
	}
	
	public Cat giveCat() {
		return new Cat();
	} 
	
	public Tiger giveTiger() {
		return new Tiger();
	}
	
	// 分析： 以上代码可以实现赠送宠物  但是这种方式同样不符合开闭原则
	// 因为后续如果有其他的奖项 还需要再编写代码实现
	// 所以我们应该编写一个方法 用于实现所有的宠物赠送  
	
	public Pet givePet(String str) {
		if(str.equals("一等奖")) {
			Penguin p1 = new Penguin("大白", 100, 100, "雌性");
			return p1;
		}else if(str.equals("二等奖")) {
			Dog dog = new Dog("大黄", 100, 100, "藏獒");
			return dog;
		}else if(str.equals("三等奖")) {
			return new Cat();
		}else if(str.equals("幸运奖")) {
			return new Tiger();
		}
		return null;
	}
	
	public double m1(double a ) {
		return 20;
	}
	
}
package com.qfedu.test3;

public class TestPet {
	public static void main(String[] args) {
		Master zhaosi = new Master();
		Pet penguin1 = zhaosi.givePet("一等奖"); // 父类引用指向子类对象 向上转型
		System.out.println(penguin1);
		
		Pet dog1 = zhaosi.givePet("二等奖");
		System.out.println(dog1);
		
		System.out.println(zhaosi.givePet("三等奖"));
		
	}
}

4. 向下转型

回顾多态的两种表现形式，都属于向上转型(自动提升)，父类引用指向子类

此时可以访问的是，继承父类的方法 和 子类重写父类的方法

但是，不能访问子类独有的方法，如果需要访问子类独有的方法

必须向下转型(手动下降)

package com.qfedu.test4;
/**
 * 	Dog类
 * 	品种
 * 
 * 	无参构造
 * 	打印信息方法
 * @author WHD
 *
 */
public class Dog extends Pet{
	private String strain;
	public String getStrain() {
		return strain;
	}
	public void setStrain(String strain) {
		this.strain = strain;
	}
	
	public Dog() {
	}
	
	
	public Dog(String name,int health,int love,String strain) {
		this.strain = strain;
		super.name = name;
		super.health = health;
		super.love = love;
	}
	@Override
	public void print(){
		super.print();
		System.out.println("狗狗的品种是：" + strain);
	}
	
	public void cure() {
		System.out.println("-------Dog子类重写Pet父类cure方法-------");
		super.cure();
		System.out.println("狗狗看病，吃药，打针，健康值恢复！");
		this.setHealth(100);
		this.setLove(100);
	}
	
	@Override
	public String toString() {
		return "Dog [strain=" + strain + ", name=" + name + ", health=" + health + ", love=" + love + "]";
	}
	
	
	public void playFlyDisc() {
		System.out.println("狗狗玩飞盘，很开心~");
	}
	
}
package com.qfedu.test4;
/**
 * 	生活中的多态：同一个动作，指令在不同的环境下，产生不同的效果
 * 
 * 	程序中的多态：同一段代码，因为实际参数或者具体返回值的不同，产生不同的效果，提升代码的灵活性
 * 
 * 	回顾多态的两种表现形式，都属于向上转型(自动提升)，父类引用指向子类
 * 	此时可以访问的是，继承父类的方法 和 子类重写父类的方法
 * 	但是，不能访问子类独有的方法，如果需要访问子类独有的方法
 * 	必须向下转型(手动下降)
 * @author WHD
 *
 */
public class Pet {
	protected String name;
	protected int health;
	protected int 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;
	}
	
	public void cure() {
		System.out.println("宠物看病");
	}
	
	
	void print() {
		System.out.println("宠物的名字是：" + name + "，健康值是：" + health + "，爱心值是：" + love);
	}
}
package com.qfedu.test4;

public class TestPet {
	public static void main(String[] args) {
		Dog dog1 = new Dog("大黄", 100, 100, "二哈");
		dog1.playFlyDisc();
		
		Pet dog2 = new Dog("小黄", 100, 100, "拉布拉多");// 只能访问继承父类的方法 和 子类重写父类的方法
		Dog dog = (Dog) dog2;
		dog.playFlyDisc();
		
		
		Pet pet = new Pet();
	
		if(pet instanceof Dog) { // instanceof 关键字用于判断 左侧的引用是否属于右侧的类型
			Dog dog3 = (Dog) pet;
			System.out.println(dog3);
		}
		
		System.out.println("hello world");
//		dog2.playFlyDisc();
		
	}	
}

5. instanceof关键字

instanceof 关键字用于判断 左侧的引用是否属于右侧的类型

用于避免程序中引用数据类型类型转换异常

package com.qfedu.test5;

import com.qfedu.test4.Dog;

/**
 * 	
 * @author WHD
 *
 */
public class Person {
	private String name;
	private String idCard;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getIdCard() {
		return idCard;
	}
	public void setIdCard(String idCard) {
		this.idCard = idCard;
	}
	
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}
		if(obj instanceof Person) {
			Person p1 = (Person) obj;
			if(this.getName().equals(p1.getName()) && this.getIdCard().equals(p1.getIdCard())) {
				return true;
			}
		}
		
		return false;
	}
	
	public static void main(String[] args) {
		Person p3 = new Person("赵四", "4512487812142453");
		Dog dog = new Dog("大黄", 100, 100, "金毛");
		System.out.println(p3.equals(dog));
		
		
		
	}
	public Person(String name, String idCard) {
		this.name = name;
		this.idCard = idCard;
	}
	public Person() {
	}
	
}

6.返回值相同或者是其子类

package com.qfedu.test6;

public class A {
	public Object m1() {
		return null;
	}
}

class A1 extends A{
	public String m1() {
		return null;
	}
}

class A2 extends A{
	public Object m1() {
		return null;
	}
}

请雅清同学过目！

ICErain0201
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Day020 方法重写与多态
csc2856891204的博客
08-05 102
三、多态（多态的使用是因为频繁修改代码，代码可扩展性、可维护性差）方法重写是实现多态的基础。
day04_接口和多态.zip
09-12
编译时多态主要通过方法重载（Overloading）实现，运行时多态主要通过方法重写（Overriding）和接口实现来实现。 例如，我们可以创建一个动物数组，其中包含不同类型的动物： ```java Animal[] animals = new ...
javaSE 第十三课 多态
code34的博客
02-05 149
main方法 package com.easy.oop.Day03; public class Application { public static void main(String[] args) { //一个对象的实际类型是确定的 //new Student(); //new Person( ); //可以指向的引用类型就不确定了:父类的引用指向子类 // Student能调用的方法都是自己的或者继承父类的!
重写和多态
qq_48578877的博客
07-22 682
重写的原则和多态的概念、优点
java面向对象day4-方法重写与多态
hzbobhz的博客
01-19 88
方法重写 方法的重写也可以叫做方法的覆盖（overriding） 子类根据需求对从父类继承的方法进行重新编写 重写时，可以用**super.**方法的方式来保留父类的方法 构造方法不能被重写 方法重写的规则：   方法名相同   参数列表相同   返回值类型相同或者是其子类   访问权限不能严于父类   父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法   子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)   父类的私有方
C++多态day15
10-28
在C++编程语言中，多态（Polymorphism）是面向对象编程的三大特性之一，另外两个是封装和继承。多态允许我们使用一个接口来表示多种类型，它提供了代码的灵活性和重用性，使得程序更加通用。今天我们将深入探讨C++中...
day10-final、接口、多态.pdf
11-02
多态的实现有两种方式：方法重写和方法重载。方法重写是指子类中提供了一个与父类同名、同参数列表的方法，但可以有不同的实现。方法重载是指多个方法具有相同的方法名，但不同的参数列表。 本文档详细讲解了 final...
C++day15-多态 文档
10-28
在C++编程语言中，多态（Polymorphism）是一个核心特性，它允许我们使用一个接口来表示多种不同的类型，增强了代码的灵活性和可扩展性。在C++中，多态主要通过虚函数（Virtual Functions）和纯虚函数（Pure Virtual ...
配置Java开发环境
Broken_x的博客
07-10 1259
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 388
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1356
在 Java 中，可以通过多种方法将一个Object转换为Integer。
解决分布式环境下session共享问题
shenxiaomo1688的博客
07-06 2368
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2019
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java占位符替换五种方式
weixin_61478518的博客
07-08 477
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
Java方法练习-双色球彩票系统
最新发布
T1798218285的博客
07-11 238
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3219
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
springboot中抽离日志
qq_24223159的博客
07-08 369
【代码】springboot中抽离日志。
java继承和多态之方法重写
10-22
Java中的继承和多态是面向对象编程的重要特性，其中方法重写是多态的一种表现形式。当子类继承父类时，子类可以重写父类的方法，即在子类中创建一个与父类中相同名称、相同返回值类型、相同参数列表的方法，但是方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值