8继承多态

3为什么需要继承，继承的意义是什么
![[Pasted image 20251210212105.png]]
所以想说明什么
![[Pasted image 20251210212458.png]]

```
public class Dog {
public String name;
public int age;
public void eat() {
System.out.println(this.name+"正在吃饭");

}
public void bark(){
System.out.println(this.name+"正在狗叫");
}
}
```

```
public class Cat {
public String name;
public int age;
public void eat(){
System.out.println(this.name+"正在吃饭");
}
public void mimi(){
System.out.println(this.name+"正在猫叫");
}//对于相同的部分（共性）进行抽取
//继承的好处就是可以达到代码的复用
}
```


```
public class Test {
static void main(String[] args) {
Dog d = new Dog();
d.name="dahuang";
d.eat();
d.bark();
System.out.println("=============================");
Cat c = new Cat();
c.name="mimi";
c.eat();
c.mimi();
}
}
```

```
public class Dog(子类) extends Animal(父类)

//子类继承父类，有什么就继承什么
![[Pasted image 20251210213604.png]
```
![[Pasted image 20251210213615.png]]
注意
子类会将父类的成员变量或方法继承到子类
子类要添加点自己特有的成员，不然就没必要继承


**当父类，子类同名的方法，成员变量，都怎么去访问，怎么去区分**
![[Pasted image 20251210224029.png]]
当父类和子类有同名的成员变量的时候，优先访问子类的
要访问父类用super
![[Pasted image 20251210224218.png]]
`System.out.println(super.a);`
只能通过super访问
```
public void func() {
System.out.println(this.a);
System.out.println(this.b);
System.out.println(c);
System.out.println(super.a);

Base base = new Base();
System.out.println(base.b);//这就是从根本

}
```
![[Pasted image 20251210224511.png]]
可以


回顾
```
class Base{
public int a=1;
public int b=2;
}

class Derived extends Base{
int a=11;
int b=22;
public int c=3;
public void test(){
System.out.println(super.a);
System.out.println(this.b);
System.out.println(c);
}

}
public class Test {
public static void main(String[] args) {
Derived derived = new Derived();
derived.test();
}
}
```
当前类用this 或者不用，父类用super
k可以用来访问类的成员或者方法
、![[Pasted image 20260103171520.png]]
![[Pasted image 20260103171625.png]]
![[Pasted image 20260103172021.png]]
![[Pasted image 20260103172221.png]]

```
class Base{
public int a=1;
public int b=2;
public void testa(){
System.out.println("这是父类的方法");
}

}

class Derived extends Base{
int a=11;
int b=22;
public int c=3;

public void testa(){//这和父类的叫重写，就是一模一样
System.out.println("这是子类的方法");
}


public void testa(char a){//这和父类的叫重载，有参数不一样
System.out.println("这是子类的方法");
}

public void test(){
testa();
super.testa();
}

public void test1(){
System.out.println(super.a);
System.out.println(this.b);
System.out.println(c);


}

// public void testb(){
//
// }

}
```
super和this只能在非静态成员使用，因为static的东西不属于对象，归属类，使用不需要super，this这种


关于super()
![[Pasted image 20260103174011.png]]
![[Pasted image 20260103174130.png]]
![[Pasted image 20260103174231.png]]
所以先帮父类进行初始化，即super（），就是调用了父类的构造方法
super（）必须在第一行
this（）也必须在第一行
那么这两个是不能共存的
![[Pasted image 20260103212338.png]]
有即不生成，没有即当能用的
![[Pasted image 20260103214227.png]]
![[Pasted image 20260103214400.png]]
不管实例化多少遍，静态的只执行一次，也就是new对象后这一次执行的就没有static


protected
(不同包当中的子类)

![[Pasted image 20260103222439.png]]

![[Pasted image 20260103224007.png]]
![[Pasted image 20260103224044.png]]
继承方式
![[Pasted image 20260104103826.png]]
不支持多继承，即第三种箭头相反，多层继承最好不要超出三层
#final关键字
用来控制它不改变
专业名称叫密封
![[Pasted image 20260104104157.png]]
可以密封方法，密封类
![[Pasted image 20260104104233.png]]
#组合

![[Pasted image 20260104112209.png]]
![[Pasted image 20260104104313.png]]
学生和老师都是学校的一部分
学生是类，老师也是类，学校也是类(同一个包里)
```
|public class School {|
|||
|||
||public Student[] students = new Student[10];|
|||
||public Teacher[] teachers = new Teacher[10];|
|||
|||

| |
|---|
|public class Student {|
||}|


| |
|---|
|public class Teacher {|
||}|
```


```
// 轮胎类
class Tire{
// ... }


// 发动机类
class Engine{
// ... }


// 车载系统类
class VehicleSystem{
// ... }

class Car{
private Tire tire;
// 可以复用轮胎中的属性和方法
private Engine engine;
// 可以复用发动机中的属性和方法
private VehicleSystem vs;
// 可以复用车载系统中的属性和方法
// ... }



// 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}
```

#多态
理解向上转型和方法的重写
![[Pasted image 20260104105313.png]]
向上转型就是
将子类向上转型到父类，可以
直接赋值
可以通过方法的传参，在形参处
可以通过返回值，接受返回值

![[Pasted image 20260104114551.png]]

父类不能调用子类的方法
![[Pasted image 20260104113901.png]]

但是当方法重写时，可以调用子类的

![[Pasted image 20260104114105.png]]
![[Pasted image 20260104110059.png]]
方法的重写
要求
![[Pasted image 20260104110133.png]]
父类与子类的方法一样，名字，参数列表，返回值，但是内容可以不一样，就是方法的重写
![[Pasted image 20260104110306.png]]
重载


向上转型
直接赋值
方法的传参（用传参演示）
方法的返回值
缺点
只能调用父类自己的方法
```
public class Animal {
public String name;
public int age;

public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(this.name + " is eating");
}
}

public class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
public void bark() {
System.out.println(this.name + " 在汪汪叫");
}

@Override
public void eat() {
System.out.println(this.name + " 正在吃狗粮");
}
}

public class Test {
public static void func(Animal animal){
animal.eat();//向上转型
}

public static void main1(String[] args) {
Dog dog=new Dog("旺财",2);
func(dog);//这就是存在重写时，用的是“旺财正在吃狗粮”
}

static void main(String[] args) {
Animal animal=new Dog("wangcai",3);
animal.eat();//向上转型后可以用这个调用子类的方法“wangcai正在吃狗粮”
}
}
```
![[Pasted image 20260106161146.png]]
程序在编译的时候，调用的是父类的方法
当运行代码的时候，通过父类的引用，调用了父类和子类重写的那个方法，结果实际调用的是子类的方法，这种情况叫“动态绑定”
（大前提：一定是在继承的情况下啊）

注解
注解起到提示作用@Override,注解有很多种

![[Pasted image 20260106162553.png]]
animal引用的对象不一样，但是调用的是同一个方法，此时表象出来的现象不一样，这种思想就叫做多态


重写的注意事项
1. 不能是一个静态方法
2. 不能被final修饰
3. 子类权限要大于等于父类
4. 被private修饰的方法，是不能被重写
5. 构成父子类关系也是重写
![[Pasted image 20260106162944.png]]
```
public class Animal {
public String name;
public int age;

public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public Animal eat() {
System.out.println(this.name + " is eating");
return null;
}
}

public class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
public void bark() {
System.out.println(this.name + " 在汪汪叫");
}

public Dog eat(){
System.out.println(this.name+"正在吃狗粮");
return null;
}
}

```
所以这也是重写
向下转型
，这很危险
向上转型是子类到父类，子类一定属于父类，但父类不一定属于子类，所以需要强转，但强转不一定成功
![[Pasted image 20260106182749.png]]

![[Pasted image 20260106183022.png]]

![[Pasted image 20260106183117.png]]


```
public class Animal {
public String name;
public int age;

public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(this.name + " is eating");
// return null;
}
}


public class Bird extends Animal {
public Bird(String name, int age) {
super(name, age);
}
public void eat(){
System.out.println(this.name+"正在吃鸟粮");
}

public void fly() {
System.out.println(this.name + " is flying");
}
}


public class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
public void bark() {
System.out.println(this.name + " 在汪汪叫");
}

public void eat(){
System.out.println(this.name+"正在吃狗粮");
//return null;
}
}

public class Test {

static void main(String[] args) {
Animal animal=new Bird("菠萝包",1);
Bird bird=(Bird)animal;
bird.fly();//向下转型


Animal animal1=new Dog("小黑",2);
Dog dog=(Dog)animal1;
Bird bird1=(Bird)animal1;
bird1.fly();

}



其实写成分支语句
Animal animal2=new Dog("xiaohuang ",3);
if(animal2 instanceof Bird){
Bird bird2=(Bird)animal2;
bird2.fly();
}else {
Dog dog2=(Dog)animal2;
}

```
![[Pasted image 20260106163236.png]]


理解：当在父类的构造方法中调用子类和父类的重写的方法，会发生动态绑定
![[Pasted image 20260106163702.png]]
![[Pasted image 20260106163910.png]]
![[Pasted image 20260106164002.png]]


![[Pasted image 20260106190300.png]]
![[Pasted image 20260106190810.png]]
```
package demo2;

/**
* Created with IntelliJ IDEA. * Description: * User: suki * Deate: 2026-01-06 * Time:18:57 */

public class Test {

static void main(String[] args) {
Rect rect = new Rect();
Cycle cycle = new Cycle();
Flower flower = new Flower();

Shape[] shapes = {rect,cycle,flower};
for (Shape shape : shapes) {
shape.draw();
}
}



public static void main2(String[] args) {
Rect rect = new Rect();
Cycle cycle = new Cycle();


String[] strings = {"cycle","rect","cycle","rect","triangle"};

for(String s :strings) {
if(s.equals("cycle")) {
cycle.draw();
}else if(s.equals("rect")) {
rect.draw();
}
}
}


public static void drawMap(Shape shape){//向上转型
shape.draw();
}
static void main1(String[] args) {
Rect rect=new Rect();
Cycle cycle=new Cycle();
Flower flower=new Flower();
drawMap(rect);
drawMap(cycle);
drawMap(flower);
}
}
```

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/1160615.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Spring Boot的约定优于配置：智能管家的“隐形”艺术

Spring Boot的约定优于配置：智能管家的“隐形”艺术

文章目录一、什么是约定优于配置？智能管家的设计哲学二、Spring Boot如何实现约定？自动配置的魔法引擎2.1 SpringBootApplication的三层秘密2.2 自动配置的执行流程：Spring Boot的“思考”过程2.3 条件化装配：智能管家的“分寸感”…
阅读更多...
大家一直催更的Agent学习路线来喽！

大家一直催更的Agent学习路线来喽！

大家好！这周出差了两天，稍微有点忙，所以Agent学习路线出得稍微晚了一点，希望这份学习路线能够帮助大家更好地理解和实现Agent技术，在学习和应用中有所收获 Agent的技术原理 1、技术发展路线：API->LLM-&…
阅读更多...
Oracle 19c入门学习教程，从入门到精通，Oracle体系结构 —— 知识点详解(2）

Oracle 19c入门学习教程，从入门到精通，Oracle体系结构 —— 知识点详解(2）

Oracle体系结构 一、需求理解 基于Oracle 19c第2章“Oracle体系结构”的核心内容（涵盖逻辑/物理存储结构、服务器结构、数据字典等），整理一份包含Oracle安装过程、体系结构相关核心语法知识点及使用方法的教程，每个知识点配套带…
阅读更多...
守护能源与数据的安全防线：从UL 2075标准解析储能及数据中心氢探技术的演进

守护能源与数据的安全防线：从UL 2075标准解析储能及数据中心氢探技术的演进

守护能源与数据的安全防线：从UL 2075标准解析储能及数据中心氢探技术的演进一、UL 2075：为高风险场景设立的专业门槛UL 2075标准通过以下核心测试保障设备可靠性： $$ \text{稳定性} f(\text{温度}, \text{湿度}, \text{电压}) $$# 极端环境测…
阅读更多...
C++类型判断

C++类型判断

一、编译期类型判断（静态类型检查）这类判断在编译阶段完成，零运行时开销，主要用于模板编程、类型萃取等场景。1. typeid 运算符（基础）typeid 可以获取类型信息，返回 std::type_info 对象&#x…
阅读更多...
Python 内置 venv 虚拟环境工具完全指南（附 uv 工具无缝升级教程）

Python 内置 venv 虚拟环境工具完全指南（附 uv 工具无缝升级教程）

Python venv 虚拟环境基础操作创建虚拟环境命令格式如下，需指定目标目录路径：python -m venv /path/to/your/env激活虚拟环境的脚本路径因操作系统而异：Windows: \path\to\env\Scripts\activateUnix/macOS: source /path/to/env/bin/activate…
阅读更多...
2026机器视觉同轴光源品牌甄选指南：解锁高精度检测的照明密钥

2026机器视觉同轴光源品牌甄选指南：解锁高精度检测的照明密钥

在智能制造与工业自动化飞速发展的今天，机器视觉系统已成为现代工业的“智慧之眼”。而同轴光源作为这一“眼睛”的核心照明系统，其性能直接决定了视觉检测的精度与可靠性。面对2026年工业检测对精度、效率和稳定性提出的更高要求，选择一款真…
阅读更多...
如何使用`typeid`判断指针或引用所指对象的实际类型？

如何使用`typeid`判断指针或引用所指对象的实际类型？

核心前提：typeid判断实际类型的条件typeid能否识别指针 / 引用指向的实际类型，唯一的关键是：被判断的类是否是多态类（包含至少一个虚函数，通常是虚析构函数）。非多态类：typeid只能识别编译期的声…
阅读更多...
C++ RAII封装结构体成员变量自动加锁性能开销分析

C++ RAII封装结构体成员变量自动加锁性能开销分析

在C中通过RAII（Resource Acquisition Is Initialization）机制封装结构体成员变量的自动加锁/解锁操作，其性能开销需从锁机制成本、编译器优化空间、运行时场景适配三个维度进行系统性分析： 一、RAII加锁封装的核心机制 以典型实现…
阅读更多...
凤希AI提出FXPA2P：下一代点对点AI服务架构-2026年1月14日

凤希AI提出FXPA2P：下一代点对点AI服务架构-2026年1月14日

思考与发现在今日对产品技术细节进行打磨与升级的同时，一个更为宏观和前瞻性的构想逐渐清晰。基于对当前AI应用依赖中心化云服务所暴露的成本、效率与隐私问题的深刻洞察，我们正式提出 FXPA2P 这一商业概念与技术实施模式。FXPA2P，即 FengXi …
阅读更多...
智能指针的生命周期控制

智能指针的生命周期控制

在C中，函数内创建的智能指针通过参数返回时，其生命周期管理遵循资源所有权转移和引用计数的智能指针语义，具体行为取决于智能指针类型（如std::unique_ptr、std::shared_ptr）和传递方式（返回值/输出参数&…
阅读更多...
AI原生应用开发：相似度匹配的模型压缩技巧

AI原生应用开发：相似度匹配的模型压缩技巧

AI原生应用开发：相似度匹配的模型压缩技巧 关键词：相似度匹配、模型压缩、AI原生应用、知识蒸馏、模型量化、参数剪枝、轻量级模型 摘要：在AI原生应用（如智能推荐、跨模态搜索、对话系统语义理解）中，相似度匹配模型是核心组件。但这类模型常因参数量大、计算复杂度高，难…
阅读更多...
6款AI论文降重神器实操教程：AI率从72%降至13%

6款AI论文降重神器实操教程：AI率从72%降至13%

一、AI论文降重工具快速对比：哪款最适合你？ 作为学生或科研人员，你是否曾遇到以下痛点： 用ChatGPT写的论文AI检测率高达70%，被导师打回重写？降重时逐句改写，耗时又容易破坏逻辑？找…
阅读更多...
Python + uiautomator2 手机自动化控制教程

Python + uiautomator2 手机自动化控制教程

安装 uiautomator2 库通过 pip 安装 uiautomator2 库，确保 Python 环境已配置。pip install uiautomator2初始化设备连接使用设备的 IP 地址或序列号连接手机，确保手机已开启 USB 调试模式。import uiautomator2 as u2 d u2.connect("192.168.1.10…
阅读更多...
Python 学生管理系统实战：从基础功能到数据持久化（附完整源码）

Python 学生管理系统实战：从基础功能到数据持久化（附完整源码）

学生管理系统基础功能实现学生管理系统的核心功能包括添加、删除、修改和查询学生信息。使用Python内置数据结构如字典和列表可以快速实现这些基础功能。students []def add_student():name input("输入学生姓名: ")age int(input("输入学生年龄: "))st…
阅读更多...
【Python库和代码案例：第一课】Python 标准库与第三方库实战指南：从日期处理到 Excel 操作

【Python库和代码案例：第一课】Python 标准库与第三方库实战指南：从日期处理到 Excel 操作

Python 标准库实战datetime 模块处理日期from datetime import datetime, timedelta# 获取当前时间 now datetime.now() print(f"当前时间: {now}")# 时间加减操作 next_week now timedelta(days7) print(f"一周后时间: {next_week}")# 时间格式化 form…
阅读更多...
数独优化求解C库tdoku-lib的使用

数独优化求解C库tdoku-lib的使用

tdoku-lib是基于优化求解器tdoku改造的动态库和静态库，它的存储库地址 https://github.com/hackerzhuli/tdoku-lib 1.拉取源代码 rootDESKTOP-59T6U68:/mnt/c/d# git clone https://github.com/hackerzhuli/tdoku-lib.gitCloning into tdoku-lib... remote: Enumer…
阅读更多...
AI原生应用云端推理的故障排查与恢复

AI原生应用云端推理的故障排查与恢复

AI原生应用云端推理的故障排查与恢复：让智能服务“不掉线”的秘密 关键词：AI原生应用、云端推理、故障排查、恢复机制、AIOps 摘要：当你用手机拍照识别植物品种时，当智能客服秒级回复你的问题时，当电商APP精准推荐商品时——这些“丝滑”体验的背后，是AI原生应用在云端高…
阅读更多...
dlx求解数独duckdb插件的编写和使用

dlx求解数独duckdb插件的编写和使用

1.将网上下载的dlx求解c程序添加int sudoku(const char *s,char *r)函数处理81个字符长的数独题目字符串 #include <cstdio> #include <cstring> #include <ctime> int cnt0; const int XSIZE 3; const int SIZE XSIZE * XSIZE; const int MAX_C SIZE *…
阅读更多...
我用 XinServer 做了个文件系统，比想象简单

我用 XinServer 做了个文件系统，比想象简单

我用 XinServer 做了个文件系统&#xff0c;比想象简单 最近有个朋友找我帮忙&#xff0c;说他们团队想做个内部文件管理系统&#xff0c;让不同部门的同事能上传、下载、共享文档&#xff0c;还要有权限控制。他问我&#xff1a;“这个后端大概要搞多久&#xff1f;我们前端倒…
阅读更多...
最新文章

Copyright @ 2022~2023