最新Java面向对象三大基本特征之多态_面向对象方法中,多态指的是(4)，2024年最新【面试总结

于 2024-05-16 06:23:08 发布
阅读量269 收藏 5
点赞数 5
文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84573133/article/details/138938782
版权

img
img

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

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

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

java实现多态有 3 个必要条件：继承、重写和向上转型。

（1）继承：在多态中必须存在有继承关系的子类和父类。

（2）方法重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

（3）向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。即父类引用变量可以指向子类对象。

父类类型 变量名=new 子类类型();

2.示例：接下来我们用代码来帮助理解

父类：Animal类

public class Animal {
	
	public String name;
	public int health;//健康值
	public int love;//亲密度
	
	public Animal() {//无参构造
		super();
	}
	public Animal(String name, int health, int love) {//有参构造
		super();
		this.name = name;
		this.health = health;
		this.love = love;
	}
	
	
	//定义一个方法
	public void test(){
		System.out.println("我是Animal类中的test()方法");
	}
	

}

子类：Cat类

public class Cat extends Animal {

	public String color;//颜色

	public Cat() {
		super();
	}

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


	// 重写Animal类中的test()方法
	public void test() {
		System.out.println("我是Cat类中的test()方法");
	}
	
	public void play(){
		System.out.println("我是Cat类中的play()方法");
	}

}

子类：Dog类

public class Dog extends Animal {
	public String strain;//种类

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

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

	
	//重写Animal类中的test()方法
	public void test(){
		System.out.println("我是Dog类中的test()方法");
	}
	
	public void eat(){
		System.out.println("我是Dog类中的eat()方法");
	}
}

测试：Test类

public class Test {

	public static void main(String[] args) {
		
		//创建Dog类对象
		Dog dog = new Dog("旺财", 100, 100, "金毛");
		dog.test();
		
		//创建Cat类对象
		Cat cat = new Cat("Tom", 100, 99, "蓝色");
		cat.test();
		
		System.out.println("--------------------------");
		
		//多态：同一个父类引用，指向不同的子类实例，执行不同的操作。方法重写是实现多态的前提
		
		//向上转型（自动类型转换）：父类的引用指向子类的实例（对象）
		Animal animal = new Dog("来福", 100, 98, "泰迪");
		animal.test();
		//eat()方法是Dog类中独有的方法、父类引用无法直接调用子类中特有的方法，如果父类引用需要使用子类中独有的的方法，需要将父类引用强制类型转换为子类
//		animal.eat();
		
		//向下转型（强制类型转换）：子类的引用指向父类的引用
		Dog dog2=(Dog)animal;
		dog2.eat();
		
		animal = new Cat("加菲猫", 85, 88, "黄色");
		animal.test();
		//play()方法是Cat类中独有的方法，父类引用无法直接调用子类中特有的方法，如果父类引用需要使用子类中独有的的方法，需要将父类引用强制类型转换为子类
//		animal.play();
		//在向下转型过程中，容易出现类型转换异常ClassCastException，将父类引用转换成了其它的子类对象，所以在转换之前需要对父类引用类型进行判断
//		Dog cat2 =(Dog)animal;
		
		
		if(animal instanceof Dog){
			Dog dog3 =(Dog)animal;
			dog3.eat();
		}else if(animal instanceof Cat){
			Cat cat3 =(Cat)animal;
			cat3.play();
		}
		
		

	}

}

结果：

由上述代码我们可以看到，创建了一个Animal引用指向Dog类实例，然后使用animal引用调用test()方法，实际上调用的却是Dog类中的test（）方法，这就是多态的一种应用;

三、Java中实现和使用多态的主要方式：

1.使用父类作为方法的形参：

示例：

父类：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) {
		


![img](https://img-blog.csdnimg.cn/img_convert/3213be1fdbcf0657119a1144c70989f1.png)
![img](https://img-blog.csdnimg.cn/img_convert/12dd959a4367a16d05a992d1e0fce629.png)

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

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


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

public class Test {

	public static void main(String[] args) {
		


[外链图片转存中...(img-OBPlx4j1-1715811767201)]
[外链图片转存中...(img-39msPS7J-1715811767201)]

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

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


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84573133
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面向对象的3大特征之多态
07-27
多态是面向对象中很重要的知识点 实现多态的条件 多态的优点
javascript面向对象三大特征之多态实例详解
12-13
本文实例讲述了javascript面向对象三大特征之多态。分享给大家供大家参考，具体如下： 多态 从某种意义上来说，多态是面向对象中重要的一部分，也是实施继承的主要目的。 一个实例可以拥有多个类型，它既可以是这种...
Java多态详解
m0_67599274的博客
04-28 3万+
目录1. 基本介绍1.1 多态的概念1.2 对象的多态1.3 入门案例2. 具体细节2.1 向上转型2.2 向下转型2.3 instanceOf 比较操作符3. 实现技术：动态绑定4. 应用4.1 多态数组4.2 多态参数5. 多态的优点 1. 基本介绍 1.1 多态的概念 多态是继封装、继承之后，面向对象的第三大特性。 多态体现为父类引用变量可以指向具体的子类对象。 1.2 对象的多态 1.3 入门案例 2. 具体细节 2.1 向上转型 2.2 向下转型 2.3 instanceOf 比较操作符 3. 实
Java中的多态
热门推荐
z972065491的博客
10-09 4万+
Java中的多态
JavsSE =＞ 多态
qq_55694452的博客
08-09 556
I came;I saw;I conquer。
JAVA中多态的理解
zhangguan96的博客
03-24 4792
JAVA中多态的理解以及使用。
Java多态概念理解（java期中作业）
lzh1830734817的博客
11-17 2541
一、Java多态简介 多态是java继封装、继承后的面向对象的第三大特征，多态是同一个行为具有多个不同表现形式或形态的能力，多态是一个接口，使用不同的实例而执行不同操作。使用多态可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。 多态的优点： 1.消除类型之间的耦合关系 2.可替换性 3.可扩充性 4.接口性 5.灵活性 6.简化性 多态存在的三个必要条件： 1.继承 2.重写 3.父类应用指向子类对象 重写：在子类中把父类本身有的方法重写一遍，方法名，参数列表，返回类型都相同，对方法体进行修改或重
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
Java面向对象——多态
weixin_64811434的博客
08-11 701
Java面向对象——多态
JAVA 什么是多态?
程序小白进阶之路
05-16 2万+
面向对象编程有三大特性：封装、继承、多态。 封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。 继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。，同时继承也为实现多态做了铺垫。 那么，什么是多态呢? 1.定义： 多态：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象...
Java —— 多态
最新发布
YeZh1Yong 的博客
11-15 223
Java语法之多态超详解
java 面向对象三大特性之多态 万字详解（超详细）
Cyan_RA9的博客
02-25 2316
Java 面向对象三大特性——多态篇！
Java学习笔记 --- 面向对象之多态
乌云的博客
10-09 401
方法或对象具有多种形态，是面向对象的三大特征，多态是建立在封装和继承之上的。
Java三大特性篇之——多态篇（千字详解）
m0_65038072的博客
04-23 2343
java三大特性中的多态通俗来讲就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态!比如stuendt是一个父类，那么在操场上上体育课的学生和在教室里面的学生就是它的子类。这时上课铃声响了，上体育课的学生去操场，在教室里面上课的学生则是回教室，不同的学生有着不同的反应，这就是多态。
类的多态
weixin_47064622的博客
08-24 908
类的多态多态 多态 多态：⼀个对象具有多种状态的⾏为 1、要有继承 2、要有重写 3、父类的引用指向子类的对象
Java基础（关于多态的理解）
m0_51288996的博客
07-07 225
在编程语言和类型论中，多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。即：在程序中，是先有父类，然后通过继承才有子类；但是在现实世界和实际应用中，是先有的不同子类，再通过父类这个统一的接口去调用他们，或者对同一件事有不同的反应和状态。比如在学校，上课铃响要上课了(lesson()方法)，学生和老师对这件事情做出不同的反应动作——学生的动作是“学”，而老师的动作是“教”。(假设Person类，Student类和Teacher类是他的子类，然后都有lesson()方法，因此构成重写。
024.JAVA面向对象_多态的概念
leon9dragon的博客
04-07 131
<!-- TOC --> <ul> <li><a href="#1-%E5%A4%9A%E6%80%81%E7%9A%84%E6%A6%82%E5%BF%B5%E5%92%8C%E8%A1%A5%E
java三大特性_详解Java三大特性——多态
weixin_39980353的博客
11-22 151
多态是继封装、继承之后，面向对象的第三大特性。现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引...
如何理解python面向对象中三大特征的多态
03-21
多态是面向对象编程中的三大特征之一，它指的是同一个方法可以在不同的对象上有不同的实现。在Python中，多态可以通过继承、接口实现和函数重载来实现。继承是最常见的实现多态的方式，子类可以重写父类的方法，从而...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值