你需要更新的Java知识（面试必看、全网最全、持续更新）
一、java基础
1、JDK版本相关（新特性、是否长期支持、选择建议等）
新特性
- JDK8
- Stream API：提供了过滤、映射、排序等功能，让集合操作更简便。
- 接口默认方法和静态方法：增强了接口的灵活性，允许在接口中定义默认方法和静态方法。
- JDK17
- 密封类和接口：通过
sealed、permits关键字限制类的继承或接口的实现，提高代码安全性和可维护性。 - 模式匹配（instanceof）：在
instanceof运算符中可直接进行类型转换和赋值，简化代码逻辑。
- 密封类和接口：通过
- JDK21
- 虚拟线程：轻量级线程，由JVM调度，可显著提升并发性能，减少线程上下文切换开销。
- Record模式和模式匹配增强：进一步增强模式匹配功能，支持在记录类上进行模式匹配。
- JDK24
- 核心Java库：包括为限制JNI的使用做准备、类文件API、流收集器、作用域值（第四次预览）、向量API（第九次孵化）等。
- Java语言规范：有模式、
instanceof和switch中的原始类型（第二次预览）、灵活的构造函数体（第三次预览）、模块导入声明（第二次预览）等。 - 安全库：包含密钥派生函数API（预览）、永久禁用安全管理器、基于模块格的抗量子密钥封装机制等。
- HotSpot：分代Shenandoah（实验性）、紧凑对象头（实验性）、G1的后期屏障扩展、提前类加载和链接等。
- Java工具：不使用JMODs链接运行时镜像。
- JDK25：根据现有信息推测，可能会敲定JEP 495“简单源文件和实例主方法（第四次预览）”特性。
长期支持情况
- JDK8：于2014年3月发布，是长期支持版本，长期支持（LTS）截止日期为2030年12月。
- JDK17：发布于2021年9月，属于LTS版本，Oracle支持至2024年9月，OpenJDK社区支持到2029年9月。
- JDK21：在2023年9月发布，是最新的LTS版本，Oracle支持到2026年9月，OpenJDK社区支持到2031年9月。
- JDK24：是自JDK21以来的第三个非长期支持版本，无长期支持计划。
- JDK25：计划2025年9月发布，目前无法确定是否为LTS版本及相关支持情况。
版本选择建议
- 稳定性优先：如果项目对稳定性要求极高，不希望频繁更新和出现兼容性问题，JDK8是一个可靠的选择，其有长期的使用历史和广泛的社区支持。对于新的长期支持项目，JDK17或JDK21是更好的选择，它们经过了一定时间的验证，稳定性有保障。
- 性能需求高：若项目需要处理高并发场景，JDK21的虚拟线程特性可以极大地提高并发性能；如果注重垃圾回收性能和低延迟，JDK17及以上版本引入的新垃圾回收器如Shenandoah GC等可能更合适。
- 追求新特性和技术：开发者想使用最新的Java语言特性和技术，且能接受可能存在的不稳定性和兼容性问题，JDK24可以尝试，但要做好应对问题的准备。
- 考虑生态系统和兼容性：若项目依赖的第三方库或框架对JDK版本有特定要求，需根据实际情况选择。比如某些老的框架可能只支持到JDK8或JDK11，那么升级到更高版本可能会有兼容性问题。
2、java语言特点，与c/ c++、python、go语言等的对比
Java是一种广泛使用的高级编程语言，与C/C++、Python、Go相比，它具有独特的特点，以下是详细对比：
Java语言特点
- 面向对象：Java是纯粹的面向对象编程语言，一切皆对象，支持封装、继承和多态。这使得代码具有更好的可维护性、可扩展性和可复用性。例如，通过继承可以创建具有层次结构的类，多态允许不同对象对同一消息做出不同响应。
- 跨平台性：Java程序通过Java虚拟机（JVM）实现跨平台运行。一次编写，到处运行，只需在不同的操作系统上安装对应的JVM，Java程序就能在该系统上执行。
- 自动内存管理：Java有自动垃圾回收机制（GC），它会自动回收不再使用的对象所占用的内存，减少了程序员手动管理内存的负担，也降低了内存泄漏和悬空指针等问题的发生概率。
- 安全性：Java提供了丰富的安全机制，如字节码校验、类加载机制、安全管理器等。这些机制可以有效防止恶意代码的攻击，保证程序在安全的环境中运行。
- 多线程支持：Java内置了对多线程编程的支持，通过
Thread类和Runnable接口可以方便地创建和管理线程。多线程可以提高程序的并发性能，充分利用多核处理器的资源。 - 丰富的类库：Java拥有庞大的标准类库，涵盖了网络编程、数据库访问、图形界面开发等各个领域，为开发者提供了丰富的工具和功能，大大提高了开发效率。
Java与C/C++对比
- 内存管理：C/C++需要程序员手动管理内存，使用
malloc、free（C）或new、delete（C++）来分配和释放内存。而Java有自动垃圾回收机制，程序员无需关心内存的释放，减少了内存管理的复杂性和出错概率。 - 跨平台性：C/C++代码需要针对不同的操作系统和硬件平台进行编译，生成特定平台的可执行文件。而Java程序通过JVM实现跨平台，只需编译一次，就可以在不同的JVM上运行。
- 安全性：C/C++由于指针的使用，容易出现内存泄漏、缓冲区溢出等安全问题。Java取消了指针的概念，通过安全机制保证程序的安全性。
- 性能：C/C++是编译型语言，直接生成机器码，执行效率高，适合对性能要求极高的系统开发，如操作系统、游戏引擎等。Java程序需要经过JVM解释执行或即时编译（JIT），性能相对较低，但随着JVM技术的不断发展，Java的性能也在不断提高。
Java与Python对比
- 执行效率：Python是解释型语言，执行速度相对较慢。Java是编译型语言，经过JIT编译后执行效率较高。对于对性能要求较高的计算密集型任务，Java更具优势。
- 语法复杂度：Python语法简洁、灵活，代码可读性高，开发效率高，适合快速开发和脚本编写。Java语法相对严格，代码结构更加规范，适合大型项目的开发和维护。
- 类型系统：Python是动态类型语言，变量类型在运行时确定，代码编写更加灵活，但也容易出现类型相关的错误。Java是静态类型语言，变量类型在编译时确定，编译器可以提前发现类型错误，提高代码的健壮性。
- 应用场景：Python在数据科学、机器学习、人工智能、脚本编写等领域应用广泛，有丰富的第三方库支持。Java在企业级应用开发、Android开发、大型系统开发等领域占据主导地位。
Java与Go对比
- 并发模型：Java通过线程和锁机制实现并发编程，线程的创建和销毁开销较大。Go语言采用了轻量级的协程（goroutine）和通道（channel）机制，并发性能更高，资源消耗更少，更适合高并发场景的开发。
- 语法复杂度：Go语言语法简洁，学习曲线较平缓，代码风格统一。Java语法相对复杂，有较多的关键字和语法规则。
- 编译速度：Go语言的编译速度非常快，能够快速生成可执行文件，提高开发效率。Java的编译过程相对较慢，尤其是在大型项目中。
- 应用场景：Go语言在网络编程、云计算、分布式系统等领域应用广泛，如Docker、Kubernetes等都是用Go语言开发的。Java在企业级应用开发、Android开发等领域有着深厚的积累和广泛的应用。
3、Java SE和Java EE
Java SE（Java Standard Edition）和 Java EE（Java Enterprise Edition，现更名为 Jakarta EE）是 Java 技术体系中两个重要的版本，它们在定位、功能、应用场景等方面存在明显差异，以下为你详细介绍：
Java SE
定义与定位
Java SE 是 Java 技术的基础版本，也被称为标准版。它为 Java 平台提供了核心的类库、开发工具和运行环境，是 Java 技术的基石，为 Java EE 和 Java ME（Java Micro Edition）提供基础支持。
主要功能与特性
- 核心类库：包含了用于字符串处理、集合框架、输入输出操作、多线程编程、网络编程等基础功能的类和接口。例如，
java.util包中的ArrayList、HashMap等集合类，java.io包中的FileInputStream、FileOutputStream等用于文件操作的类。 - 开发工具：提供了一系列开发工具，如
javac（编译器）、java（解释器）、javadoc（文档生成器）等，方便开发者进行代码编写、编译、运行和文档生成。 - 跨平台性：通过 Java 虚拟机（JVM）实现了“一次编写，到处运行”的特性，使得 Java 程序可以在不同的操作系统上运行，只要该操作系统安装了对应的 JVM。
- 面向对象编程：支持面向对象编程的四大特性——封装、继承、多态和抽象，使得代码具有更好的可维护性、可扩展性和可复用性。
应用场景
Java SE 主要用于开发桌面应用程序、命令行工具、小型系统等。例如，使用 Java SE 开发一个简单的文本编辑器、计算器程序等。
Java EE
定义与定位
Java EE 是 Java 技术的企业版，它是在 Java SE 的基础上构建的，提供了一系列用于开发企业级应用的 API 和规范，旨在帮助开发者更高效地构建大规模、分布式、高并发的企业应用系统。
主要功能与特性
- 企业级服务：提供了多种企业级服务，如事务管理、安全管理、分布式对象通信、消息传递等。例如，通过 Java Transaction API（JTA）实现分布式事务管理，确保数据的一致性；使用 Java Authentication and Authorization Service（JAAS）实现用户认证和授权。
- 组件化开发：支持基于组件的开发模式，如 Servlet、JSP（JavaServer Pages）、EJB（Enterprise JavaBeans）等。开发者可以将不同的功能封装成组件，然后通过配置和组装这些组件来构建复杂的应用系统。
- 分布式计算：支持分布式系统的开发，通过 RMI（Remote Method Invocation）、CORBA（Common Object Request Broker Architecture）等技术实现不同计算机之间的远程方法调用和对象通信。
- Web 开发支持：提供了强大的 Web 开发框架和工具，如 Servlet 和 JSP 用于开发动态 Web 页面，JavaServer Faces（JSF）用于构建交互式 Web 应用程序。
应用场景
Java EE 主要用于开发企业级应用，如企业资源规划（ERP）系统、客户关系管理（CRM）系统、电子商务平台等。这些应用通常需要处理大量的数据、高并发的用户请求和复杂的业务逻辑。
4、JVM介绍
什么是 JVM
Java 虚拟机（Java Virtual Machine，JVM）是一种能够运行 Java 字节码的虚拟机。它是 Java 平台的核心组件，为 Java 程序提供了一个独立于底层操作系统和硬件的运行环境。通过 JVM，Java 程序实现了“一次编译，随处运行”的特性，即开发人员只需将 Java 源代码编译成字节码，该字节码就可以在任何安装了对应 JVM 的系统上运行，而无需针对不同的操作系统和硬件进行重新编译。
JVM 的作用
- 跨平台运行：JVM 是 Java 跨平台的关键。不同的操作系统（如 Windows、Linux、macOS）都有对应的 JVM 实现。这些实现会将相同的 Java 字节码进行解析和执行，并给出相同的结果，使得 Java 程序可以在各种系统上保持一致的运行效果。
- 内存管理：JVM 负责管理 Java 程序的内存分配和回收。它将内存划分为不同的区域，如堆、栈、方法区等。其中，堆用于存储对象实例，栈用于存储局部变量和方法调用信息，方法区用于存储类的元数据等。同时，JVM 还提供了垃圾回收机制，自动回收不再使用的内存，减轻了程序员手动管理内存的负担。
- 字节码执行：JVM 对编译后的 Java 字节码进行解释和执行。它将字节码转换为具体的机器指令，从而实现 Java 程序的运行。此外，一些 JVM 还采用了即时编译（JIT）技术，将热点代码（频繁执行的代码）编译成机器码，以提高程序的执行效率。
JVM 的实现
JVM 并不是只有一种，只要满足 JVM 规范，每个公司、组织或者个人都可以开发自己的专属 JVM。以下是一些常见的 JVM 实现：
- HotSpot VM：这是最常用的 JVM 实现，由 Sun Microsystems 开发，后被 Oracle 收购。它具有高效的垃圾回收机制和即时编译技术，广泛应用于各种 Java 应用场景。
- J9 VM：由 IBM 开发，具有良好的性能和稳定性，尤其在企业级应用和嵌入式系统中得到了广泛应用。
- Zing VM：由 Azul Systems 公司开发，以其低延迟的垃圾回收机制而闻名，适用于对响应时间要求极高的应用场景。
- JRockit VM：由 BEA 公司开发，后被 Oracle 收购。它具有出色的性能和实时性，在金融、电信等领域有广泛应用。
JVM 规范
JVM 规范定义了 JVM 的体系结构、字节码格式、内存管理、垃圾回收等方面的标准和规则。各个版本的 JDK 都有对应的 JVM 规范，开发人员可以在 Java SE Specifications 上找到相关信息。遵循 JVM 规范的 JVM 实现可以确保 Java 程序的兼容性和可移植性。
5、JDK vs JRE
JDK（Java Development Kit）
定义与功能
JDK 是功能齐全的 Java SDK（软件开发工具包），专门提供给开发者使用，是用于创建和编译 Java 程序的开发套件。它不仅包含了运行 Java 程序所必需的环境，还配备了一系列开发和调试工具，让开发者能够高效地进行 Java 应用程序的开发工作。
包含内容
- JRE：JDK 包含了 JRE，这确保了在开发过程中可以直接运行编写好的 Java 程序。
- 编译器：其中的
javac编译器是核心工具之一，它可以将 Java 源代码（.java文件）编译成字节码文件（.class文件），使得 Java 程序能够在 JVM 上运行。 - 其他工具：
javadoc：文档注释工具，能够根据 Java 源代码中的注释生成详细的 API 文档，方便开发者之间的交流和代码的维护。jdb：调试器，用于在程序运行过程中查找和解决问题，帮助开发者定位代码中的错误。jconsole：基于 JMX（Java Management Extensions）的可视化监控工具，可用于监控 Java 应用程序的性能和资源使用情况。javap：反编译工具，能够将字节码文件反编译成可读的 Java 代码，有助于开发者理解字节码的结构和程序的执行逻辑。
应用场景
如果需要进行 Java 编程工作，比如编写和编译 Java 程序、使用 Java API 文档等，就必须安装 JDK。对于一些需要使用 Java 特性的应用程序，如将 JSP 转换为 Java Servlet、使用反射等，也需要 JDK 来编译和运行 Java 代码。所以，即使不打算进行大规模的 Java 应用程序开发工作，在某些特定场景下也可能需要安装 JDK。
JRE（Java Runtime Environment）
定义与功能
JRE 是 Java 运行时环境，是运行已编译 Java 程序所需的所有内容的集合。它为 Java 程序提供了运行的基础环境，确保 Java 程序能够在各种操作系统上正常执行。
包含内容
- Java 虚拟机（JVM）：JVM 是 JRE 的核心组件，负责解释和执行 Java 字节码。不同的操作系统有对应的 JVM 实现，保证了 Java 程序的跨平台特性。
- Java 基础类库（Class Library）：提供了 Java 程序运行所需的各种类和接口，涵盖了字符串处理、集合框架、输入输出操作等基础功能，是 Java 程序开发和运行的重要支撑。
应用场景
如果只是需要运行已经开发好的 Java 程序，而不需要进行开发工作，那么只需要安装 JRE 即可。例如，普通用户在运行 Java 编写的游戏、工具软件时，系统中安装 JRE 就能保证程序正常运行。
JDK 9 及以后版本的变化
从 JDK 9 开始，JDK 和 JRE 的关系发生了变化。引入了模块系统，JDK 被重新组织成 94 个模块，同时推出了 jlink 工具（随 Java 9 一起发布的新命令行工具）。
- 模块系统：将 JDK 按照功能划分为多个模块，使得 Java 应用的结构更加清晰，依赖管理更加方便。
- jlink 工具：Java 应用可以通过
jlink工具创建出只包含所依赖的 JDK 模块的自定义运行时镜像。这样做的好处是可以极大地减少 Java 运行时环境的大小，有助于简化 Java 应用的部署，节省内存，同时增强安全性和可维护性，以满足现代应用程序架构（如虚拟化、容器化、微服务和云原生开发）的需求。从 JDK 11 开始，Oracle 不再提供单独的 JRE 下载。
二、java基本数据类型
Java数据类型介绍
Java是一种强类型语言，所有变量必须显式声明数据类型。数据类型决定了变量的内存大小、取值范围及操作方式。Java数据类型分为两大类：基本数据类型和引用数据类型。以下是 8种基本数据类型 的详细介绍：
-
字节型 (byte)
- 占用内存少，适合处理二进制数据或节省内存。
- 示例：文件读写、网络传输中的字节流。
-
短整型 (short)
- 内存占用介于byte和int之间，适用于较小整数场景。
- 示例：计数器、小范围数值计算。
-
整型 (int)
- 最常用的整数类型，性能优于long。
- 示例：循环控制、数学运算。
-
长整型 (long)
- 表示极大整数，需在字面量后加
L或l。 - 示例：时间戳、大范围计数。
- 表示极大整数，需在字面量后加
-
单精度浮点型 (float)
- 节省内存但精度较低，需在字面量后加
F或f。 - 示例：简单科学计算、图形处理。
- 节省内存但精度较低，需在字面量后加
-
双精度浮点型 (double)
- 默认浮点类型，精度高，适用于复杂计算。
- 示例：财务计算、物理仿真。
-
字符型 (char)
- 表示单个Unicode字符，用单引号定义。
- 示例：字符处理、文本解析。
-
布尔型 (boolean)
- 仅表示逻辑值
true或false。 - 示例：条件判断、开关标志。
- 仅表示逻辑值
用列表展示如下 ：
| 类型名称 | 关键字 | 占用内存 | 取值范围 | 默认值 |
|---|---|---|---|---|
| 字节型 | byte |
1 字节 | -128 ~ 127 | 0 |
| 短整型 | short |
2 字节 | -32,768 ~ 32,767 | 0 |
| 整型 | int |
4 字节 | -2,147,483,648 ~ 2,147,483,647 | 0 |
| 长整型 | long |
8 字节 | -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 | 0L |
| 单精度浮点型 | float |
4 字节 | ±3.403E38 | 0.0F |
| 双精度浮点型 | double |
8 字节 | ±1.798E308 | 0.0D |
| 字符型 | char |
2 字节 | Unicode字符（如 'a', '家'） |
'\u0000' |
| 布尔型 | boolean |
1 字节 | true 或 false |
false |
注意事项
- 引用数据类型（如
String、数组、对象）存储在堆内存中，默认值为null。 - 浮点型存在精度丢失问题，需谨慎用于精确计算（建议用
BigDecimal）。 char类型使用Unicode编码，支持国际字符集。
三、静态常量 vs 实例常量 vs 局部常量
作用域
- **静态常量**：静态常量使用`static final`修饰，其作用域为整个类。无论在类的哪个方法、代码块中，都可以直接通过类名来访问静态常量。例如：
public class Constants {
public static final int MAX_VALUE = 100;
}
// 在其他类中访问
public class Main {
public static void main(String[] args) {
int value = Constants.MAX_VALUE;
}
}
- **实例常量**：实例常量使用`final`修饰但没有`static`关键字，它的作用域为类的实例对象。只能通过类的实例来访问实例常量，不同的实例对象各自拥有独立的实例常量副本。例如：
public class Circle {
private final double pi = 3.14159;
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double calculateArea() {
return pi * radius * radius;
}
}
- **局部常量**：局部常量在方法或代码块内部声明，使用`final`修饰，其作用域仅限于声明它的方法或代码块。一旦超出这个范围，该局部常量就无法被访问。例如：
public class LocalConstantExample {
public void method() {
final int localVar = 10;
// 以下代码在该方法内可以使用localVar
System.out.println(localVar);
}
// 这里无法访问localVar
}
生命周期
- **静态常量**：随着类的加载而创建，在整个程序运行期间都存在，只要类被加载到内存中，静态常量就会一直存在，直到程序结束或类被卸载。
- **实例常量**：在创建类的实例对象时被创建，其生命周期与所属的实例对象相同。当实例对象被垃圾回收机制回收时，实例常量也随之消失。
- **局部常量**：在程序执行到声明局部常量的代码块时被创建，当代码块执行结束后，局部常量就超出了作用域，其生命周期结束。它的生命周期与所在的代码块的执行周期一致。
四、&& vs &
在Java中，&&和&都属于逻辑与运算符，但它们存在显著区别：
短路特性
- **`&&`（短路与）**：具有短路特性。当使用`&&`进行逻辑运算时，从左到右依次计算操作数。一旦发现某个操作数为`false`，则整个表达式立即被判定为`false`，不再计算后续的操作数。例如：
int a = 5;
int b = 3;
if (a > 10 && (b++ > 2)) {
// 这里由于a > 10为false，b++ > 2不会被执行
}
System.out.println(b); // 输出仍为3
- **`&`（非短路与）**：不具备短路特性。无论`&`左边的操作数是`true`还是`false`，都会计算右边的操作数。例如：
int c = 5;
int d = 3;
if (c > 10 & (d++ > 2)) {
// 这里即便c > 10为false，d++ > 2也会被执行
}
System.out.println(d); // 输出为4
应用场景选择
- **`&&`的使用场景**：当希望在逻辑判断中利用短路特性来提高效率时，优先选择`&&`。比如在进行复杂的条件判断时，如果前面的条件已经能确定整个表达式的结果为`false`，那么后续可能耗时或有副作用的操作就无需执行了。例如在检查一个对象是否为空，再访问其属性时：
if (obj!= null && obj.getProperty() > 10) {
// 只有obj不为空时，才会去调用getProperty方法
}
- **`&`的使用场景**：当需要确保所有操作数都被计算时，使用`&`。例如在进行位运算（`&`也可用于位运算）或需要强制计算所有条件的逻辑与场景中。在一些测试代码中，可能需要确保每个条件都被执行来验证某些逻辑，此时就适合用`&`。另外，在处理布尔数组或集合时，如果希望对每个元素都进行与运算而不考虑短路，也可使用`&`。例如：
boolean[] boolArray = {true, false, true};
boolean result = true;
for (boolean bool : boolArray) {
result &= bool;
// 这里使用&确保每个元素都参与运算
}
五、面向对象编程三大特性
面向对象编程（OOP）的三大特性为封装、继承和多态，它们是OOP的核心概念，相互协作构建出强大且灵活的软件系统：
封装
- **概念**：将数据（属性）和操作数据的方法绑定在一起，隐藏对象的内部实现细节，仅对外提供公共的访问接口。通过封装，对象的内部状态被保护起来，外部代码只能通过特定接口来访问和修改数据。
- **实现方式**：在Java中，使用访问修饰符（`public`、`private`、`protected`以及默认修饰符）来控制类成员的可见性。例如，将类的属性声明为`private`，通过公有的`getter`和`setter`方法来访问和修改属性值。
class BankAccount {
private double balance;
// Getter方法获取余额
public double getBalance() {
return balance;
}
// Setter方法设置余额
public void setBalance(double amount) {
if (amount >= 0) {
this.balance = amount;
} else {
System.out.println("金额不能为负数");
}
}
}
- **优势**：提高了代码的安全性，防止外部非法访问和修改对象内部数据；增强了代码的可维护性，因为内部实现细节的改变不会影响到外部调用代码；降低了代码耦合度，使对象之间的依赖关系更清晰。
继承
- **概念**：一个类（子类）可以继承另一个类（父类）的属性和方法，从而实现代码复用与功能扩展。子类继承父类的非私有成员，并可根据自身需求重写父类方法。
- **实现方式**：在Java中，使用`extends`关键字实现继承。例如，`Animal`类为父类，`Dog`类继承自`Animal`类。
class Animal {
public void eat() {
System.out.println("动物进食");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("狗叫");
}
}
- **优势**：减少代码重复，提高开发效率；通过建立类的层次结构，使程序结构更清晰，便于理解和维护；符合现实世界的分类和层次概念，如动物类下有狗、猫等子类。
多态
- **概念**：同一个方法调用在不同对象上会产生不同的行为。多态有两种实现形式：方法重载和方法重写。
- **方法重载**：在同一个类中，定义多个同名方法，但方法的参数列表（参数个数、类型、顺序）不同。编译器根据调用时传入的参数来决定调用哪个方法，这是编译时多态。例如：
class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
- **方法重写**：子类重新实现父类中已有的方法，要求方法名、参数列表和返回类型与父类方法一致（返回类型可以是父类返回类型的子类型，在Java 5.0及以上版本支持）。在运行时，根据对象的实际类型来决定调用哪个版本的方法，这是运行时多态。例如：
class Shape {
public void draw() {
System.out.println("绘制形状");
}
}
class Circle extends Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
class Rectangle extends Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}
- 优势：增加程序的灵活性和扩展性，使程序能够根据不同对象类型执行不同操作。在图形绘制系统中，通过多态可以方便地添加新的图形类型，而无需修改主程序中绘制图形的核心逻辑。
六、访问修饰符
在 Java 中，访问修饰符用于控制类、方法、变量等的访问权限。Java 提供了四种访问修饰符，按照访问权限从大到小依次为：public、protected、默认（无修饰符）和 private。以下是对这四种访问修饰符的详细介绍：
1. public
- 访问权限：具有最高的访问权限，被
public修饰的类、方法、变量可以在任何地方被访问，包括不同包中的类。 - 使用场景：通常用于定义公共的 API，使得其他类可以自由地使用这些公共的类、方法或变量。
示例代码：
// 定义一个公共类
public class PublicClass {
// 定义一个公共变量
public int publicVariable = 10;
// 定义一个公共方法
public void publicMethod() {
System.out.println("This is a public method.");
}
}
// 在另一个类中访问 PublicClass 的公共成员
public class AnotherClass {
public static void main(String[] args) {
PublicClass publicClass = new PublicClass();
// 访问公共变量
System.out.println(publicClass.publicVariable);
// 调用公共方法
publicClass.publicMethod();
}
}
2. protected
- 访问权限：被
protected修饰的成员可以在同一个包内的任何类中访问，也可以在不同包的子类中访问。 - 使用场景：当你希望某个成员在同一个包内可以自由访问，同时允许不同包的子类继承和使用该成员时，可以使用
protected修饰符。
示例代码：
// 定义一个基类
package package1;
public class BaseClass {
// 定义一个受保护的变量
protected int protectedVariable = 20;
// 定义一个受保护的方法
protected void protectedMethod() {
System.out.println("This is a protected method.");
}
}
// 在同一个包内访问受保护成员
package package1;
public class SamePackageClass {
public static void main(String[] args) {
BaseClass baseClass = new BaseClass();
// 访问受保护变量
System.out.println(baseClass.protectedVariable);
// 调用受保护方法
baseClass.protectedMethod();
}
}
// 在不同包的子类中访问受保护成员
package package2;
import package1.BaseClass;
public class SubClass extends BaseClass {
public void accessProtectedMembers() {
// 访问受保护变量
System.out.println(protectedVariable);
// 调用受保护方法
protectedMethod();
}
}
3. 默认（无修饰符）
- 访问权限：也称为包访问权限，被默认访问修饰符修饰的成员只能在同一个包内的类中访问。
- 使用场景：当你希望某个成员只能在同一个包内被使用时，可以不使用任何访问修饰符。
示例代码：
// 定义一个类
package package3;
class DefaultClass {
// 定义一个默认访问修饰符的变量
int defaultVariable = 30;
// 定义一个默认访问修饰符的方法
void defaultMethod() {
System.out.println("This is a default method.");
}
}
// 在同一个包内访问默认成员
package package3;
public class SamePackageAccess {
public static void main(String[] args) {
DefaultClass defaultClass = new DefaultClass();
// 访问默认变量
System.out.println(defaultClass.defaultVariable);
// 调用默认方法
defaultClass.defaultMethod();
}
}
4. private
- 访问权限：具有最低的访问权限，被
private修饰的成员只能在定义该成员的类内部访问。 - 使用场景：通常用于封装类的内部实现细节，防止外部类直接访问和修改这些成员，从而提高代码的安全性和可维护性。
示例代码：
// 定义一个类
public class PrivateClass {
// 定义一个私有变量
private int privateVariable = 40;
// 定义一个私有方法
private void privateMethod() {
System.out.println("This is a private method.");
}
// 提供公共的访问方法
public int getPrivateVariable() {
return privateVariable;
}
public void callPrivateMethod() {
privateMethod();
}
}
// 在另一个类中访问 PrivateClass 的私有成员
public class AccessPrivateMembers {
public static void main(String[] args) {
PrivateClass privateClass = new PrivateClass();
// 通过公共方法访问私有变量
System.out.println(privateClass.getPrivateVariable());
// 通过公共方法调用私有方法
privateClass.callPrivateMethod();
}
}
总结
| 访问修饰符 | 同一类中 | 同一包中（子类与非子类） | 不同包中的子类 | 不同包中的非子类 |
|---|---|---|---|---|
public |
√ | √ | √ | √ |
protected |
√ | √ | √ | × |
| 默认（无修饰符） | √ | √ | × | × |
private |
√ | × | × | × |
七、重载和重写
重载（Overloading）
定义
方法重载是指在同一个类中，允许存在多个同名的方法，但这些方法的参数列表必须不同（参数的个数、类型或顺序不同），与方法的返回类型和访问修饰符无关。
作用
方法重载可以让程序更加清晰和简洁，通过使用相同的方法名来表示一组相似的操作，提高代码的可读性和可维护性。
示例代码
public class MethodOverloading {
// 方法重载：参数个数不同
public int add(int a, int b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
// 方法重载：参数类型不同
public double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
MethodOverloading overloading = new MethodOverloading();
// 调用两个整数相加的方法
System.out.println(overloading.add(1, 2));
// 调用三个整数相加的方法
System.out.println(overloading.add(1, 2, 3));
// 调用两个双精度浮点数相加的方法
System.out.println(overloading.add(1.0, 2.0));
}
}
重载规则
- 方法名必须相同：在同一个类中，所有重载的方法都使用相同的方法名。
- 参数列表必须不同：参数的个数、类型或顺序至少有一个不同。
- 返回类型可以不同：重载方法的返回类型可以相同也可以不同，但仅返回类型不同不能构成方法重载。
- 访问修饰符可以不同：重载方法的访问修饰符可以相同也可以不同。
重写（Overriding）
定义
方法重写是指在子类中定义一个与父类中具有相同方法名、相同参数列表和相同返回类型（或兼容的返回类型，即子类方法的返回类型是父类方法返回类型的子类）的方法，用于实现子类对父类方法的具体实现进行修改或扩展。
作用
方法重写是实现多态的重要手段之一，它允许子类根据自身的需求对父类的方法进行个性化的实现，提高了代码的灵活性和可扩展性。
示例代码
// 定义一个父类
class Animal {
public void makeSound() {
System.out.println("The animal makes a sound.");
}
}
// 定义一个子类
class Dog extends Animal {
// 重写父类的 makeSound 方法
@Override
public void makeSound() {
System.out.println("The dog barks.");
}
}
public class MethodOverriding {
public static void main(String[] args) {
Animal animal = new Animal();
animal.makeSound();
Dog dog = new Dog();
dog.makeSound();
Animal animalDog = new Dog();
animalDog.makeSound();
}
}
重写规则
- 方法名、参数列表和返回类型必须相同：子类重写的方法必须与父类被重写的方法具有相同的方法名、参数列表和返回类型（或兼容的返回类型）。
- 访问修饰符不能比父类更严格：子类重写方法的访问修饰符不能比父类被重写方法的访问修饰符更严格，例如，如果父类方法是
public的，子类重写方法不能是protected或private的。 - 抛出的异常不能比父类更多：子类重写方法抛出的异常不能比父类被重写方法抛出的异常更宽泛。
- 父类的
private方法不能被重写：因为private方法只能在定义它的类内部访问，子类无法访问和重写。 - 使用
@Override注解：虽然不是强制要求，但建议在子类重写方法时使用@Override注解，这样可以让编译器检查该方法是否真的重写了父类的方法，如果没有重写会报错，提高代码的可读性和安全性。
总结
- 重载：发生在同一个类中，方法名相同但参数列表不同，用于提供多个相似功能的方法，方便调用。
- 重写：发生在子类和父类之间，方法名、参数列表和返回类型相同，用于子类对父类方法的具体实现进行修改或扩展，实现多态性。