持续更新优化，部分内容太过基础没写

Java概述

程序：计算机执行某些操作或者解决某个问题而编写的一系列有序指令的集合

Java诞生与1995年 作者 扎姆斯高斯林

Java技术体系平台

• Java SE 标准版 桌面应用
• Java EE 企业版 Web应用 主要学习这个
• Java ME 小型版 移动应用和嵌入式

Java重要特点

• 面向对象 oop
• 语言健壮
• 跨平台
• 解释型语言 需要解释器

Java虚拟机 JVM

用于在不同的设备上运行.class字节码文件，屏蔽系统差异

JDK、JRE

JDK java开发工具包 Java Development Kit 开发者用

JDK=JRE+java开发工具

JRE java运行环境 Java Runtime Environment 普通用户用

JRE=JVM+Java核心类库

注意事项

1. 文件名必须与public类名一致
2. 一个源文件中最多只能有一个public类
3. 编译之后每一个类对应一个.class文件
4. Java语言严格区分大小写
5. 每个语句以 “;” 结束
6. java 命令之后跟类名
7. main 方法就是 Java 程序的唯一合法入口
8. 原则：一个文件只写一个类

特殊转义字符\r

功能：将光标移动到当前行的开头

不同的操作系统对“换行”的定义曾各不相同：

• Windows: 使用 \r\n（回车 + 换行）代表一行结束。
• Unix / Linux / macOS: 统一使用 \n（换行）代表一行结束。

\r 有一个非常酷的用途：制作简单的命令行进度条。

for (int i = 0; i <= 100; i++) {
    System.out.print("进度: " + i + "%\r"); // 利用 \r 回到行首不断覆盖
    Thread.sleep(100); // 暂停一小会儿
}

注释

• 单行注释 //
• 多行注释 / /
• 文档注释 /* /

被注释的文字，不会被JVM解释执行

Java代码规范

1. 类、方法的注释，要以Javadoc的方式来写
2. 非Java Doc 的注释，往往是给代码维护者看的
3. 使用Tab进行右移，shift+tab 进行左移
4. 运算符和=两边习惯性各加一个空格
5. 源文件使用utf-8编码
6. 行宽度不要超过80个字符
7. 代码编写推荐行尾风格

变量

变量是程序的基本组成单位

三要素 ：类型+名称+值

变量必须先声明再使用

同一个作用域之内变量不能重名

数据类型

基本数据类型+引用数据类型

\image-20260413125151360.png)

注意事项

1. 整型常量默认为 int 型，声明 long 型常量须后加‘l’或‘L’
2. 浮点型常量默认为 double 型，声明 float 型常量，须后加‘f’或‘F’
3. “小向大”是顺水推舟，自动完成；“大向小”是强人所难，必须强转。
4. 浮点数=符号位+指数位+尾数位 尾数部分可能丢失，造成精度损失(小数都是近似值)
5. 永远不要用 == 来比较两个浮点数。应该判断它们的差值是否小于一个极小的数值（如 1e-9）
6. 当我们对运算结果是小数的进行相等判断是，要小心应该是以两个数的差值的绝对值，在某个精度范围类判断
7. char字符常量只能用单引号''引用，只能存单个字符或者是数字，本质是存储的是一个整数unicode对映的编码，可以进行计算

补充知识浮点数的计算机存储

计算机里的浮点数就像一个精密的二进制科学计数法，其存储结构固定为：

• 符号位 (Sign)：1位。0正1负。
• 指数位 (Exponent)：
  • 作用：决定数值范围（小数点移动多少位）。
  • 黑科技：使用偏移码（Bias），通过给真实指数加一个固定值（如127），强行把负指数变成正整数，方便硬件直接比较大小。
• 尾数位 (Mantissa)：
  • 作用：决定数值精度（长什么样）。
  • 黑科技：隐藏整数位的 1。既然二进制规格化后第一位必然是1，干脆省掉不存，多赚1位精度。

+号的作用

1. 当左右两边都是数值类型时，则做加法运算
2. 当左右两边有一方为字符串，则做拼接运算
3. 运算顺序，从左到右

基本数据类型转换

路径 A： byte → short → int → long → float → double

路径 B： char → int → long → float → double

为什么long是8个字节，float是4个字节，但是long会自动转为float？

它们底层的二进制存储方式完全不同。数值范围的大小并不取决于它占用了多少字节，而取决于它的结构设计

long（64 位定点数）：1 位符号位 + 63 位数值位，纯精确整数。

float（32 位 IEEE 754 浮点数）：1 位符号位 + 8 位指数位 + 23 位尾数位。

long（8 字节）：最大值约 $9.22 \times 10^{18}$

float（4 字节）：最大值约 $3.4 \times 10^{38}$（范围远大于 long）

引入指数位后，表达范围被几何级放大。

注意看：

byte 可以自动转 short。short 不能直接转 char。byte 也 不能直接转 char。但是它们都可以统一自动转为 int再计算。原因是short和byte有符号。

提升原则：表达式结果的类型自动提升为操作数中最大的类型，最小是int类型

注意事项：

byte short char 类型的变量进行计算都会转换成 int 类型

byte short char 类型的常量(字面常量)进行计算会进行优化机制

常量计算不溢出时，类型由左侧接收变量决定（直通不升格）；一旦溢出，则被视为 int 类型（导致报错）。

只要公式中出现了一个变量，整个公式的“常量优化”特权就会立即消失，全面进入变量运算规则。

强制类型转化

将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符 ( )，但可能造成精度降低或溢出,格外要注意。

Java基本数据类型中，数值类型和boolean不能互相强制转换

基本数据类型和String类型的转换

基本数据类型转String类型：将基本类型的值+“”

String类型转基本数据类型：利用包装类 xxx.parsexxx(“”)

包装类的作用：让基本数据类型能够像对象一样工作，具备属性和方法

运算符

算术运算符

System.out.println(10 / 4); //从数学来看是 2.5, java 中 2
System.out.println(10.0 / 4); //java 是 2.5

int total = 4;
int score = 10;
double result = score / total; // 猜猜结果是多少？ 2.0
System.out.println(result);

原因： score / total 的计算先发生，因为两个都是 int，所以先算出了 2。

赋值： 算出 2 之后，才把这个整数赋值给 double result。这时 2 变成了 2.0。

在 % 的本质 看一个公式a % b = a - a / b * b

由公式可以知道：在 Java 的取模运算中，结果的符号只取决于左操作数（被除数 $a$）的符号，而与右操作数（除数 $b$）无关。

面试题

int i = 1；
i = i++；
System.out.println(i);

答案是 1

过程 temp = i i=i+1 i=temp

int i = 1；
i = ++i；
System.out.println(i);

答案是 2

过程 i=i+1 temp=i i=temp

补充知识点

java和python在处理/的时候采用不同的处理方法

Java：向零取整 (Truncate)

Java 的整数除法采用的是 截断除法。简单来说，就是直接把小数点后面的部分“扔掉”。

• 计算 -7 / 3： 结果是 -2.333...，截断后变成 -2。
• 推导 %： $-7 - (3 \times -2) = -7 + 6 = -1$。

Python：向下取整 (Floor)

Python 的整数除法（//）采用的是 地板除。它向数轴的左侧（负无穷方向）取整。

• 计算 -7 // 3： 结果是 -2.333...，向左取整变成 -3。
• 推导 %： $-7 - (3 \times -3) = -7 + 9 = 2$。

关系运算符

关系运算符的结果都是boolean类型，也是就是要么true要么false

instanceof

逻辑运算符

1) a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false
2) a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
3) a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
4) a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
5) !a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true
6) a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断，效率高

对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断，效率低

||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高

| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低

赋值运算符

赋值运算符特点

1) 运算顺序从右往左

2) 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值

3) 复合赋值运算符等价于下面的效果比如：a+=3;等价于 a=a+3;
4) 复合赋值运算符会进行类型转换。

byte b = 3;
b += 2; // 等价 b = (byte)(b + 2);
b++; // b = (byte)(b+1);

三元运算符

条件表达式 ? 表达式 1: 表达式 2;

运算规则：

1. 如果条件表达式为 true，运算后的结果是表达式 1；
2. 如果条件表达式为 false，运算后的结果是表达式 2；

注意事项

1) 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
2) 三元运算符可以转成 if—else 语句

命名规范

补充知识点，原码反码补码

原码 (Sign-Magnitude)：最高位为符号位（0正1负），其余位是数值。

• 直观但难算，0有两套写法。

反码 (Ones’ Complement)：正数不变；负数符号位不变，数值位按位取反。

• 进化的中间产物，解决了符号位参与运算的问题。

补码 (Two’s Complement)：正数不变；负数在反码基础上 +1。

• 计算机真正采用的格式。

所有运算都在补码（Two’s Complement）基础上进行

程序控制结构

1. 顺序控制

   程序从上到下逐行执行，中间没有任何判断和跳转

2. 分支控制

   1. 单分支 if

   2. 双分支 if-else

   3. 多分支 if-else if- else

   4. switch分支

      表达式数据类型应和case后的变量类型一致，或者可以自动转成可以比较的类型

      switch(表达式)中的表达式的返回值必须是：byte short int char enum String

      case子句中的值必须是常量，而不能是变量

      default子句是可选的，当没有匹配的case时，执行default

      break语句用来在执行完成一个case分支后使程序跳switch语句块，如果没有break，程序会顺序执行，直到遇到break

3. 循环控制

   1. for循环

      for循环四个要素 循环变量初始化 循环条件 循环操作 循环变量迭代

      注意 循环里面创建的变量都是临时的，用完就销毁

      循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

   2. while循环

   3. do while循环

      先执行再判断，最少会执行一次

      最后 有一个;

4. 多重循环控制

   1. break 终止循环
   2. continue 跳出本次循环

5. 跳转控制语句 - return

   跳出所在的方法

数组、排序、查找

数组定义方式

1. 动态分配 数据类型 数组名[] = new 数组类型[大小]

2. 先声明再分配 数据类型 数组名[] 数组名 = new 数组类型[大小]

3. 数组名.length 表示数组的大小/长度

4. 数据类型 数组名[]; 也可以 数据类型[] 数组名;

注意事项

1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3) 数组创建后，如果没有赋值，有默认值

int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

4) 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组
5) 数组的下标是从 0 开始的。
6) 数组下标必须在指定范围内使用，否则报：下标越界异常，
7) 数组属引用类型，数组型数据是对象(object)

int a = 1；
int b = a；
a和b是单独的空间，互不影响     基本数据类型
int[] a = [1,2];
int[] b = a;
a和b是引用同一个地址，相互影响    引用数据类型

面向对象编程

组成

1. 属性

   对象名.属性名

2. 行为

   对象名.方法名

对象与类的关系

1. 类是抽象的，概念的，代表一类事物
2. 对象是具体的，实际的，代表一个具体事务
3. 类是对象的模板，对象是类的一个个体

类和对象的内存分配机制

Java 内存的结构分析

1. 栈：一般存放基本数据类型(局部变量)
2. 堆：存放对象(Cat cat ， 数组等)
3. 方法区：常量池(常量，比如字符串)，类加载信息

Person p = new Person();
p.name = "jack";
p.age = 10;

1. 先加载Person类信息(属性和方法信息，只会加载一次)
2. 再堆中分配空间，进行默认初始化
3. 把地址赋给p ，p就指向对象
4. 进行指定初始化，比如 p.name=”jack” p.age = 10

方法的调用机制原理

1. 当程序执行到方法时，就会开辟一个独立的空间(栈空间)
2. 当方法执行完毕，或者执行到return语句时，就会返回
3. 返回到调用方法的地方
4. 返回后，继续执行方法后面的代码
5. 当main方法(栈)执行完毕，这个程序退出

方法的访问修饰符

1. public：公开的。无论是哪个类、哪个包、还是外部项目，都可以直接访问。
2. protected：受保护的。同一个包内的类可以访问；不同包中的子类也可以访问。
3. 默认（无修饰符）：包级私有（package-private）。只有同一个包内的类可以访问，跨包了就不能访问。
4. private：私有的。只有在定义它的类内部才能访问，体现了面向对象的封装性。通常属性会设为 private，然后通过 get/set 方法来间接访问。

方法的返回数据类型

1) 一个方法最多有一个返回值 [多个结果 返回数组 ]
2) 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
3) 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容

4) 如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;

注意事项

1. 方法不能嵌套定义，方法体中不能再定义方法
2. 基本数据类型，传递的是值(值拷贝)，形参的任何变化不影响实参
3. 引用数据类型，传递的是地址(传递也是值，但是值是地址)，可以通过形参影响实参

递归重要规则

1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2. 方法的局部变量时独立的，不会相互影响
3. 如果方法中使用的是引用类型变量(比如数组，对象)，就会共享引用类型的数据
4. 递归必须向退出递归条件逼近，否则就是无限递归
5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

方法重载

1. 方法名：必须相同
2. 参数列表：必须不同
3. 返回类型：无要求

可变参数

public int sum(int... nums) {
	int res = 0;
	for(int i = 0; i < nums.length; i++) {
		res += nums[i];
	}
	return res;
}

1. int… 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)

2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组

3. 遍历 nums 求和即可

注意事项

1. 可变参数的实参可以为0个或者任意多个
2. 可变参数的实参可以为数组
3. 可变参数的本质就是数组
4. 可变参数可以和普通类型的参数一起放在形参列表，但是必须保证可变参数在最后
5. 一个形参列表中只能出现一个可变参数

作用域

1. Java编程中，主要的变量就是属性(成员变量)和局部变量
2. 局部变量一般是指在成员方法中定义的变量
3. java中作用域的分类
   1. 全局变量：也就是属性，作用域为整个类
   2. 局部变量：除了属性之外的其他变量，作用域是定义他的代码块
4. 全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值，才能使用，因为没有默认值

注意事项

1. 属性和局部变量可以重名，访问时遵循就近原则
2. 在同一个作用域中，两个变量不能重名
3. 属性生命周期较长，便随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁
4. 作用域范围不同
   1. 全局变量：可以被本类使用，或其他类使用
   2. 局部变量：只能在本类中对应的方法中使用
5. 修饰符不同
   1. 全局变量可以加修饰符
   2. 局部变量不可用加修饰符

构造方法

[修饰符] 方法名(形参列表){
	方法体;
}

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1) 方法名和类名相同
2) 没有返回值
3) 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
4) 构造器没有返回值, 也不能写 void

注意事项

1. 一个类可以定义多个不同的构造器，即构造器重载
2. 构造器名要和类名相同
3. 构造器没有返回值
4. 构造器是完成对象的初始化，并不是创建对象
5. 在创建对象时，系统自动的调用该类的构造方法
6. 如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(默认构造器)
7. 一旦定义了自己的构造器，默认的构造器就被覆盖了，就不能再使用默认无参构成器了，除非显式的定义一下

this关键字

Java虚拟机会给每个对象分配this代表当前对象

注意事项

1. this 关键字可以用来访问本类的属性、方法、构造器

2) this 用于区分当前类的属性和局部变量
3) 访问成员方法的语法：this.方法名(参数列表);

4) 访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)

5) this 不能在类定义的外部使用，只能在类定义的方法中使用

补充知识点

1. ==（双等号）
   • 基本数据类型（如 int, double, boolean）：比较的是它们的数值是否相等。
   • 引用数据类型（如对象、数组、字符串）：比较的是它们的内存地址是否相同（即是否指向堆内存中的同一个对象）。
2. equals() 方法
   • 对象专属：它是 Object 类的一个方法，所有类都继承了它。
   • 默认行为：如果没有重写（Override），它的底层逻辑和 == 一样，比较的还是内存地址。
   • 常用重写：像 String、Integer 等类都重写了 equals() 方法，用来比较它们的内容（值）是否相同。

IDEA 常用快捷键

1) 删除当前行, 默认是 ctrl + Y 自己配置 ctrl + d
2) 复制当前行, 自己配置 ctrl + alt + 向下光标
3) 补全代码 alt + /
4) 添加注释和取消注释 ctrl + / 【第一次是添加注释，第二次是取消注释】
5) 导入该行需要的类 先配置 auto import , 然后使用 alt+enter 即可
6) 快速格式化代码 ctrl + alt + L
7) 快速运行程序 自己定义 alt + R
8) 生成构造器等 alt + insert
9) 查看一个类的层级关系 ctrl + H
10) 将光标放在一个方法上，输入 ctrl + B , 可以定位到方法
11) 自动的分配变量名 , 通过 在后面假 .var

包

作用

1. 区分相同名字的类
2. 方便管理类
3. 控制访问范围

基本语法

package cn.itrf

package 关键词，表示打包

cn.itrf 表示包名

注意事项

1. package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package
2. import指令 位置放在package的下面，在类定义前面，可以有多句且没有顺序要求

访问修饰符

1. public：公开的。无论是哪个类、哪个包、还是外部项目，都可以直接访问。
2. protected：受保护的。同一个包内的类可以访问；不同包中的子类也可以访问。
3. 默认（无修饰符）：包级私有（package-private）。只有同一个包内的类可以访问，跨包了就不能访问。
4. private：私有的。只有在定义它的类内部才能访问，体现了面向对象的封装性。通常属性会设为 private，然后通过 get/set 方法来间接访问。

面向对象的三大特征

封装、继承、多态

封装

封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只能通过授权的操作，才能对数据进行操作

将属性设置为private 创建setXXX和getXXX的方法 public

继承

class 子类 extends 父类{

}

子类就是会自动拥有父类定义的属性和方法

父类又叫 超类，基类

子类又叫派生类

注意事项

1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问

2) 子类必须调用父类的构造器， 完成父类的初始化
3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。

4) 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
5) super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)
6) super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7) java 所有类都是 Object 类的子类, Object 是所有类的基类.
8) 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
9) 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】

10) 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

super关键字

super代表父类的引用，用于访问父类的属性、方法、构造器

不能访问父类的private属性和方法

当子类中有何父类中的成员(属性和方法)重名时，为了访问父类成员，必须通过super。如果没有重名，使用super、this、直接访问的结果一样

super.成员 的查找起点是直接父类，若直接父类没有对应成员，会继续沿着继承链向上查找（可找到爷爷类等上层父类）；查找遵循继承链就近原则，同时受访问权限约束遇到private就断了报错；无法主动跳过直接父类，强制直接访问爷爷类中被父类重写 / 覆盖的同名成员。

this和super的区别

方法的重写/覆盖

方法的覆盖就是子类的一个方法和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法

子类重写方法的返回值类型和父类返回值类型一致，或者是其子类

子类的方法不能缩小父类方法的访问范围

多态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

重点

1. 一个对象的编译类型和运行类型可以不一致
2. 编译类型在定义对象时，就确定了，不能改变
3. 运行类型是可以变化的
4. 编译类型看定义时 = 号 的左边，运行类型看 = 号的 右边

多态前提（四个条件缺一不可）

1. 继承 / 实现：子类继承父类（类继承）或者类实现接口
2. 方法重写：子类重写父类方法
3. 父类引用指向子类对象（向上转型）
4. 调用重写方法

向上转型（自动转型，隐式转型）

格式：父类类型 引用 = new 子类();

Animal animal = new Dog(); // 向上转型

特点：

1. 自动转换，不需要强制
2. 可以调用：父类所有方法 + 子类重写的方法
3. 不能调用子类独有的方法

向下转型（强制转型，显式转型）

作用：向上转型后，想要调用子类独有方法，必须向下转回子类类型

格式：子类类型 引用 = (子类)父类引用;

Animal a = new Dog(); //向上转型
Dog dog = (Dog) a;    //向下转型
dog.watchDoor();      // 正常执行

巨大坑：类型转换异常 ClassCastException

只有原本就是该子类对象，才能强转；

Animal a = new Cat();
Dog d = (Dog)a; //运行报错！

解决方案：instanceof 判断

判断引用变量指向的实际对象是不是【某个类 / 它的子类 / 实现类】的实例

转型前先判断引用实际对象类型

if(a instanceof Dog){
    Dog d = (Dog)a;
    d.watchDoor();
}

高频易错总结

1. 方法有多态，成员变量没有多态！

class A{ int num = 10; }
class B extends A{ int num = 20; }
A a = new B();
System.out.println(a.num); //输出10，看左边父类

1. 静态方法重写不叫重写，叫隐藏，不存在多态；调用看左边
2. 向上转型本质：多态的基础写法
3. 向下转型不是多态，只是为了访问子类特有功能

Java的动态类型绑定

1. 调用对象【方法】：存在动态绑定

   调用方法时，看对象真实运行类型（堆里 new 出来的类型），执行子类重写后的方法。

通俗：方法 → 运行看右边

1. 调用对象【成员属性 (变量)】：没有动态绑定

访问变量时，看引用声明类型（等号左边是什么类型），哪里声明，就取哪里的属性。

通俗：属性 → 编译 / 运行都看左边

类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

class Child { //类
	private String name;
	//定义一个变量 count ,是一个类变量(静态变量) static 静态
	//该变量最大的特点就是会被 Child 类的所有的对象实例共享
	public static int count = 0;
	public Child(String name) {
		this.name = name;
	}
}

访问类变量

类名.类变量名 对象名.类变量名 推荐用第一种

生命周期

1. 类变量是在类加载时就完成初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量
2. 类变量的生命周期是随类的加载开始，随着类消亡而销毁

类方法

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：

   类方法中无 this 的参数

   普通方法中隐含着 this 的参数

2. 类方法可以通过类名调用，也可以通过对象名调用。

3. 普通方法和对象有关，需要通过对象名调用，比如对象名。方法名 (参数)，不能通过类名调用。

4. 类方法中不允许使用和对象有关的关键字，比如 this 和 super。普通方法 (成员方法) 可以。

5. 类方法 (静态方法) 中 只能访问 静态变量 或静态方法 。

6. 普通成员方法，既可以访问 非静态成员，也可以访问静态成员。

小结： 静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员 (必须遵守访问权限)

mian方法

public static void main(String[] args)

1. public：公共访问权限。JVM 需要跨类调用 main 方法，必须对外公开可访问。

2. static：静态方法。JVM 启动时还没有创建类的实例对象，直接通过类名调用方法，不需要 new 对象。

3. void：无返回值。JVM 不接收 main 函数的返回结果。

4. main：固定方法名，JVM 识别的程序入口名称，不能修改。

5. String[] args：命令行参数数组

   • 在控制台执行命令示例：

     java TestDemo 张三 20 男

     args[0]="张三" args[1]="20" args[2]="男"

   • args 名称可以修改（例如String[] params），但数组类型不能变。

三种代码块定义

1. 静态代码块

static {
    //代码
}

• 位置：类内部，方法外面，加 static

• 触发时机：类加载的时候执行，只执行 1 次

• 作用：初始化静态变量

• 限制：

  ✅只能访问静态成员

  ❌不能使用 this、super

  ❌不可以写 return

1. 构造代码块（实例代码块 / 普通代码块【类内】）

{
    //代码
}

• 位置：类内部、方法外面，没有 static
• 触发时机：每次创建对象 new 的时候执行
• 执行时机：在构造方法之前执行
• 作用：提取多个构造方法的公共重复代码
• ✅可以访问静态、非静态成员，可以使用 this

1. 局部代码块（方法内普通代码块）

public void test(){
    {
        //局部代码块
    }
}

• 位置：方法内部
• 作用：限定局部变量生命周期，缩小作用域

考试常考：区分「构造代码块」和「局部代码块」

执行顺序

情况 1：只创建单个对象

1. 静态代码块（类加载，最先执行，只运行一次）
↓
2. 构造代码块（每次new对象都执行）
↓
3. 构造方法

示例演示：

public class Test {
    static {
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
    public Test(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        new Test();
    }
}

静态代码块
构造代码块
构造方法

情况 2：多次 new 对象

new Test();
new Test();

静态代码块    //类加载，仅第1次执行
构造代码块
构造方法
构造代码块    //第二次new，静态不再执行！
构造方法

💡关键结论：静态代码块随类加载，全局只执行一次；构造代码块每次 new 对象都会执行。

情况 3：存在父子继承关系（高频面试！必考）

继承场景完整顺序口诀：

父静态 → 子静态 → 父构造代码块 → 父构造方法 → 子构造代码块 → 子构造方法

演示代码：

class Father{
    static {System.out.println("父静态");}
    {System.out.println("父构造代码块");}
    public Father(){System.out.println("父构造器");}
}
class Son extends Father{
    static {System.out.println("子静态");}
    {System.out.println("子构造代码块");}
    public Son(){System.out.println("子构造器");}
}

public class Main{
    public static void main(String[] args) {
        new Son();
    }
}

运行结果：

父静态
子静态
父构造代码块
父构造器
子构造代码块
子构造器

⚠️易错提醒：

静态代码块只看类加载顺序，优先父类静态；静态代码块互不依赖实例，优先全部执行完所有静态，再执行实例相关代码块、构造器。

设计模式

1. 静态方法和属性的经典使用
2. 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

单例模式：保证一个类在整个程序中，只有唯一的一个实例对象，对外提供统一获取该对象的入口。

使用场景：工具类、线程池、数据库连接池、配置文件对象等，不需要多个实例，节约内存。

核心三大要点：

1. 私有构造方法：private 类名(){}，禁止外部new创建对象
2. 私有静态成员变量：保存唯一实例
3. 公共静态方法：对外获取这个唯一实例

方式 1：饿汉式（静态常量写法，【线程安全】）

public class SingletonHungry {
    // 1.类加载时直接创建实例
    private static final SingletonHungry instance = new SingletonHungry();
    // 2.私有构造，阻止外部new
    private SingletonHungry(){}
    // 3.对外获取实例的方法
    public static SingletonHungry getInstance(){
        return instance;
    }
}

执行时机

类加载的时候直接创建对象。

✅优点：

• 写法简单，天然线程安全（类加载只执行一次，不存在多线程冲突）

❌缺点：

• 类一旦加载，立刻创建对象。即使程序全程没有用到这个实例，对象依然创建，造成内存浪费。

饿汉：肚子一饿立刻吃饭 → 类加载直接实例化。

方式 2：懒汉式（基础版，⚠️多线程不安全！）

public class SingletonLazy {
    // 先不创建实例
    private static SingletonLazy instance;
    private SingletonLazy(){}
    // 调用方法时，才创建对象
    public static SingletonLazy getInstance(){
        // 第一次调用才new
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}

执行时机

调用getInstance()方法的时候，才创建实例（延迟加载）

✅优点：懒加载，不用就不创建，节省内存

❌致命缺陷：多线程环境下会创建多个对象，线程不安全

👉线程安全优化：双重检查锁 DCL（面试标准懒汉写法）

public class SingletonLazyDCL {
    // volatile 禁止指令重排，必须加上
    private static volatile SingletonLazyDCL instance;
    private SingletonLazyDCL(){}

    public static SingletonLazyDCL getInstance(){
        // 第一层判断：避免每次都竞争锁，提高效率
        if(instance == null){
            synchronized (SingletonLazyDCL.class){
                // 第二层判断：防止多个线程同时等待锁，重复创建
                if(instance == null){
                    instance = new SingletonLazyDCL();
                }
            }
        }
        return instance;
    }
}

懒汉：不到饭点不吃饭 → 需要用到的时候才创建对象

⚠️拓展面试考点

1. 私有构造方法依然可以被反射暴力破解，两种基础实现都不能防止反射创建多个实例；
2. 还有第三种写法：静态内部类单例（推荐，兼顾懒加载与线程安全）；

public class Singleton {
    private Singleton(){}
    private static class Inner{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return Inner.INSTANCE;
    }
}

Java final 关键字完整讲解

final 表示「最终的、不可修改」，可以修饰：变量、方法、类。

一、final 修饰【变量】

变量一旦赋值成功，不能重新赋值（常量）

1. 局部变量

public void test(){
    final int a;
    a = 10;
    // a = 20;  // ❌编译报错，不能二次赋值
}

final 局部变量可以先声明、后面一次赋值，但是只能赋值一次。

1. 成员变量（实例变量）

两种赋值时机，二选一：

1. 定义时直接初始化
2. 在构造方法中赋值

❗不能不赋值！final 成员变量必须保证对象创建完成时有值。

class A{
    final int num = 10;
    // final int num; // 合法，可以在构造器赋值
    public A(){
        // num = 20;
    }
}

1. 静态成员变量（static final）

俗称常量，命名规范：全部大写，下划线分隔 MAX_VALUE

赋值时机：

1. 声明处初始化
2. 静态代码块初始化

public static final double PI = 3.1415926;

⚠️极易混淆重点：final 修饰引用类型变量

final Person p = new Person();
p.name = "张三";  // ✅合法！！
p = new Person(); // ❌报错！

• final 限制的是引用地址不能变

• 对象内部的属性依然可以修改！

  形象理解：遥控器不能换电视，但是可以换频道。

二、final 修饰【方法】

public final void show(){}

规则：

✅ 该方法不能被子类重写（override）

仍然可以被继承，子类可以调用，只是不能改写方法实现。

💡补充：

private 方法隐式带有 final 特性，子类无法重写私有方法。

三、final 修饰【类】

final class Animal{}

规则：

✅ 这个类不能被继承，没有子类

例子：String、Integer 都是 final 类，你无法写 class MyStr extends String

四、高频易错题汇总

1. final 和 static 区别？

• static：属于类，所有对象共享一份
• final：值不可修改；两者经常组合 static final 定义常量

1. 基本类型 final vs 引用类型 final

• 基本类型：数值不能变
• 引用类型：对象地址不能变，对象内部内容可变

1. final 方法可以重载吗？

   ✅可以重载！只是禁止重写，重载不受影响。

class A{
    public final void test(){}
    public final void test(int a){} // ✅重载合法
}

1. final 可以修饰构造方法吗？

   ❌不允许！构造方法本身不能被继承重写，语法不支持。

五、速记口诀

• final 变量：赋值一次，终身不改（引用变量地址不变，对象内容可变）
• final 方法：禁止子类重写
• final 类：断绝继承，不能有子类

Java 抽象类（abstract class）

一、基础概念

用 abstract 关键字修饰的类，叫做抽象类。

抽象类用来提取多个子类的公共模板，允许定义没有方法体的抽象方法，强制子类去实现。

语法格式：

abstract class 类名 {
    
}

二、抽象方法

语法：abstract 返回值 方法名();

• 只有方法声明，没有方法体（没有 {}）
• 必须写在抽象类 / 接口当中
• 作用：规范子类必须实现这个方法

示例：

abstract class Animal {
    // 抽象方法：没有方法体
    public abstract void shout();
}

三、核心硬性规则（必背考点）

1. 抽象类不能 new 创建对象

   new Animal(); // ❌编译报错

   原因：类中有未实现的抽象方法，对象不完整。

2. 如果一个类继承抽象类：

   • 方案①：普通子类 → 必须重写父类所有抽象方法
   • 方案②：子类也定义为 abstract 抽象类 → 可以不用实现抽象方法

// 普通子类，必须实现全部抽象方法
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("汪汪汪");
    }
}

1. 抽象类里可以包含什么？

   ✅ 普通成员变量、静态变量

   ✅ 普通实例方法、static 静态方法

   ✅ 构造方法（供子类创建对象时调用）

   ✅ 抽象方法

💡重点：抽象类有构造方法！只是不能自己实例化，子类 new 的时候通过 super() 调用。

1. 几个语法禁忌

   ❌ abstract 和 final不能一起修饰类

   final 类不能被继承，abstract 类要求必须被继承实现，互相矛盾。

   ❌ abstract 和 private 不能一起修饰方法

   private 方法子类看不见，无法重写实现，冲突。

   ❌ abstract 和 static 不能一起修饰方法

   静态方法可以直接类名调用，不需要子类实现，冲突。

三、高频易错题

1. 抽象类一定包含抽象方法？

   ❌错误！抽象类可以没有任何抽象方法，只是很少这么写。

abstract class Test{
    // 全部都是普通方法，合法抽象类
    public void hello(){}
}

1. 有抽象方法的类，一定是抽象类？

   ✅正确！普通类存在抽象方法直接编译报错。

Java 接口（interface）

接口是行为规范、标准契约，定义一组功能（方法声明），本身不关心怎么实现。

语法：

interface 接口名 {

}

类实现接口，关键字：implements

class 类名 implements 接口1,接口2 {
    
}

二、不同 JDK 版本接口内允许的成员（考试重点）

1）JDK7 及以前（经典老式接口）

接口里面只能有：全局常量、抽象方法

1. 常量：public static final 修饰，默认隐藏

interface Usb{
    // 默认：public static final int MAX_SPEED = 480;
    int MAX_SPEED = 480;
}

必须初始化，不能修改。

1. 抽象方法：public abstract 修饰，默认隐藏

interface Usb{
    // public abstract void work();
    void work();
}

2）JDK 8 新增

✅ 默认方法（default）：带方法体，实现类可以选择重写，不重写就用默认实现

default void show(){
    System.out.println("默认方法");
}

✅ 静态方法（static）：接口。静态方法 () 调用，实现类不能继承

3）JDK 9 新增

✅ 私有方法 private：供接口内部默认方法复用

💡面试常记：日常开发核心掌握【常量、抽象方法、default 默认方法、static 静态方法】

三、核心语法规则（必背）

1. 接口不能 new 实例化，没有构造方法！

new Usb(); // ❌报错

1. 类和接口：implements 多实现（一个类可以同时实现多个接口）

class Phone implements Usb, Bluetooth{}

1. 接口与接口：extends 多继承

interface A{}
interface B{}
interface C extends A,B{}

1. 实现类要求：

• 普通类实现接口：必须重写接口中所有抽象方法
• 抽象类实现接口：可以不实现抽象方法，交给它的子类完成

1. 方法访问权限：

接口抽象方法强制 public，重写的时候不能缩小权限（不能写 protected/private）

设计思想区分：

Animal（抽象类）：动物是什么

Run（接口）：动物能跑

Dog extends Animal implements Run

四、高频易错考点

1. default 默认方法冲突问题

   一个类实现多个接口，如果多个接口存在同名同参数 default 方法，实现类必须手动重写该方法，否则编译报错。

2. 接口静态方法不会被继承,普通类的可以被继承但不能重写

interface A{
    static void test(){}
}
class B implements A{}
B.test(); // ❌错误，只能 A.test()

1. 接口常量默认public static final，写不写都一样，不能修改。

Java 内部类

一、什么是内部类

把一个类定义在另一个类的内部，这个类就叫内部类；外面的类称为外部类（外围类）。

//外部类
class Outer{
    //内部类
    class Inner{
        
    }
}

分类（四大类）：

1. 成员内部类（实例内部类）
2. 静态内部类（静态嵌套类）
3. 局部内部类（方法内定义）
4. 匿名内部类（重点，经常和接口 / 抽象类搭配）

1. 成员内部类（没有 static，写在外部类成员位置）

class Outer{
    private String name = "外部类成员";
    //成员内部类
    class Inner{
        public void show(){
            //✅内部类可以直接访问外部类所有成员，包括private私有！
            System.out.println(name);
        }
    }
}

核心规则

1. 成员内部类依赖外部类对象，不能直接 new

   创建语法：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.show();

简写：Outer.Inner inner = new Outer().new Inner();

1. 内外类出现同名变量怎么区分？

class Outer{
    String a = "外部a";
    class Inner{
        String a = "内部a";
        public void test(){
            System.out.println(a);            //内部a
            System.out.println(this.a);       //内部a
            System.out.println(Outer.this.a); //外部类的a！【重点语法】
        }
    }
}

1. 限制

   ❌内部类里面不能定义静态成员（static 变量、静态方法）

因为成员内部类必须依托外部实例，静态属于类，冲突

1. 访问权限

   成员内部类可以使用 private / protected / public修饰；

   如果内部类被 private 修饰，外部其他类无法访问这个内部类。

1. 静态内部类（static 修饰，也叫嵌套类）

class Outer{
    private static String msg = "静态外部变量";
    //静态内部类
    static class StaticInner{
        public void show(){
            //✅ 只能访问外部类【静态成员】
            System.out.println(msg);
        }
    }
}

核心规则

1. 不依赖外部类对象，直接通过外部类类名创建

Outer.StaticInner inner = new Outer.StaticInner();

❌ 不能写 outer.new StaticInner ()

1. 访问范围

   只能直接访问外部类 static 静态属性、静态方法；

   想要访问外部实例成员，必须传入外部类对象。

2. 可以拥有自己的静态成员。

成员内部类 vs 静态内部类 关键区别

1. 局部内部类（定义在【方法里面】）

class Outer{
    public void method(){
        //局部内部类，作用域仅限于当前方法
        class LocalInner{
            public void show(){
                System.out.println("局部内部类方法");
            }
        }
        //只能在方法内创建使用
        LocalInner li = new LocalInner();
        li.show();
    }
}

规则

1. 作用域仅限当前方法，方法外面无法使用；
2. 不能使用访问修饰符 public private protected；
3. JDK8 开始，如果访问方法里的局部变量，变量默认隐式 final（不能修改）；

public void test(){
    int num = 10;
    class Inner{
        void show(){
            System.out.println(num);
        }
    }
    // num = 20; //报错！局部内部类访问后，num等同于final
}

1. 匿名内部类（重中之重！面试、开发高频）

没有类名的内部类，一般用来一次性实现接口 / 抽象类，简化代码。

语法格式：

new 接口/抽象类/父类(){
    //重写方法
};

示例：基于接口

interface Usb{
    void work();
}

public class Test{
    public static void main(String[] args) {
        //匿名内部类，相当于创建接口的实现类对象
        Usb usb = new Usb(){
            @Override
            public void work() {
                System.out.println("usb设备工作");
            }
        };
        usb.work();
    }
}

核心特点

1. 匿名内部类只能使用一次，只能创建一个对象；下次创建对象的时候必须重新写一边,没有名字不能重复使用;
2. 没有构造方法；
3. 本质：隐式继承父类 / 实现接口；
4. 属于局部内部类的一种；

💡常用场景：方法传参、线程 new Thread(new Runnable(){})

拓展：JDK8 Lambda 表达式可以简化只有一个抽象方法的接口，替代匿名内部类。

⚠️通用核心考点：内部类访问外部类

1. 内部类天生持有外部类的隐式引用：外部类名.this
2. 外部类想要访问内部类成员：必须先创建内部类对象，不能直接访问

class Outer{
    class Inner{
        int num = 100;
    }
    public void test(){
        // System.out.println(num); //❌不行！
        Inner in = new Inner();
        System.out.println(in.num); //✅需要对象
    }
}

枚举和注解

枚举是一种特殊类，用来固定、列出有限、确定的常量。

适合场景：季节、星期、订单状态、性别、方向。

解决普通常量public static final的缺陷（无法限制传入非法值）。

语法定义：

enum Season {
    // 枚举常量（必须写在最前面）
    SPRING, SUMMER, AUTUMN, WINTER;
}

等价理解：每个常量都是 Season 的静态常量实例对象。

枚举的实现方式

1. 自定义类实现枚举

   1) 构造器私有化
   2) 本类内部创建一组对象
   3) 对外暴露对象（通过为对象添加 public final static 修饰符）
   4) 可以提供 get 方法，但是不要提供 set

2. 使用enum关键字实现枚举

   1) 当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类, 而且是一个 final 类

   2) 传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”)， 这里必须知道，它调用的是哪个构造器.

   3) 如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略
   4) 当有多个枚举对象时，使用,间隔，最后有一个分号结尾
   5) 枚举对象必须放在枚举类的行首

   enum 定义的类，编译器自动处理：

   1. 隐式继承 java.lang.Enum，不能再继承其他类
   2. 所有枚举实例：public static final
   3. 构造方法强制私有 private，就算不写也是 private，禁止外部new

   ❌ 误区：不能手动写 extends；构造方法不能用 public /protected

   示例

   enum Season { //常量对象，调用构造方法 SPRING("春天", "温暖"), SUMMER("夏天", "炎热"), AUTUMN("秋天", "凉爽"), WINTER("冬天", "寒冷"); //成员变量 private String name; private String desc; //【构造方法：默认private，不能写public】 Season(String name, String desc) { this.name = name; this.desc = desc; } //getter，不能提供setter（枚举常量一般不可修改） public String getName() { return name; } public String getDesc() { return desc; } }

   Enum 自带核心方法（必考）

   1. values()

   返回枚举所有常量的数组，用于遍历

   Season[] arr = Season.values(); for(Season s : arr){ System.out.println(s); }

   1. valueOf(String name)

   根据名字字符串获取枚举常量；名字不存在抛出异常IllegalArgumentException

   Season s = Season.valueOf("SPRING");

   1. ordinal()

   返回常量序号，从 0 开始（定义顺序）

   System.out.println(Season.SPRING.ordinal()); //0

   1. name() / toString()
   • name()：返回常量定义名称（SPRING），final 无法重写
   • toString()：默认和 name () 一样，可以重写自定义输出

   System.out.println(Season.SPRING.name()); //SPRING

   枚举可以拥有的特性

   ✅ 构造方法（只能 private）

   ✅ 成员变量、普通方法、静态方法

   ✅ 抽象方法（每个枚举常量必须实现！）

   ✅ 可以实现接口

   ❌ 不能继承其他类（隐式继承 Enum，Java 单继承）

   ❌ 外部无法 new 枚举对象

   每个枚举实例单独实现方法：

   enum Season { SPRING{ @Override public void show() { System.out.println("春暖花开"); } }, SUMMER{ @Override public void show() { System.out.println("夏日炎炎"); } }; //抽象方法 public abstract void show(); }

   高频易错总结

   1. 枚举构造器只能 private，省略不写也是 private
   2. 枚举常量必须放在类最开头，分号可选（后面有代码必须加分号）
   3. 枚举不能被继承；不能继承别的类，可以实现接口
   4. valueOf() 参数名称错误会抛运行异常
   5. ordinal () 顺序依赖代码定义顺序，业务不要重度依赖！
   6. 枚举常量是单例，全局只有一个对象

注解

1) 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。
2) 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。
3) 在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在 JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等。

元注解（用来修饰【自定义注解】的注解）

元注解：注解的注解，专门定义自定义注解的行为，一共 5 个，重点 4 个

1. @Target

   可选值（ElementType 枚举）：

• TYPE：类、接口、枚举
• METHOD：方法
• FIELD：成员变量
• PARAMETER：方法参数
• CONSTRUCTOR：构造方法
• LOCAL_VARIABLE：局部变量

@Target({ElementType.METHOD,ElementType.TYPE})

1. @Retention

指定注解，生命周期（保留到哪个阶段）

SOURCE  → 源码阶段，编译后丢弃（注释级别，仅编译器看见，class不存在）
CLASS   → 编译保留在class，运行时JVM丢弃【默认策略】
RUNTIME → 运行时仍然保留，可以通过反射读取（自定义框架注解几乎都用这个！）

想在运行时通过反射获取注解信息，必须写：@Retention(RetentionPolicy.RUNTIME)

1. @Documented

使用 javadoc 生成 API 文档时，把注解信息纳入文档

1. @Inherited

可继承：父类标记该注解，子类自动继承这个注解

⚠️注意：只对【类】有效；方法、属性无效

1. @Repeatable（JDK8）：可重复注解（拓展了解）

自定义注解（自己创建注解）

语法：@interface

// 元注解约束
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    // 注解的【属性】，格式：类型 名称() [default 默认值];
    String value() default "";
    int age() default 18;
    String[] tags() ;
}

使用自定义注解

// 只有一个属性名叫value，可以省略属性名
@MyAnnotation("测试")
public void func(){

}
// 多个属性
@MyAnnotation(value="demo",age=20,tags={"a","b"})

关键语法规则

1. 属性支持类型：基本类型、String、枚举、注解、以上类型数组

2. 如果属性没有设置default默认值，使用注解时必须显式赋值

3. 特殊约定：属性名叫做value，并且只有这一个属性，赋值时可以省略value=

注解如何生效？

注解本身只是标记！必须配合反射机制解析

示例：通过反射读取运行时注解

// 获取方法
Method method = Test.class.getMethod("func");
// 判断是否存在注解
if(method.isAnnotationPresent(MyAnnotation.class)){
    MyAnnotation anno = method.getAnnotation(MyAnnotation.class);
    System.out.println(anno.value());
}

Spring、Mybatis 框架底层大量使用：自定义注解 + 反射实现功能。

异常-Exception

一、什么是异常

程序运行过程中出现的不正常情况（错误），会打断正常指令流。

Java 使用面向对象方式管理异常：异常本身就是一个对象。

区分：

• 编译期异常：写代码编译器就报错
• 运行时异常：编译正常，运行程序崩溃

二、异常体系结构图（核心）

java.lang.Throwable
├─ Error 【错误】系统级严重问题，程序无力处理，不用捕获
│    StackOverflowError、OutOfMemoryError
└─ Exception 【异常】程序层面，可以捕获处理
     ├─ RuntimeException 运行时异常（非受检异常）
     │    NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException
     └─ 其他Exception：编译期异常（受检异常 CheckedException）
          IOException、FileNotFoundException、SQLException

概念区分

1. Error（错误）

   虚拟机内部故障、资源耗尽。程序代码无法修复，不需要 try-catch 捕获。

2. Exception（异常）

   程序逻辑问题，可以处理。分为两类：

   ✅ 运行时异常（RuntimeException）【非受检异常】

   编译不强制要求捕获 / 声明；一般由代码书写 bug 导致。

   ✅ 编译期异常（受检异常 CheckedException）

   编译器强制要求：要么try-catch捕获，要么throws抛出，否则编译报错。

三、异常处理两大方案

方案 1：try-catch-finally 捕获处理

语法模板

try{
    // 可能出现异常的代码
}catch(异常类型 e){
    // 异常发生后的处理逻辑
}finally{
    // 无论是否异常，【一定会执行】，唯一例外：System.exit(0)
}

细节考点

1. try不能单独存在，必须搭配 catch 或 finally
2. 多个 catch：小范围异常写前面，大范围异常写后面（子类在前，父类在后）

try{

}catch(NullPointerException e){

}catch(Exception e){ //父类放最后
}

1. finally 典型用途：释放资源（文件流、数据库连接、IO 流）

try-catch-resources（JDK7 新特性）

自动实现资源关闭，不用手写 finally 关闭流

try(InputStream is = new FileInputStream("a.txt")){

}catch(IOException e){

}

方案 2：throws 向上抛出异常

如果当前方法不想处理异常，可以把异常抛给调用者

// 抛出受检异常，调用者必须处理
public void readFile() throws IOException{

}

⚠️区别：

• try-catch：自己处理异常，异常到此结束
• throws：不处理，甩锅给上层调用方法

四、主动抛出异常 throw

手动创建异常对象并抛出

int age = -5;
if(age < 0){
    throw new RuntimeException("年龄不能为负数");
}

throw（小写）：方法内部主动抛出对象

throws（复数）：方法声明上，标识该方法可能抛出的异常

五、自定义异常

业务场景内置异常不够用时，自己定义异常类

1. 自定义受检异常：继承 Exception

2. 自定义运行时异常：继承 RuntimeException（项目最常用）

   示例：

//自定义运行时异常
public class AgeIllegalException extends RuntimeException{
    public AgeIllegalException(String msg){
        super(msg);
    }
}

使用：

if(age < 0){
    throw new AgeIllegalException("年龄非法");
}

六、高频重点考题

1.finally 一定会执行吗？

✅绝大多数情况一定会执行

❌唯一打断情况：System.exit(0); 终止 JVM，finally 不再执行

2.try 里有 return，finally 执行时机

先执行 finally 代码，再执行 return

public static int test(){
    try{
        return 10;
    }finally{
        System.out.println("finally执行");
    }
}
//输出：finally执行  然后返回10

⚠️注意：不要在 finally 中写 return！会覆盖 try 的返回值，屏蔽异常，属于不规范代码。

1. 受检异常 vs 运行时异常总结

• 运行时异常 (RuntimeException)：编译不强制处理；属于代码 bug，尽量提前判断避免
• 受检异常：编译器强制处理；属于外部不可控情况（文件不存在、网络故障）

1. 常用异常举例

运行时异常：

NullPointerException空指针

当应用程序试图在需要对象的地方使用 null 时

ArrayIndexOutOfBoundsException数组越界

用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引

ClassCastException类型转换异常

当试图将对象强制转换为不是实例的子类时，抛出该异常。

ArithmeticException数学运算异常

当出现异常的运算条件时，抛出此异常。

NumberFormatException数字格式不正确异常

编译异常：

IOException、FileNotFoundException、SQLException

1. 异常链

捕获异常后抛出新异常时，可以把原始异常作为 cause 保存，保留完整堆栈信息

throw new 业务异常("操作失败",e);

异常链（Exception Chaining） 是一种将一个异常传递给另一个异常的技术。它允许我们在捕获一个异常后，抛出另一个新的异常，同时把原始异常（底层原因）完整地保留并记录在新的异常内部。

1. 为什么需要异常链？（痛点）

在复杂的系统中，异常通常具有层次性。假设这样一个场景：

1. 底层（数据库层）：执行 SQL 时抛出了 SQLException。

2. 中层（服务层）：捕捉到 SQLException，如果直接把它往外抛，会显得太底层、太专业（业务调用方不关心你是不是 SQL 错误）。或者如果你把它吞掉，换成抛出一个自定义的 ServiceException：

   catch (SQLException e) { throw new ServiceException("用户注册失败"); }

   问题来了：虽然外层成功抛出了符合业务的 ServiceException，但原本的 SQLException 被丢弃了。如果数据库连接串写错或者表名写错，由于丢失了底层异常的堆栈信息（Stack Trace），排查错误会变得异常困难。

异常链完美解决了这个问题：它在抛出新异常的同时，把旧异常“栓”在新异常身上，形成一条链条。

1. Java 是如何支持异常链的？

在 Java 中，所有的异常最终都继承自 Throwable 类。Throwable 及其子类在设计时就内置了对异常链的支持：

1. 构造方法支持传入 cause（原因）： 几乎所有标准异常类和自定义异常类，都提供了一个接收 Throwable 参数的构造方法：

   public MyException(String message, Throwable cause) { super(message, cause); // 传给父类 Throwable 保存 }

2. initCause() 方法： 如果使用的异常类没有提供带 cause 参数的构造方法，可以通过调用对象的 initCause(Throwable cause) 方法来手动绑定。

3. 代码示例

步骤 1：定义一个自定义业务异常

public class UserServiceException extends RuntimeException {
    // 提供带有 cause 参数的构造器
    public UserServiceException(String message, Throwable cause) {
        super(message, cause);
    }
}

步骤 2：在业务代码中捕获并链式抛出

public class UserService {
    public void registerUser() {
        try {
            // 模拟底层代码，抛出了底层的 SQLException
            // throw new java.sql.SQLException("数据库连接超时");
            
            // 模拟发生异常
            int i = 1 / 0; 
            
        } catch (Exception e) {
            // 捕获底层异常，包装成高层的业务异常抛出，并传入 e 作为 cause
            throw new UserServiceException("用户注册模块发生内部错误", e);
        }
    }
}

步骤 3：查看运行效果

当外层程序捕获到 UserServiceException 并打印堆栈信息（e.printStackTrace()）时，你会看到类似下面这样的输出：

com.example.UserServiceException: 用户注册模块发生内部错误
    at com.example.UserService.registerUser(UserService.java:15)
    ... (省略中间调用栈)
Caused by: java.lang.ArithmeticException: / by zero   <--- 底层原因清晰可见
    at com.example.UserService.registerUser(UserService.java:11)
    ...

• 注意看 Caused by:：这就是异常链的核心威力所在。它不仅告诉调用者上层业务出错了，还顺藤摸瓜地把底层的罪魁祸首完整展示了出来。

1. 总结与应用场景

• 核心作用：屏蔽底层实现细节，同时保留底层错误根源，实现“高层抛出业务异常，底层保留技术异常”。
• 常见应用：在现代企业级框架（如 Spring、MyBatis 等）中非常普遍。例如，当你使用 MyBatis 查询数据库出错时，它捕获到底层的 SQLException，并会将其包装并抛出它自己的 DataAccessException（带有异常链），方便开发者通过日志一眼看出是底层 SQL 语法错了、主键冲突了还是连接断了。

常用类

包装类

1) 针对八种基本数据类型相应的引用类型—包装类
2) 有了类的特点，就可以调用类中的方法

java 有 8 种基本数据类型，不是对象；

包装类：把基本类型包装成【对象】，位于java.lang包

💡记忆：除了 int→Integer、char→Character，其余基本类型首字母大写就是包装类。

装箱 & 拆箱（核心考点）

1. 手动装箱 / 拆箱（JDK5 之前写法）

装箱：基本类型 → 包装对象

int a = 10;
Integer num = Integer.valueOf(a); //装箱

拆箱：包装对象 → 基本类型

Integer num = new Integer(10);
int a = num.intValue(); //拆箱

1. 自动装箱、自动拆箱（JDK5 + 新特性，编译器自动转换）

//自动装箱
Integer i = 10; //等价 Integer i = Integer.valueOf(10);

//自动拆箱
int n = i; //等价 int n = i.intValue();

⚠️底层本质：自动装箱底层调用valueOf()；自动拆箱调用xxxValue()。

Integer 缓存机制

Integer.valueOf(int i) 存在缓存数组 cache[]

• 默认缓存范围：-128 ~ 127
• 范围内数字：直接复用缓存对象，==结果 true
• 超出范围：新建Integer对象，==结果 false

Integer a = 100;
Integer b = 100;
System.out.println(a == b); //true，在缓存区间

Integer c = 200;
Integer d = 200;
System.out.println(c == d); //false，超出缓存，两个不同对象

✅重要提醒：

== 比较：

两边如果是包装对象 → 比较地址

一边包装、一边基本类型 → 触发自动拆箱，比较数值

开发比较数值一律使用 .equals()，不要直接==

拓展缓存范围

只有 Byte、Short、Integer、Long 缓存区间固定[-128,127]

Character缓存 0~127

Float、Double没有缓存！

字符串 和 基本类型互相转换

1. 基本类型 → String

方式 1：变量 + ""

int num = 99;
String str = num + "";

方式 2：String.valueOf()（推荐）

String str = String.valueOf(num);

1. String → 基本类型

使用包装类的静态方法 parseXxx()

String s = "123";
int n = Integer.parseInt(s);
double d = Double.parseDouble(s);

⚠️注意：字符串格式不对，抛出 NumberFormatException 数字格式异常。

包装类与基本类型区别汇总

1. 默认值不同

• 基本类型：有默认值（int=0，boolean=false）
• 包装类：默认值 null

❗坑：包装类变量为 null 时，执行自动拆箱 → NullPointerException 空指针异常

Integer i = null;
int a = i; //运行报错！空指针

1. 存储位置

• 基本类型：局部变量存在栈
• 包装类对象：对象本体在堆

1. 使用场景

• 集合 List/Map 不能存放基本类型，只能存包装类

List<Integer> list = new ArrayList<>(); //正确
List<int> list = new ArrayList<>(); //编译报错

String 类

一、String 基本介绍

1. java.lang.String，代表字符串。
2. 字符串本质：字符序列，底层：
   • JDK8：private final char[] value
   • JDK9+：private final byte[] value（优化存储）
3. 重点：String 对象不可变（immutable）
   • value 数组被 final 修饰，数组引用不能指向新数组
   • 一旦字符串创建，内容无法修改

⚠️误区：

String s = "abc";
s = "def";

不是修改原来对象！只是让s引用指向新字符串对象，旧对象等待 GC 回收。

二、字符串创建两种方式

方式 1：直接赋值（字面量）

String str1 = "Java";

执行流程：

先去字符串常量池（堆内存）查找 “Java”

• 找到：直接复用常量池中的对象
• 没找到：在常量池中创建，引用指向常量池对象

方式 2：new String ()

String str2 = new String("Java");

执行流程：

1. 先检查常量池有没有"Java"，没有则放入常量池；
2. 在堆中创建新 String 对象，引用指向堆对象。

经典面试对比

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true  都指向常量池

String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s3 == s4); // false 堆中两个不同对象

三、字符串拼接规则

规则 1：编译期常量优化

两个字面量直接相加，编译器自动合并

String s1 = "a"+"b"+"c";
// 编译器优化等价于 String s1 = "abc";

规则 2：存在变量参与拼接 → 在堆创建新对象

String a = "a";
String s = a + "b";
//底层：new StringBuilder().append(a).append("b").toString()
//toString()底层 new String()，对象在堆，不进入常量池

intern () 方法

str.intern()：主动把字符串放入常量池

如果常量池已经存在相同内容，返回常量池引用；不存在则将对象放入常量池并返回池内引用。

四、== 和 equals ()

1. ==

   • 基本类型：比较数值
   • String 引用：比较对象地址

2. equals()

   • String 重写了 Object 的 equals，比较字符串内容

     ✅开发规范：判断字符串内容相等一律使用

     equals()

String s1 = new String("hello");
String s2 = "hello";
System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true

五、常用 API 方法

String str = "HelloJava";
str.length();                // 获取字符长度
str.charAt(索引);            // 获取指定位置字符
str.indexOf("Java");         // 查找子串起始索引，找不到返回-1
str.substring(begin,end);    // 截取字符串 [左闭右开)
str.trim();                  // 去除首尾空格(JDK11:strip支持全角空格)
str.toUpperCase();           // 转大写
str.toLowerCase();           // 转小写
str.contains("He");          // 是否包含子串
str.startsWith("He");        // 是否以指定开头
str.endsWith("va");          // 是否以指定结尾
str.split(",");              // 按照分隔符切割 → String数组
str.replace("a","b");        // 字符/字符串替换

六、不可变性带来的优缺点

✅优点：

1. 字符串常量池实现复用，节省内存
2. 哈希值只需要计算一次，适合作为 HashMap 的 key
3. 线程安全，多线程并发访问无问题

❌缺点：

频繁字符串拼接，不断产生新对象，产生大量垃圾。

👉大量拼接解决方案：StringBuilder / StringBuffer

Stringbuffer类

一、基础概念

java.lang.StringBuffer，可变字符序列

底层：char[]（JDK9 之后byte[]），数组没有被final修饰，可以直接扩容修改内容，不会频繁创建新对象。

对比：

• String：不可变，每次拼接产生新对象，大量拼接效率极低
• StringBuffer：可变容器，原地修改字符数组

二、构造方法

// 空参，默认容量 16
StringBuffer sb1 = new StringBuffer();

// 指定初始容量
StringBuffer sb2 = new StringBuffer(50);

// 根据字符串创建，容量 = 字符串长度 + 16
StringBuffer sb3 = new StringBuffer("hello");

默认容量 16：预留空间，减少频繁扩容。

三、核心常用方法（全部支持链式调用）

StringBuffer sb = new StringBuffer();

sb.append("java");       // 末尾追加（最常用）
sb.insert(1,"A");        // 指定索引位置插入
sb.delete(0,2);          // 删除 [左闭右开区间]
sb.replace(0,1,"Hi");    // 区间替换
sb.reverse();            // 字符串反转
sb.setCharAt(0,'X');     // 修改指定位置字符

sb.length();             // 当前实际字符长度
sb.capacity();           // 获取底层数组总容量

// 转换成String
String str = sb.toString();

四、扩容机制（重点）

1. 当 append 后字符超出容量，触发扩容
2. 扩容公式：新容量 = 原有容量 * 2 + 2
3. 如果扩容后依然不够，则直接使用所需最小容量
4. 底层：新建更大数组，复制旧数组内容

示例：初始容量 16 → 扩容后 16*2+2=34

五、StringBuffer 和 String 的互相转换

// String → StringBuffer
String str = "hello";
StringBuffer sb = new StringBuffer(str);

// StringBuffer → String
String result = sb.toString();

六、高频易错考点

1. append 返回的是自身 this 对象，所以支持链式调用

sb.append("a").append("b").append("c");

1. toString() 会新建 String 对象，不会复用底层数组
2. 不要频繁 new StringBuffer，预估长度尽量指定初始容量，避免多次扩容
3. 线程不安全场景误用 StringBuffer 不能带来收益，反而降低速度；单线程优先StringBuilder

七、经典误区

❌错误理解：

“StringBuffer 比 String 快”

✅准确说法：

少量拼接差距不大；大量循环拼接时，String 不会产生大量临时对象，性能差距巨大。

StringBuilder 完整知识点

一、基础介绍

java.lang.StringBuilder

可变字符序列，用于字符串拼接，JDK1.5 推出

底层：字符数组（JDK8 char [] / JDK9 byte []），数组无 final 修饰，可以直接修改，不会频繁创建新字符串对象。

和 StringBuffer API 几乎完全一致，唯一区别：没有 synchronized 同步锁。

二、构造方法

// 1.无参构造：初始容量 16
StringBuilder sb1 = new StringBuilder();

// 2.指定初始容量
StringBuilder sb2 = new StringBuilder(30);

// 3.传入字符串，容量 = 字符串长度 + 16
StringBuilder sb3 = new StringBuilder("hello");

三、核心常用方法（支持链式调用）

StringBuilder sb = new StringBuilder();

sb.append("Java");          // 末尾追加（最常用）
sb.insert(1,"_");           // 指定位置插入
sb.delete(0,2);             // 删除 [start,end) 左闭右开
sb.replace(0,1,"Hi");       // 区间替换
sb.reverse();               // 字符反转
sb.setCharAt(0,'A');        // 修改指定下标字符

sb.length();    // 实际字符个数
sb.capacity();  // 底层数组总容量

// 转为String（生成新字符串对象）
String str = sb.toString();

原理：所有修改操作直接操作底层数组，不产生新对象。

四、扩容机制

触发时机：追加内容后，字符总数超过当前容量

默认扩容公式：

新容量 = 原有容量 * 2 + 2

如果扩容后的容量依旧不够存放，直接采用所需最小容量。

示例：

初始容量 16 → 扩容：16×2+2 = 34

💡优化建议：如果你提前预估字符串长度，创建时指定容量，避免多次扩容、数组复制，提升性能。

五、String / StringBuilder / StringBuffer 三者终极对比

开发准则：

绝大多数业务代码（单线程） → 优先 StringBuilder

六、相互转换

// String → StringBuilder
String s = "demo";
StringBuilder sb = new StringBuilder(s);

// StringBuilder → String
String res = sb.toString();

七、高频考点 & 易错点

1. 线程不安全典型场景

   多个线程同时操作同一个 StringBuilder 对象，会出现数据错乱、数组越界异常。

解决方案：多线程改用 StringBuffer，或者每个线程新建独立 StringBuilder。

1. 循环拼接大坑

// ❌性能极差！每次循环产生大量中间String对象
String str = "";
for(int i=0;i<10000;i++){
    str += i;
}

// ✅推荐写法
StringBuilder sb = new StringBuilder();
for(int i=0;i<10000;i++){
    sb.append(i);
}
String str = sb.toString();

1. 编译器优化误区

String s = "a"+"b"+"c";
// 编译期优化为 String s = "abc";

String a = "a";
String s = a + "b";
// 底层自动 new StringBuilder 拼接
// 但是！只限于**单行简单拼接，循环内不会优化！**

Math 类

一、基础介绍

java.lang.Math

1. 提供大量数学计算静态方法，全部是 static，不需要 new 对象，直接类名。方法调用
2. 构造方法被 private 修饰，无法实例化
3. 包含两个常用静态常量

Math.PI    //圆周率 π ≈ 3.1415926535...
Math.E     //自然常数 e ≈ 2.71828...

调用方式示例：

double num = Math.abs(-10);

二、常用方法分类

1. 绝对值 abs ()

Math.abs(-5);        //int 绝对值 → 5
Math.abs(-3.14);     //double 绝对值 →3.14

1. 取最值 max /min

Math.max(10,20);     //返回较大值 20
Math.min(10,20);     //返回较小值 10
//支持int long float double

1. 四舍五入、向上取整、向下取整

//1.四舍五入 → long
Math.round(3.4);   //3
Math.round(3.5);   //4

//2.向上取整（天花板），返回double
Math.ceil(3.1);    //4.0
Math.ceil(-3.1);   //-3.0

//3.向下取整（地板），返回double
Math.floor(3.9);   //3.0
Math.floor(-3.1);  //-4.0

⚠️极易踩坑：负数的 ceil、floor 不要凭直觉判断！

1. 幂运算、开平方

Math.pow(2,3);    //2^3 = 8.0  参数、返回值都是double
Math.sqrt(16);    //平方根 √16 =4.0

1. 随机数 random ()

Math.random(); 
// 返回 [0.0 , 1.0) 之间的随机小数，包含0.0，不包含1.0

✅业务常用公式：获取 [a,b] 的随机整数

// 范围 [min,max]
int num = (int)(Math.random() * (max - min + 1)) + min;

//示例：1~10随机整数
int r = (int)(Math.random() * 10) + 1;

拓展：JDK 推荐也可以使用 java.util.Random 类，功能更强。

1. 三角函数（参数是弧度，不是角度）

Math.sin(弧度);
Math.cos(弧度);
Math.tan(弧度);
Math.toRadians(角度); //角度 → 弧度
Math.toDegrees(弧度); //弧度 → 角度

三、Math vs StrictMath（了解）

• Math：部分方法平台相关，底层可以使用 CPU 优化，计算结果微小误差

• StrictMath：严格遵循浮点运算标准，所有平台计算结果完全一致；速度略慢。

  日常开发几乎只用 Math。

四、高频易错点

1. round() 返回 long；ceil() / floor() 返回 double

double d = Math.ceil(2.2); //d=3.0 是小数类型，不是int

1. Math.random () 左闭右开 [0.0,1.0)
2. pow 返回 double，即使整数次方，不能直接当 int 使用，需要强转
3. 三角函数传入的是弧度，直接传入角度结果错误

java.util.Arrays

一、概述

java.util.Arrays：数组工具类

1. 包：java.util，使用需要导包
2. 所有方法都是 static 静态方法，直接 Arrays.方法名() 调用
3. 构造方法私有，不能 new Arrays 对象
4. 作用：提供数组打印、排序、查找、复制、填充、比较等工具方法

import java.util.Arrays;

二、常用核心方法

1. toString () 打印数组

普通数组直接打印输出地址，Arrays.toString 打印数组内容

int[] arr = {1,3,2};
System.out.println(Arrays.toString(arr));
//输出：[1, 3, 2]

注意：只支持一维数组

多维数组使用：deepToString()

int[][] arr2 = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(arr2));

1. sort () 数组排序

① 基本类型数组：升序排序（快速排序）

int[] arr = {5,2,9,1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 5, 9]

② 对象数组 / 自定义排序（引用类型）

Arrays.sort(数组, Comparator) 支持自定义顺序（只能用于包装类型数组，不能用 int []，要用 Integer []）

Integer[] arr = {5,2,9,1};
//降序
Arrays.sort(arr, (a,b)->b-a);

重点：基本类型 sort 不支持直接传入比较器！

拓展：可以指定区间排序 Arrays.sort(arr,from,to) 左闭右开

1. binarySearch () 二分查找

前提条件：数组必须先升序排序！否则结果不可预测

• 找到：返回元素索引
• 找不到：返回 -(插入点)-1

int[] arr = {1,2,5,9};
int index = Arrays.binarySearch(arr,5); //返回2
int index2 = Arrays.binarySearch(arr,3); //找不到，返回负数

4. copyOf () /copyOfRange () 数组复制

copyOf (数组，新长度)

从头复制，可扩容 / 缩容

int[] old = {1,2,3};
int[] newArr = Arrays.copyOf(old,5);
// [1,2,3,0,0]

copyOfRange (数组，起始索引，结束索引)

区间复制，左闭右开 [start,end)

int[] arr = {10,20,30,40};
int[] sub = Arrays.copyOfRange(arr,1,3);
// [20,30]

⚠️区别：

数组自身 clone () 和 Arrays.copyOf 效果类似；copyOf 底层调用 System.arraycopy。

1. fill () 数组填充

给数组全部 / 指定区间统一赋值

int[] arr = new int[5];
Arrays.fill(arr,8); //全部填充8
// [8,8,8,8,8]

Arrays.fill(arr,1,3,6); //下标1~2填充6

1. equals () 判断两个数组内容是否相同

int[] a = {1,2,3};
int[] b = {1,2,3};
System.out.println(Arrays.equals(a,b)); //true

⚠️误区：

a==b 比较数组地址；

Arrays.equals() 比较数组中每个元素的值。

多维数组比较使用：deepEquals()

三、一维数组 vs 多维数组配套方法汇总

四、高频易错考点

1. binarySearch 二分查找必须先排序，无序数组结果错误
2. Arrays.sort 基本类型只能升序；想要降序必须使用包装数组 + Comparator
3. copyOf 产生新数组，原数组不会改变
4. Arrays.toString 不能打印多维数组，只会输出地址，要用 deepToString
5. 数组是引用类型，equals() 默认比较地址，一定要用 Arrays.equals 比较元素

五、拓展：数组转集合（asList）⭐大坑

Integer[] nums = {1,2,3};
List<Integer> list = Arrays.asList(nums);

⚠️重要坑：

1. asList 接收引用类型数组；不能直接传基本类型数组int[]
2. 返回的 List 是 Arrays 内部静态类，固定大小！不能 add/remove，会抛出异常
3. 集合和原数组互相引用，修改数组元素，集合同步变化

Java System 类 完整知识点

一、概述

java.lang.System

1. 全部成员都是静态，直接 System.xxx 调用，无需实例化
2. 构造方法 private，禁止 new System()
3. 代表程序运行平台系统资源，提供标准输入输出、时间、数组复制、退出程序、环境变量等操作

二、三大静态常量（流对象）

// 标准输入流：控制台键盘输入
public static final InputStream in;
// 标准输出流：控制台打印（常用 System.out.println()）
public static final PrintStream out;
// 标准错误输出流：红色字体输出，优先打印，不受输出缓冲区控制
public static final PrintStream err;

区分 out 和 err：

• out：普通信息输出，缓冲区缓存，顺序不一定立刻打印
• err：错误信息，立即输出，控制台一般红色

三、核心常用方法

1. arraycopy () 数组复制⭐底层非常重要

public static void arraycopy(
Object src,     //源数组
int srcPos,     //源数组起始索引
Object dest,    //目标数组
int destPos,    //目标数组起始索引
int length      //复制元素个数
)

示例：

int[] a = {10,20,30,40,50};
int[] b = new int[5];
System.arraycopy(a,1,b,0,3);
// b = [20,30,40,0,0]

✅特点：

• native 本地方法，由 C 实现，速度极快

• Arrays.copyOf/copyOfRange 底层本质调用 System.arraycopy

  ⚠️注意：自己复制自己、索引越界会抛出 ArrayIndexOutOfBoundsException

1. 获取时间

// 当前时间毫秒数：从【1970-01-01 00:00:00 UTC】到现在的毫秒
long time1 = System.currentTimeMillis();

// JDK1.8新增：纳秒！用于计算代码执行耗时，不代表系统日期
long time2 = System.nanoTime();

使用场景：计算程序运行耗时

long start = System.currentTimeMillis();
//执行代码...
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-start)+"ms");

区别：

currentTimeMillis：基于系统时钟，可以手动修改系统时间，数值会跳变

nanoTime：基于虚拟机计时器，适合计算时间间隔，不适合获取日期

1. exit (状态码) 终止 JVM

System.exit(0);  //正常退出
System.exit(1);  //异常退出，非0代表程序异常终止

⚠️重点考点：

执行 System.exit() 直接关闭虚拟机，finally 代码块不会执行！

1. gc () 建议垃圾回收

System.gc();

作用：向 JVM建议执行垃圾回收；

只是建议，不保证立刻执行 GC，什么时候回收由虚拟机决定。

1. 获取环境变量、系统属性

// 获取单个系统属性
String path = System.getProperty("user.dir"); //当前项目工作目录
String os = System.getProperty("os.name");    //操作系统名称

//获取环境变量
String javaHome = System.getenv("JAVA_HOME");

常用属性：

user.name 当前用户名

java.version Java 版本

四、输入输出重定向（了解）

//把输出写入文件，不再打印控制台
System.setOut(new PrintStream("log.txt"));

五、高频面试易错点汇总

1. System.arraycopy 是 native 方法，效率高于手动 for 循环复制数组
2. System.exit(0) 停止 JVM，会跳过 finally 执行
3. System.gc() 只是通知虚拟机，不能强制垃圾回收
4. currentTimeMillis() 毫秒时间戳；nanoTime() 仅用于计算间隔
5. System.out 和 System.err 是两个不同流，打印顺序无法保证

六、拓展对比

Arrays.copyOf → 底层调用 System.arraycopy

System.arraycopy 是底层原生方法，开发中很少直接手写，框架大量使用。

BigInteger 和 BigDecimal

一、背景引入

1. 基本数据类型局限long、int有取值上限；float/double 浮点运算存在精度丢失（二进制存储小数缺陷）。

System.out.println(0.1 + 0.2);
//输出 0.30000000000000004，不是0.3

1. 解决方案

• BigInteger：超大整数（无上限）
• BigDecimal：高精度小数，金融、金额计算必须使用包：java.math

二、BigInteger（超大整数）

1. 创建对象

⚠️不能直接使用 + - * / 运算符！只能调用方法

//方式1：字符串构造【推荐】
BigInteger num1 = new BigInteger("12345678901234567890");

//方式2：long转（数值不能超过long范围）
BigInteger num2 = BigInteger.valueOf(100);

1. 常用运算方法

BigInteger a = new BigInteger("20");
BigInteger b = new BigInteger("7");

a.add(b);      //加法 a+b
a.subtract(b); //减法 a-b
a.multiply(b); //乘法 a*b
a.divide(b);   //除法（整除，不能有余数，否则报错）
a.remainder(b);//取余数
a.mod(b);      //模运算

a.abs();       //绝对值
a.max(b);      //最大值
a.min(b);      //最小值

重点：所有运算返回新 BigInteger 对象，原对象不可变！

1. 带余数除法（divideAndRemainder）

BigInteger[] res = a.divideAndRemainder(b);
res[0] 商，res[1]余数

三、BigDecimal（高精度小数 ⭐面试 & 业务重点）

1. 对象创建

// ❌不推荐！double构造依然存在精度损失
BigDecimal num = new BigDecimal(0.1);

// ✅推荐两种写法
BigDecimal num1 = new BigDecimal("0.1");    //字符串构造
BigDecimal num2 = BigDecimal.valueOf(0.1);   //valueOf底层自动转字符串

1. 四则运算

同样不可变，运算返回新对象

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");

a.add(b);        //加
a.subtract(b);   //减
a.multiply(b);   //乘

// ⚠除法极易报错！除不尽会抛出 ArithmeticException
a.divide(b);

1. 除法 & 保留小数、舍入模式（核心）

除法必须指定保留位数 + 舍入模式

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");
//保留2位小数，四舍五入
a.divide(b,2,BigDecimal.ROUND_HALF_UP);

常用舍入模式：

1. ROUND_HALF_UP：四舍五入（日常最常用）
2. ROUND_UP：向上取整
3. ROUND_DOWN：直接截断，舍弃后面小数

4. ROUND_HALF_EVEN：银行家舍入（JDK 默认）

5. 大小比较

❌禁止使用 ==（比较地址）

❌尽量不要用 equals ()！equals 会比较小数位数

BigDecimal d1 = new BigDecimal("2.0");
BigDecimal d2 = new BigDecimal("2.00");
System.out.println(d1.equals(d2)); //false！位数不同

✅正确方式：compareTo()

// 返回值：
// 0 相等  >0 当前数大  <0 当前数小
if(d1.compareTo(d2) == 0){
    System.out.println("数值相等");
}

1. 小数点操作

bd.setScale(2,BigDecimal.ROUND_HALF_UP); //保留2位小数

四、BigInteger vs BigDecimal 对比

共性：

1. 不可变类，每次计算产生新对象
2. 不支持运算符重载，必须调用方法
3. 在java.math包

五、高频易错考点汇总

1. double 直接传入 BigDecimal 构造器会精度丢失，优先字符串构造
2. BigDecimal 除法如果无法整除，必须指定精度和舍入模式，否则抛异常
3. equals 会比较小数位数；数值比较用compareTo
4. 对象不可变，运算结果需要接收返回值

//错误写法
bd.add(xxx); //结果丢失，原对象不变
//正确
bd = bd.add(xxx);

1. double/float 不要用于金额计算，强制使用 BigDecimal

六、开发规范（金融项目）

1. 数据库金额：decimal 类型
2. Java 代码：使用 BigDecimal 存储金额
3. 运算统一指定保留小数位数与四舍五入

Java 日期时间全套知识点

分为两大体系：

1. 旧版（JDK1.0 ~ JDK7）：Date、SimpleDateFormat、Calendar

   ❌缺点：线程不安全、API 设计差、可变性

2. 新版（JDK8+ 推荐）java.time 包：LocalDate、LocalTime、LocalDateTime、DateTimeFormatter、Instant、Duration、Period

   ✅优点：不可变、线程安全、设计优雅，项目优先使用

一、旧 API（了解，尽量不推荐新项目使用）

1. java.util.Date

代表瞬时时间点（毫秒时间戳）

// 当前系统时间
Date date = new Date();
// 指定毫秒时间戳构造
Date date2 = new Date(1750000000000L);

// 获取时间戳毫秒
long time = date.getTime();
// 设置时间戳
date.setTime(1750000000000L);

⚠️缺点：

1. Date对象可变；setTime 修改原有对象

2. 无法直接获取年、月、日；月份从 0 开始（0=1 月，大坑）

3. SimpleDateFormat 日期格式化

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// Date → 字符串
String str = sdf.format(new Date());
// 字符串 → Date
Date date = sdf.parse("2026-07-28 12:30:00");

⚠️致命坑：SimpleDateFormat 线程不安全！多线程共用会异常。

常用格式符号：

• yyyy 4 位年份
• MM 月份 (01~12)
• dd 日期
• HH 24 小时制；hh12 小时制
• mm分钟；ss秒；SSS毫秒

1. Calendar 日历类（JDK1.1 替代 Date）

抽象类，常用实现 GregorianCalendar

Calendar cal = Calendar.getInstance();
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH); // 依旧 0代表一月！
int day = cal.get(Calendar.DAY_OF_MONTH);

// 设置日期
cal.set(2026,6,28);
Date date = cal.getTime(); //Calendar转Date

缺点：依旧可变，API 别扭。

二、JDK8 全新时间包 java.time（⭐重点，面试核心）

所有对象不可变，修改操作返回新对象；线程安全！

1. 核心类区分

1. 创建对象

// 获取当前时间
LocalDate nowDate = LocalDate.now();
LocalTime nowTime = LocalTime.now();
LocalDateTime nowDT = LocalDateTime.now();

// 指定时间创建
LocalDate date = LocalDate.of(2026,7,28);
LocalDateTime dt = LocalDateTime.of(2026,7,28,14,30);

// Instant 时间戳
Instant instant = Instant.now();
// 时间戳转Instant
Instant instant2 = Instant.ofEpochMilli(1750000000000L);

1. 常用运算（不可变！操作返回新对象）

LocalDateTime time = LocalDateTime.now();

time.plusDays(3);    //加3天
time.minusHours(2);  //减2小时
time.plusMonths(1);  //加1月

// 获取单独字段
int month = time.getMonthValue(); //月份1~12（正常！不再从0开始）
int day = time.getDayOfMonth();

// 修改指定字段
time.withYear(2027);

1. 格式化与解析 DateTimeFormatter ✅线程安全

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();

//时间 → 字符串
String str = now.format(formatter);
//字符串 → 时间
LocalDateTime dt = LocalDateTime.parse("2026-07-28 15:20:00",formatter);

1. 时间间隔计算 Duration / Period

// 时分秒间隔（LocalDateTime / Instant）
LocalDateTime t1 = LocalDateTime.of(2026,7,28,10,0);
LocalDateTime t2 = LocalDateTime.of(2026,7,28,12,30);
Duration duration = Duration.between(t1,t2);
System.out.println(duration.toHours()); //相差小时

// 年月日间隔（仅LocalDate）
LocalDate d1 = LocalDate.of(2026,1,1);
LocalDate d2 = LocalDate.of(2026,7,28);
Period period = Period.between(d1,d2);
period.getMonths();

1. 新旧 API 互相转换（项目兼容必备）

// LocalDateTime ↔ Date
//1. LocalDateTime -> Date
Instant instant = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant();
Date date = Date.from(instant);

//2. Date -> LocalDateTime
LocalDateTime ldt = new Date().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();

1. 时区简单说明

LocalDateTime不带时区，跨时区业务（海外系统）必须使用 ZonedDateTime。

服务器一般统一使用 UTC 时间存储。

三、新旧 API 核心对比

四、高频易错考点

1. 旧 Date、Calendar 月份从 0 开始；LocalDateTime 月份 1~12
2. SimpleDateFormat 禁止多线程共享；新项目一律用 DateTimeFormatter
3. LocalDateTime 无时区；不要直接用于跨时区业务
4. Duration 处理时分秒；Period 只处理年月日，不能混用
5. 所有 JDK8 时间对象修改后返回新实例，原对象不变

集合

一、集合概述

集合：java.util包下，容器，用来存储多个对象。

区分数组和集合：

1. 数组：长度固定；可以存基本类型 + 引用类型
2. 集合：长度可变；只能存储引用类型（对象），基本类型会自动装箱

集合两大根接口：

1. Collection 单列集合：一次存一个对象
2. Map 双列集合：一次存一对对象（key=value 键值对）

集合整体架构图

Collection(单列)
├─ List【有序、可重复、有索引】
│   ├─ ArrayList   数组实现
│   ├─ LinkedList  双向链表
│   └─ Vector      数组实现(古老、同步)
├─ Set【无序、不可重复、无索引】
│   ├─ HashSet         哈希表
│   │   └─ LinkedHashSet 哈希表+双向链表(有序)
│   └─ TreeSet         红黑树(自然排序)
└─ Queue【队列】
    └─ ArrayDeque、PriorityQueue

Map(双列 key-value)
├─ HashMap         哈希表
│   └─ LinkedHashMap 哈希表+链表(有序)
├─ TreeMap         红黑树，按键排序
├─ Hashtable       古老，同步（淘汰）
└─ Properties      键值对，用于配置文件

第一部分：Collection 接口

通用常用方法（所有 List、Set 都拥有）

boolean add(E e)                添加元素
boolean remove(Object o)        删除指定元素
void clear()                    清空集合
boolean contains(Object o)      判断是否包含元素
boolean isEmpty()               判断是否为空
int size()                      获取元素个数
Object[] toArray()              转数组

1. List 接口

特点：有序、可重复、带有索引，支持根据索引增删查改。

特有方法（带索引操作）

get(int index)
set(int index, E element)
add(int index, E element)
remove(int index)

① ArrayList（重点）

底层：可变 Object 数组

• 默认初始容量：10

• 扩容机制：原容量 1.5倍

• 查询快、随机访问快；中间增删慢（需要移动元素）

• 线程不安全；效率高

  适用：大量查询，少量增删

② LinkedList

底层：双向链表

• 没有扩容概念，按需创建节点

• 查询慢（需要遍历）；首尾增删速度快

• 线程不安全

  特有方法（队列 / 栈操作）

addFirst() addLast()
getFirst() getLast()
removeFirst() removeLast()

③ Vector（了解，基本淘汰）

底层数组，扩容 2 倍；方法加synchronized，线程安全，性能差。

开发 90% 场景优先 ArrayList！

1. Set 接口

特点：无序、不可重复、无索引，不能用普通 for 循环遍历，只能迭代器 / 增强 for。

① HashSet

底层：哈希表（数组 + 链表 + 红黑树）

元素唯一依靠：hashCode() + equals()

判断重复规则：

1. 先比较哈希值 hashCode ()
2. 哈希值不同 → 直接不重复
3. 哈希值相同 → 再调用 equals ()，true 判定重复

⚠️自定义类存入 HashSet，必须重写 hashCode 和 equals！

特性：无序，不保证存储顺序；线程不安全。

② LinkedHashSet

继承 HashSet；底层哈希表 + 双向链表

✅存取有序；依然不能重复。

适合：需要去重同时保留添加顺序。

③ TreeSet

底层：红黑树

✅自动排序（自然排序）

要求：存储元素实现 Comparable 接口，或者构造传入Comparator

⚠️元素不能为 null；根据比较规则去重，不是 equals。

1. Queue 队列（简单了解）

先进先出 FIFO

• ArrayDeque：数组双端队列
• PriorityQueue：优先队列（自动排序）

Collection 遍历方式

1. 增强 for 循环（底层迭代器）

for(Object obj : list){}

1. Iterator 迭代器

Iterator<String> it = list.iterator();
while(it.hasNext()){
    String s = it.next();
}

⚠️并发异常：迭代遍历集合时，不要用集合 add/remove；想要删除用迭代器it.remove()

1. List 额外支持普通 for 循环（有索引）

第二部分：Map 双列集合

存储格式：key=value，键唯一，值可重复；

一个 key 只能对应一个 value；后存入的 value 覆盖旧 value。

Map 通用方法

put(k,v)        添加/覆盖键值对
remove(key)     根据key删除
get(key)        根据key获取value
containsKey(key) 判断是否存在键
containsValue(value) 判断是否存在值
keySet()        获取所有key【重点】
entrySet()      获取所有键值对对象【重点】
clear()
size()

Map 三种遍历方式

1. keySet () 先拿所有键，再 get 取值

Set<String> keys = map.keySet();
for(String key : keys){
    map.get(key);
}

1. entrySet () 获取 Entry 键值对（效率更高，推荐）

Set<Map.Entry<String,Integer>> entries = map.entrySet();
for(Map.Entry entry : entries){
    entry.getKey();
    entry.getValue();
}

1. values () 只获取所有 value（无法拿到 key）

常用实现类

① HashMap（重中之重）

底层：哈希表（数组 + 链表 + 红黑树）JDK1.8 优化

参数：

• 默认容量：16

• 负载因子：0.75

• 扩容条件：元素个数 > 容量 * 负载因子 → 容量扩大 2 倍

• 树化阈值：链表长度 ≥8，数组长度≥64 → 链表转为红黑树；

  元素≤6 退化为链表。

特点：

• key 无序；key 允许一个 null，value 允许多个 null

• 线程不安全

  去重规则：key 对象重写

  hashCode() + equals()

② LinkedHashMap

继承 HashMap；哈希表 + 双向链表

✅存取有序；其他特性和 HashMap 一致。

可用来实现 LRU 缓存。

③ TreeMap

底层红黑树；按键自动排序

key 必须实现 Comparable 或传入比较器；key 不能为 null。

④ Hashtable（淘汰）

线程安全；key 和 value 都不允许 null；扩容 2 倍；性能差，基本不用。

⑤ Properties

继承 Hashtable；专门读取配置文件 xxx.properties；key、value 只能是字符串。

三、重要面试高频对比

HashMap vs HashTable

1. HashMap 线程不安全；Hashtable 方法加 synchronized，安全
2. HashMap 允许 key 一个 null；Hashtable 键值都不能 null
3. HashMap 初始容量 16，扩容 ×2；Hashtable 初始 11，扩容 ×2+1
4. Hashtable 古老，不推荐使用；多线程可用 ConcurrentHashMap

HashSet 和 HashMap 关系

1. HashSet 底层就是 HashMap！

2. HashSet 存储元素，作为 HashMap 的 key，value 统一是一个静态 Object 常量。

四、Collections 工具类（区分 Collection 接口！）

java.util.Collections 操作集合的静态工具类

Collections.sort(list);        //排序
Collections.shuffle(list);     //打乱顺序
Collections.max/min(list);
Collections.unmodifiableList() //返回不可变集合
//线程安全集合
Collections.synchronizedList(list);

⚠️注意：只是方法加锁，性能一般；高并发优先 JUC 工具。

五、高频坑 & 考点总结

1. 迭代遍历集合时，不能直接集合 add/remove → ConcurrentModificationException 并发修改异常
2. HashSet/HashMap 自定义对象作为 key，必须重写 hashCode 和 equals
3. ArrayList 初始容量 10，第一次 add 才初始化数组；扩容 1.5 倍
4. HashMap 负载因子 0.75，树化阈值 8，链表转红黑树
5. List 有序可重复；Set 无序不可重复；Map 键唯一
6. TreeSet/TreeMap 依靠比较器排序，不是 equals 去重
7. 集合存储的是对象引用地址，不是对象本身
8. 自动装箱：集合不能存基本类型 List<int> 报错，只能包装类 List<Integer>

六、线程安全小结

不安全：ArrayList、LinkedList、HashMap、HashSet

安全方案：

1. Collections.synchronizedXxx () 包装
2. JUC 并发包：CopyOnWriteArrayList、ConcurrentHashMap

泛型

一、什么是泛型

泛型：参数化类型，把类型当作参数传入类、接口、方法。

<>内的标识符代表未知类型，编译期确定。

核心目标：

1. 编译期类型检查，防止类型转换异常
2. 消除强制类型转换
3. 代码复用，一套代码支持多种数据类型

诞生：JDK 1.5 引入；泛型只存在编译期，运行时被擦除（类型擦除）

二、为什么需要泛型

没有泛型时，集合默认存储 Object：

List list = new ArrayList();
list.add("abc");
list.add(123); //编译不报错
String s = (String) list.get(1); //运行时报 ClassCastException

使用泛型：

List<String> list = new ArrayList<>();
list.add("abc");
// list.add(123); 编译直接报错！
String s = list.get(0); //无需强转

三、泛型的三种使用形式

1. 泛型类

格式：类名<泛型标识>

常用标识符约定（只是名字，无语法要求）

• E Element 元素（集合）
• T Type 类型
• K Key 键 、V Value 值（Map）
• R Return 返回值

public class MyBox<T> {
    private T data;
    public T getData(){ return data; }
    public void setData(T data){ this.data = data; }
}

//使用
MyBox<String> box = new MyBox<>();
box.setData("hello");

注意：创建对象时指定类型，这个类里面所有 T 都会被替换为指定类型。

1. 泛型接口

interface IStorage<T> {
    void save(T data);
}
//方式1：实现类确定类型
class StringStorage implements IStorage<String>{
    @Override
    public void save(String data) {}
}
//方式2：实现类继续保留泛型
class AnyStorage<T> implements IStorage<T>{
    @Override
    public void save(T data) {}
}

1. 泛型方法（⭐重点：和泛型类区分开）

泛型方法可以定义在普通类 / 泛型类上，方法自己拥有独立泛型参数

✅格式：返回值前声明泛型 <T>

//泛型方法
public static <T> T getFirst(List<T> list){
    return list.get(0);
}

⚠️关键区分：

• 泛型类的 T：创建对象时确定
• 泛型方法的 T：调用方法时自动推导类型

四、类型擦除

泛型是编译期概念，.class 字节码中不存在泛型信息！

编译流程：

1. 编译器利用泛型做类型校验
2. 擦除泛型参数，替换为原始类型（上限 Object / 指定边界类型）
3. 自动插入强制类型转换代码

示例：

List<String> list = new ArrayList<>();
list.add("aaa");
String s = list.get(0);

编译后字节码等价于：

List list = new ArrayList();
list.add("aaa");
String s = (String) list.get(0);

原始类型 RawType

不加泛型参数的集合：List list = new ArrayList();

原始类型会关闭泛型检查，尽量不要使用。

擦除规则

1. 无边界泛型 <T> → 擦除为 Object
2. 有上限 <T extends Number> → 擦除为 Number
3. 有下限不能单独用于类泛型（只能通配符）

五、通配符 ? Wildcard

? 代表任意未知类型，主要用于方法参数，不能用于定义泛型类 / 泛型方法。

1. 无界通配符 <?>

public void printList(List<?> list){
    for(Object o : list) System.out.println(o);
}

限制：

✅可以读取元素，读到 Object

❌不能 add 除 null 以外的任何元素（编译器不知道真实类型，禁止写入）

1. 上限通配符 ? extends T

? extends Animal：代表T 及其所有子类

public void test(List<? extends Animal> list){
    Animal a = list.get(0); //可读，向上转型
    // list.add(new Dog()); //编译报错！禁止写入
}

读取安全，写入不安全。生产者场景（读数据）

1. 下限通配符 ? super T

? super Dog：代表Dog 及其所有父类

public void test(List<? super Dog> list){
    list.add(new Dog());    //可以存入Dog及子类
    //Dog dog = list.get(0); //读取只能拿到Object，无法向下转型
}

写入安全，读取不安全。消费者场景（写入数据）

PECS 原则（高频面试）

Producer Extends，Consumer Super

• 只读取数据（生产者）：? extends T
• 只写入数据（消费者）：? super T
• 既要读又要写：不能使用通配符，直接确定泛型<T>

六、泛型边界（限定类型范围）

上限限定 <T extends 类/接口>

T 只能是该类或子类

// T必须是Number或者Number子类(Integer/Double等)
public <T extends Number> void method(T num){}

⚠️泛型没有多上限直接写法；想要同时多个约束，需要 T extends A & B

<T extends Serializable & Comparable>

❗注意：没有 <T super xxx> 写法！

下限只能用于通配符？，不能用于泛型声明。

七、泛型常见限制（

1. 不能使用泛型创建实例

T t = new T(); //编译报错！擦除后无法确定类型

1. 不能定义泛型数组

T[] arr = new T[10]; //报错
//可以通过反射创建：Array.newInstance

1. 静态方法不能使用类上定义的泛型

public class Test<T>{
    public static void fun(T data){} //报错！
}

原因：类泛型在创建对象时确定，静态方法不需要对象。

✅解决方案：使用独立泛型方法<E>

1. 基本类型不能作为泛型参数

   List<int> ❌；必须使用包装类 List<Integer> ✅

2. 泛型不支持继承多态误区

List<String> list1 = new ArrayList<>();
List<Object> list2 = list1; //编译报错！

虽然 String 是 Object 子类，但是 List<String>不是 List<Object> 的子类。泛型容器之间不存在继承关系！

1. 重载不能依靠泛型区分（擦除后方法签名一样）

void fun(List<String> list){}
void fun(List<Integer> list){} //编译冲突，擦除后都是List

八、泛型方法 vs 通配符怎么选？

示例需求：把 list 所有元素添加到另一个集合

//方案1：泛型方法
public static <T> void copy(List<T> src, List<T> dest){
    dest.addAll(src);
}

//方案2：通配符
public static <T> void copy2(List<? extends T> src, List<T> dest)

• 需要同时读写集合、类型互相约束 → 使用泛型<T>
• 只单纯读取或写入 → 使用通配符

九、面试高频问题汇总

1. 泛型实现原理？

   答：类型擦除，编译期校验，运行时无泛型信息。

2. List<String> 和 List<Object> 有继承关系吗？

   没有，泛型容器不存在多态，擦除后都是 List。

3. ? extends T 和 ? super T 区别？PECS？

4. 原始类型、泛型、通配符区别？

5. 能不能 new T ()？为什么？

6. 为什么泛型不支持基本数据类型？

十、背诵精简提纲

泛型参数化类型，JDK1.5 推出；

编译检查免强转，运行类型被擦除；

三类用法：泛型类、泛型接口、泛型方法；

任意未知类型，extends上界super下界；

PECS 口诀：读用 extends，写用 super；

不能 new 泛型对象、不能泛型数组；

静态方法不能使用类泛型；

容器泛型无继承，List不是 List