Java温故而知新-多态性

最新推荐文章于 2024-05-27 15:37:49 发布
最新推荐文章于 2024-05-27 15:37:49 发布
阅读量88 收藏
点赞数
分类专栏： java 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxyoucan/article/details/112298864
版权
java 同时被 2 个专栏收录
148 篇文章 4 订阅
订阅专栏
笔记
107 篇文章 1 订阅
订阅专栏

在面向对象的程序开发过程之中，有三大主要特性：封装性，继承性，多态性
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Object 类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

对象的比较

在这里插入图片描述

有缺陷的比较（一般人的想法）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

示例代码

示例1：

class Person {
	private String name ;
	private String addr ;
	private char sex ;
	private int age ;
	public Person() {}
	public Person(String name, String addr) {
		this(name, addr, '男', 18) ; // 调用四参构造
	}
	public Person(String name, String addr, char sex, int age) {
		this.name = name ;
		this.addr = addr ;
		this.sex = sex ;
		this.age = age ;
	}
	public String toString() {	// 覆写Object类中的方法
		return "姓名：" + this.name + "、地址：" + this.addr + "、性别：" + this.sex + "、年龄：" + this.age ;
	}
}
class Student extends Person {	// 继承可以实现类的代码重用
	private double math ;
	private double english ;
	public Student() {}
	public Student(String name, String addr) {
		super(name, addr) ; // 调用父类中的双参构造
	}
	public Student(String name, String addr, char sex, int age, double math, double english) {
		super(name, addr, sex, age) ;	// super调用父类构造
		this.math = math ;
		this.english = english ;
	}
	public String toString() {
		return super.toString() + "，数学成绩：" + this.math + "、英语成绩：" + this.english ;
	}
}
public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		Person person = new Student("小李", "北京-天安门", '男', 18, 99.8, 99.9) ;// 向上转型
		System.out.println(person) ;
	}
}

示例2：

class Employee { // 员工
	private String name ;
	private String sex ;
	private int age ;
	public Employee() {}
	public Employee(String name, String sex, int age) {
		this.name = name ;
		this.sex = sex ;
		this.age = age ;
	}
	public String toString() {
		return "姓名：" + this.name + "、性别：" + this.sex + "、年龄：" + this.age ;
	}
}
class Manager extends Employee { // 管理层
	private String job ;
	private double income ;
	public Manager() {}
	public Manager(String name, String sex, int age, String job, double income) {
		super(name, sex, age) ;
		this.job = job ;
		this.income = income ;
	}
	public String toString() {
		return super.toString() + "、职位：" + this.job + "、年薪：" + this.income ;
	}
}
class Staff extends Employee {
	private String dept ;
	private double salary ;
	public Staff() {}
	public Staff(String name, String sex, int age, String dept, double salary) {
		super(name, sex, age) ;
		this.dept = dept ;
		this.salary = salary ;
	}
	public String toString() {
		return super.toString() + "、部门：" + this.dept + "、月薪：" + this.salary ;
	}
}
public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		get(new Manager("小李", "男", 20, "部门经理", 60000.0)) ;
		get(new Staff("小张", "女", 19, "后勤部", 90000.0)) ;
	}
	public static void get(Employee emp) {
		System.out.println(emp) ;
	}
}

示例3：面向过程统计字母数量

public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		String str = "want you to know one thing" ; // 给定一个字符串信息
		String result [] = str.split("") ; // 按照每一位进行拆分
		int oCount = 0 ; // 保存字母o的个数
		int nCount = 0 ;  // 保存字母n的个数
		for (String temp : result) {
			if ("o".equalsIgnoreCase(temp)) {
				oCount ++ ;
			}
			if ("n".equalsIgnoreCase(temp)) {
				nCount ++ ;
			}
		}
		System.out.println("字母O的个数：" + oCount + "、字母N的个数：" + nCount) ;
	}
}

示例4:面向对象的方式统计字母数量

class StringUtil { // 定义一个字符串的工具类
	private String content ; // 字符串的内容
	public StringUtil(String content) {
		this.content = content ;
	}
	public void setContent(String content) {
		this.content = content ;
	}
	public String getContent() {
		return this.content ;
	}
}
class CharCount extends StringUtil { // 实现数据统计
	private int oCount ;	// 统计字母o的个数
	private int nCount ;	// 统计字母n的个数
	public CharCount(String content) {
		super(content) ; // 调用父类中的单参构造
		this.handleContent() ; // 构造方法直接进行字符串的处理
	}
	public void handleContent() {	// 处理传入的数据信息
		String result [] = super.getContent().split("") ; // 按照每一位进行拆分
		for (String temp : result) {
			if ("o".equalsIgnoreCase(temp)) {
				this.oCount ++ ;
			}
			if ("n".equalsIgnoreCase(temp)) {
				this.nCount ++ ;
			}
		}
	}
	public String toString() {
		return "【字符统计结果】字母“O”的个数：" + this.oCount + "、字母“N”的个数：" + this.nCount ;
	}
}
public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		String str = "want you to know one thing" ; // 给定一个字符串信息
		StringUtil util = new CharCount(str) ;
		System.out.println(util) ;
	}
}

示例5：数组扩充操作

5、
class Array { // 进行数组的操作
	private int data [] ; // 提供有一个数组类型
	private int index ; // 数据增加索引号
	public Array() {
		this(5) ; // 如果使用的是无参构造，默认设置5个大小
	}
	public Array(int len) {	// 动态决定数组大小
		if (len > 0) {
			this.data = new int[len] ; // 开辟新的数组大小
		} else {
			this.data = new int[1] ; // 保证不出错
		}
	}
	public void increment(int cap) {	// 设置增长容量
		int newData [] = new int [this.data.length + cap] ; // 开辟新的数组
		System.arraycopy(this.data,0, newData,0, this.data.length) ; // 数组拷贝
		this.data = newData ; // 修改指向，产生垃圾
	}
	public boolean add(int data) {	// 实现数据增加
		if (this.index < this.data.length) {	// 此时还有空余位置
			this.data[this.index ++] = data ; // 保存增加数据
			return true ; // 返回true表示增加成功
		}
		return false ;
	}
	public int[] getData() {
		return this.data ;
	}
}
public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		Array arr = new Array() ; // 默认的大小为5个
		System.out.println(arr.add(8)) ;
		System.out.println(arr.add(3)) ;
		System.out.println(arr.add(10)) ;
		System.out.println(arr.add(5)) ;
		System.out.println(arr.add(20)) ;
		arr.increment(3) ; // 扩充3个容量
		System.out.println(arr.add(30)) ;
		System.out.println(arr.add(80)) ;
		System.out.println(arr.add(1)) ;
		printArray(arr) ;
	}
	public static void printArray(Array array) {
		for (int temp : array.getData()) {
			System.out.print(temp + "、") ;
		}
		System.out.println() ;
	}
}

示例数组排序：

class Array { // 进行数组的操作
	private int data [] ; // 提供有一个数组类型
	private int index ; // 数据增加索引号
	public Array() {
		this(5) ; // 如果使用的是无参构造，默认设置5个大小
	}
	public Array(int len) {	// 动态决定数组大小
		if (len > 0) {
			this.data = new int[len] ; // 开辟新的数组大小
		} else {
			this.data = new int[1] ; // 保证不出错
		}
	}
	public void increment(int cap) {	// 设置增长容量
		int newData [] = new int [this.data.length + cap] ; // 开辟新的数组
		System.arraycopy(this.data,0, newData,0, this.data.length) ; // 数组拷贝
		this.data = newData ; // 修改指向，产生垃圾
	}
	public boolean add(int data) {	// 实现数据增加
		if (this.index < this.data.length) {	// 此时还有空余位置
			this.data[this.index ++] = data ; // 保存增加数据
			return true ; // 返回true表示增加成功
		}
		return false ;
	}
	public int[] getData() {
		return this.data ;
	}
}
class SortArray extends Array { // 数组排序的子类
	public SortArray() {}
	public SortArray(int len) {
		super(len) ;
	}
	public int[] getData() {	// 覆写父类方法
		java.util.Arrays.sort(super.getData()) ; // 数组排序
		return super.getData() ;
	}
}
public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		Array arr = new SortArray() ; // 默认的大小为5个
		System.out.println(arr.add(8)) ;
		System.out.println(arr.add(3)) ;
		System.out.println(arr.add(10)) ;
		System.out.println(arr.add(5)) ;
		System.out.println(arr.add(20)) ;
		arr.increment(3) ; // 扩充3个容量
		System.out.println(arr.add(30)) ;
		System.out.println(arr.add(80)) ;
		System.out.println(arr.add(1)) ;
		printArray(arr) ;
	}
	public static void printArray(Array array) {
		for (int temp : array.getData()) {
			System.out.print(temp + "、") ;
		}
		System.out.println() ;
	}
}

示例：数组反转

class Array { // 进行数组的操作
	private int data [] ; // 提供有一个数组类型
	private int index ; // 数据增加索引号
	public Array() {
		this(5) ; // 如果使用的是无参构造，默认设置5个大小
	}
	public Array(int len) {	// 动态决定数组大小
		if (len > 0) {
			this.data = new int[len] ; // 开辟新的数组大小
		} else {
			this.data = new int[1] ; // 保证不出错
		}
	}
	public void increment(int cap) {	// 设置增长容量
		int newData [] = new int [this.data.length + cap] ; // 开辟新的数组
		System.arraycopy(this.data,0, newData,0, this.data.length) ; // 数组拷贝
		this.data = newData ; // 修改指向，产生垃圾
	}
	public boolean add(int data) {	// 实现数据增加
		if (this.index < this.data.length) {	// 此时还有空余位置
			this.data[this.index ++] = data ; // 保存增加数据
			return true ; // 返回true表示增加成功
		}
		return false ;
	}
	public int[] getData() {
		return this.data ;
	}
}
class SortArray extends Array { // 数组排序的子类
	public SortArray() {}
	public SortArray(int len) {
		super(len) ;
	}
	public int[] getData() {	// 覆写父类方法
		java.util.Arrays.sort(super.getData()) ; // 数组排序
		return super.getData() ;
	}
}
class ReverseArray extends Array {	// 数组反转
	public ReverseArray() {}
	public ReverseArray(int len) {
		super(len) ;
	}
	public int[] getData() {	// 覆写父类方法
		int center = super.getData().length / 2 ; // 确定反转次数
		int head = 0 ; 
		int tail = super.getData().length - 1 ;
		for (int x = 0 ; x < center; x ++) {
			int temp = super.getData()[head] ;
			super.getData()[head] = super.getData()[tail] ;
			super.getData()[tail] = temp ;
			head ++ ;
			tail -- ;
		}
		return super.getData() ;
	}
}
public class YootkDemo { // 李兴华编程训练营：yootk.ke.qq.com
	public static void main(String args[]) {
		Array arr = new ReverseArray() ; // 默认的大小为5个
		System.out.println(arr.add(8)) ;
		System.out.println(arr.add(3)) ;
		System.out.println(arr.add(10)) ;
		System.out.println(arr.add(5)) ;
		System.out.println(arr.add(20)) ;
		arr.increment(3) ; // 扩充3个容量
		System.out.println(arr.add(30)) ;
		System.out.println(arr.add(80)) ;
		System.out.println(arr.add(1)) ;
		printArray(arr) ;
	}
	public static void printArray(Array array) {
		for (int temp : array.getData()) {
			System.out.print(temp + "、") ;
		}
		System.out.println() ;
	}
}

教程来源

https://www.bilibili.com/video/BV1PE41187Vd?p=125

ITKEY_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Task01】Numpy学习打卡
Xiao_Spring的博客
10-20 1407
注：为了节约行数，默认import numpy as np已经写在每段代码前，不再重复写入，如果有新的包引入，会在代码头部import 一、常量 前言： NumPy包括几个常量： np.inf、np.NINF、np.PZERO & np.NZERO、np.nan、np.e、np.pi、np.euler_gamma、np.newaxis 1、正无穷大 numpy中正无穷大一共有五种表现形式：Inf = inf = infty = Infinity = PINF NumPy 使用IEEE二进制浮点算法
【Numpy学习01】常数
Xiao_Spring的博客
10-19 1273
文章目录：前言：1、正无穷大【例1】判断Inf 、inf 、infty、Infinity、PINF的关系2、负无穷大【例2】打印负无穷大3、正负零【例3】打印正负零4、非数值【例4-1】判断两个非数值是否相等【例4-2】判断nan、NaN、NAN的关系【例4-3】计算ndarray中非数值常量（nan）的数量5、自然数e【例5-1】打印自然数e【例5-2】判断numpy中自然数e的有效位数6、圆周率π【例6】打印圆周率π7、伽马常数γ【例7】伽马常数γ8、None（newaxis）【例8-1】判断None和
利用Python进行数据分析学习笔记五：数据加载、存储与文件格式
Mxeron的博客
01-20 844
访问数据是使⽤本书所介绍的这些⼯具的第⼀步。我会着重介绍pandas的数据输⼊与输出，虽然别的库中也有不少以此为⽬的的⼯具。 输⼊输出通常可以划分为⼏个⼤类：读取⽂本⽂件和其他更⾼效的磁盘存储格式，加载数据库中的数据，利⽤Web API操作⽹络资源。 一、读写文本格式的数据 pandas提供了⼀些⽤于将表格型数据读取为DataFrame对象的函数。表6-1对它们进⾏了总结，其中read_csv和read_table可能会是你今后⽤得最多的。 我将⼤致介绍⼀下这些函数在将⽂本数据转换为DataFrame时所
numpy的基本常量
weixin_42184315的博客
10-03 840
numpy的基本常量
NumPy numpy.inf and numpy.infty
既然选择了远方 便只顾风雨兼程 - 永强
06-25 2876
NumPy numpy.inf and numpy.infty
微信小程序页面布局方式flexbox -温故而知新
03-29
微信小程序使用flexbox容器，flexbox布局由伸缩容器和伸缩项目组成。任何一个元素都可以指定为flexbox布局，其中设为display:flex或者display:inline-flex的元素称为伸缩容器。伸缩容器的子元素称为伸缩项目，伸缩...
【温故而知新】Document对象.md
最新发布
06-13
【温故而知新】Document对象
javase集合 温故而知新.doc
07-09
javase集合 温故而知新 javase集合是Java语言中的一种数据结构，用于存储和操作数据。集合可以分为两大接口：Collection和Map。Collection接口的实现类有List、Set和Queue等，而Map接口的实现类有HashMap、TreeMap...
【温故而知新】HTML5 WebSocket.md
06-13
【温故而知新】HTML5 WebSocket
【温故而知新】JavaScript数据类型.md
06-13
【温故而知新】JavaScript数据类型
es python search 返回_python中的Elasticsearch操作
weixin_39871562的博客
12-20 341
导入包from elasticsearch import Elasticsearch本地连接es = Elasticsearch(['127.0.0.1:9200'])创建索引es.indices.create(index="python_es01",ignore=400)ingore=400 ingore是忽略的意思，400是未找到删除索引es.indices.delete(index="pyt...
Spark中无穷大值Infinity替换
硅谷工具人
07-23 952
在pyspark中计算结果写入iceberg中时，遇到无穷大值infinity，前端无法展示，则需要替换。
关于numpy的nan值处理
qq_44971458的博客
09-18 1万+
numpy的nan值处理没有一个可以直接调用的方法，我们可以自己编写相应的函数，通过调用函数把nan值填充为均值、中位数、众数等等 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择......
python列表统计NAN个数【numpy】
Never Give Up
05-27 289
这段代码首先将列表转换为 NumPy 数组，这是使用 NumPy 处理数据的基础。然后，使用 == 运算符来比较数组中的每个元素是否等于 ‘apple’。这将生成一个布尔数组，其中 True 表示元素是 ‘apple’。最后，使用 np.sum() 函数计算布尔数组中 True 的数量，即为 ‘apple’ 出现的次数。数据类似这样，共有三列。
判断numpy 中 infinite 和NAN的问题
weixin_39673686的博客
02-17 3345
在numpy中由于numpy太强大了，经常会计算出一些不合法的结果，若不注意放入model中训练。就会报错 今天教大家一个测试数据是否合法的函数 np.isnan(y) 上面的y是一个数 ，return返回值为TrueFalse np.isnan(vec).any() np.isnan(vec).all() 上面的vec是一个nparray，可以判断数组中的任意元素是否合法，特...
机器学习：多项式回归（Python）
2302_78896863的博客
01-29 723
【代码】机器学习：多项式回归（Python）
ES查询原理和timeout讲解
Xlucas的博客
11-05 8569
ES的查询过程 1、客户端发送请求到任意一个node，成为coordinate node 2、coordinate node对document进行路由，将请求转发到对应的node(primary或者replicanode上)上，此时使用round-robin随机轮询算法，在primary shard以及其所有的replica中随机选择一个，让读请求负载均衡 3、接收请求的node返回documen...
Elasticsearch: Python 客户端现在支持异步 I/O
Elastic 中国社区官方博客
12-21 3458
随着支持异步 I/O 的 Python Web 框架（如 FastAPI、Starlette 以及即将在 Django 3.1 中出现）的日益流行，Python Elasticsearch 客户端对原生异步 I/O 支持的需求不断增长。 异步 I/O 令人兴奋，因为与传统的多线程应用程序相比， 你的应用程序可以更有效地使用系统资源，从而在 I/O 密集型工作负载（例如为 Web 应用程序提供服务时）带来更好的性能。 从 Elastic Stack 7.8 版开始提供原生 async/await 支持，同时
Python-ElasticSearch搜索
热门推荐
奔跑的豆子的专栏
08-03 2万+
Elasticsearch 是一个开源的搜索引擎，建立在一个全文搜索引擎库 Apache Lucene™ 基础之上。 Lucene 可能是目前存在的，不论开源还是私有的，拥有最先进，高性能和全功能搜索引擎功能的库。但是 Lucene 仅仅只是一个库。为了利用它，你需要编写 Java 程序，并在你的 java 程序里面直接集成 Lucene 包。 更坏的情况是，你需要对信息检索有一定程度的理解才能明白
用英文对话的方式回答下列三个问题：1.大学生如何理解温故而知新，2.学生如何更好地去复习，3.温故而知新的过程需要注意什么
08-16
大学生理解温故而知新意味着要在学习新知识之前，先回顾和复习以前学过的相关知识或基础知识。通过温故，我们能够加深对已有知识的理解和记忆，从而更好地理解和掌握新的知识。 2. 学生如何更好地去复习？ 学生要更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值