一、集合框架核心类:ArrayList
1. 类定位
- 集合框架中
List 接口的实现类,基于动态数组实现。
2. 核心特性
- 内部封装
Object 类型数组,初始长度为 10,支持自动扩容(长度可变); - 查询快(数组支持索引直接访问),增删慢(需移动数组元素);
- 线程不安全
二、浮点类型存储规则
1. 核心原理
- 基于二进制科学计数法表示:
value = (-1)^S × M × 2^E;S:符号位(0 = 正数,1 = 负数);M:尾数(有效数字,二进制下隐含整数位 1,仅存小数部分);E:指数(偏移存储,避免负指数开销)。
2. 常用类型存储结构
| 类型 | 总位数 | 符号位 (S) | 指数位 (E) | 尾数位 (M) | 指数偏移量 | 有效精度(十进制) |
|---|
| 单精度(float) | 32 | 第 31 位 | 第 30-23 位 | 第 22-0 位 | 127 | 7~8 位 |
| 双精度(double) | 64 | 第 63 位 | 第 62-52 位 | 第 51-0 位 | 1023 | 15~17 位 |
3. 关键特性与注意点
- 精度有限:无法精确表示所有十进制小数(如
0.1 二进制无限循环),会导致精度丢失(例:0.1 + 0.2 != 0.3); - 表示范围广:float 支持 ±10^±38,double 支持 ±10^±308,远大于同位数整数;
- 特殊值:E 全 1+M 全 0 为 ±∞,E 全 1+M 非 0 为 NaN,E 全 0+M 非 0 为非规格化数(接近 0 的极小值)。
三、HashSet 去重机制与 equals/hashCode 关系
1. HashSet 去重逻辑
- 基于 HashMap 实现,核心:先比较
hashCode,再比较 equals;- 新增对象时,通过
hashCode() 确定哈希表 “桶位置”; - 若桶中已有对象,调用
equals() 比较是否相同; - 仅当
hashCode 不同,或 hashCode 相同但 equals 为 false 时,视为不同对象存储。
2. 重写 equals 必须重写 hashCode 的原因
- Java 规范:equals 为
true 的对象,hashCode 必须相同; - 不重写后果:自定义类默认 hashCode 基于内存地址生成,导致 “逻辑相等的对象(equals 为
true)hashCode 不同”,HashSet 去重失效。
3. 正确重写示例
class Dog {private String name;@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Dog dog = (Dog) o;return Objects.equals(name, dog.name);}@Overridepublic int hashCode() {return Objects.hash(name);}
}
四、Java 异常体系
1. 体系结构
- 根类:
Throwable,分为两大分支:- 错误(Error):系统级严重问题(如
OutOfMemoryError、StackOverflowError),程序无法恢复; - 异常(Exception):分为受检异常和非受检异常(运行时异常)。
2. 异常分类与特点
| 类型 | 编译期约束 | 产生原因 | 示例 |
|---|
| 受检异常(Checked) | 强制处理 | 外部环境 / 资源问题 | IOException、SQLException |
| 运行时异常(Unchecked) | 不强制处理 | 程序逻辑错误 | NullPointerException、ArrayIndexOutOfBoundsException |
3. 异常处理方式:throws 关键字
(1)核心作用
- 异常上抛:当前方法不处理异常,声明可能抛出的异常类型,将处理责任交给调用者(仅用于受检异常)。
(2)使用格式
// 单个异常
返回值类型 方法名(参数列表) throws 异常类型1 { ... }
// 多个异常
返回值类型 方法名(参数列表) throws 异常类型1, 异常类型2 { ... }
(3)核心规则
- 受检异常必须声明,运行时异常可省略;
- 调用者需通过
try-catch 捕获或继续 throws 上抛,最终必须有方法处理(否则 JVM 终止程序); - 重写方法声明的异常不能比父类更宽泛。
(4)示例与异常传递
// 声明抛出 IOException
public static void readFile(String filePath) throws IOException {FileReader reader = new FileReader(filePath);reader.close();
}
// 调用者处理方式1:try-catch 捕获
public static void main(String[] args) {try {readFile("test.txt");} catch (IOException e) {System.out.println("文件读取失败:" + e.getMessage());}
}
// 调用者处理方式2:继续上抛
public static void main(String[] args) throws IOException {readFile("test.txt");
}
(5)常见问题:try-catch 后仍 “报错” 的原因
try-catch 是 “捕获并处理异常”,不是阻止异常发生;- 看到的 “报错” 是
catch 块中 e.printStackTrace() 主动打印的异常堆栈(调试信息),而非程序未捕获异常导致的崩溃; - 异常会中断
try 块后续代码执行(例:Class.forName() 抛出异常后,后续 System.out.println() 无法执行)。
五、反射:获取 Class 对象的三种方式
1. 方式 1:对象的 getClass () 方法
- 需创建类的实例,通过实例调用
getClass(); - 示例:
String str = "Hello"; Class<> class = str.getClass();。
2. 方式 2:类的 .class 属性
- 无需创建实例,直接通过 “类名.class” 获取;
- 示例:
Class<> class = String.class;
3. 方式 3:Class.forName () 方法
- 通过类的全限定名(包名 + 类名)获取,常用于动态加载类;
- 示例:
Class<> class = Class.forName("java.lang.String");(需处理 ClassNotFoundException)。
六、核心关键字:static
1. 核心定义
- 修饰符,可修饰变量、方法、代码块、内部类;
- 核心特征:属于 “类本身”,而非实例,无需创建对象即可访问;
- 生命周期:与类一致(类加载时初始化,类卸载时销毁)。
2. 修饰不同成分的用法
(1)静态变量(类变量)
- 存储位置:方法区,所有对象共享同一内存;
- 访问方式:
类名.变量名(推荐)或 对象.变量名(不推荐); - 特性:修改一个对象的静态变量,所有对象均可见。
(2)静态方法(类方法)
- 访问方式:
类名.方法名()(推荐),无需创建对象; - 限制:无
this 指针,无法访问非静态成员(依赖实例),可访问静态成员;
(3)静态代码块
- 格式:
static { ... }; - 执行时机:类加载时执行(仅一次),优先级高于构造方法;
- 用途:初始化静态变量、加载资源(如数据库驱动)。
(4)静态内部类
- 不依赖外部类实例,直接创建:
外部类.内部类 实例 = new 外部类.内部类(); - 限制:仅能访问外部类的静态成员。
3. 关键注意事项
- 静态成员不能访问非静态成员,非静态成员可访问静态成员;
- 避免滥用静态变量(生命周期长,可能导致内存泄漏);
- 静态方法不能被重写,子类同名静态方法会隐藏父类方法。
七、核心关键字:this
1. 核心定义
- 隐含引用,仅存在于非静态成员(非静态方法、构造方法)中;
- 指向:当前执行方法 / 构造方法的对象实例;
- 限制:不能用于静态方法、静态代码块(无对象关联)。
2. 核心用途
(1)区分成员变量与局部变量(重名时)
- 示例:
public Person(String name) { this.name = name; }(this.name 为成员变量)。
(2)调用当前类的其他构造方法
- 语法:
this(参数列表),必须作为构造方法第一条语句; - 示例:
public Person() { this("默认姓名", 18); }(无参构造调用带参构造)。
(3)返回当前对象(链式调用)
- 语法:
return this;(返回值类型为当前类); - 示例:
public Person setAge(int age) { this.age = age; return this; }(支持 new Person().setAge(25).setName("张三"))。
3. 关键注意事项
this 不能为 null,不能手动赋值;- 构造方法中调用
this(...) 不可形成循环(如 A 构造调用 B 构造,B 构造又调用 A 构造)。