一、包装类

包装类将 8 种基本类型封装为对象，支持放入集合、调用工具方法，核心是 “基本类型 ↔ 对象” 的转换。

1. 基本类型与包装类对应关系

基本类型	包装类（java.lang 包）	常量池范围
byte	Byte	-128 ~ 127
short	Short	-128 ~ 127
int	Integer	-128 ~ 127
long	Long	-128 ~ 127
float	Float	无
double	Double	无
char	Character	0 ~ 127
boolean	Boolean	true/false 实例

2. 核心操作：拆装箱

• 装箱：基本类型 → 包装类（手动 / 自动）
• 拆箱：包装类 → 基本类型（手动 / 自动）

// 自动装箱（底层：Integer.valueOf(10)）
Integer a = 10;
// 自动拆箱（底层：a.intValue()）
int b = a;

// 手动装箱
Integer c = new Integer(20);
// 手动拆箱
int d = c.intValue();

3. 常量池陷阱（高频考点）

• 范围：-128 ~ 127 的整数包装类会缓存，超出范围每次创建新对象
• 对比：== 比较地址，equals() 比较数值

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true（复用缓存对象）

Integer m = 200;
Integer n = 200;
System.out.println(m == n); // false（超出范围，新对象）
System.out.println(m.equals(n)); // true（比较数值）

4. 常用工具方法

• parseXxx(String s)：字符串转基本类型（如 Integer.parseInt("123")）
• toString()：包装类转字符串（如 a.toString()）
• MAX_VALUE/MIN_VALUE：获取基本类型最值（如 Integer.MAX_VALUE）

二、抽象类

抽象类是 “模板类”，不能实例化，专门用于被继承，核心是 “强制子类实现抽象方法”。

1. 定义规则

• 关键字：abstract class
• 包含内容：可有抽象方法（无方法体）、普通方法、属性
• 核心限制：不能 new 实例化，需通过子类实例化（多态）

// 抽象类
abstract class Animal {
    // 抽象方法（无方法体，强制子类重写）
    abstract void run();
    
    // 普通方法（可直接使用）
    void eat() {
        System.out.println("吃饭");
    }
}

// 子类实现抽象方法
class Dog extends Animal {
    @Override
    void run() {
        System.out.println("狗跑");
    }
}

// 使用（多态）
Animal animal = new Dog();
animal.run(); // 输出：狗跑

2. 修饰符冲突（禁止组合）

• final + abstract：final 禁止继承，abstract 需继承（冲突）
• private + abstract：private 不可见，abstract 需子类重写（冲突）
• static + abstract：static 是类级别，abstract 是实例级别（冲突）

3. 继承规则

• 子类若不实现父类所有抽象方法，自身必须声明为抽象类

三、内部类

定义在另一个类中的类，逻辑依赖外部类，分四种形态。

类型	位置	访问外部成员	实例化方式	核心特点
成员内部类	外部类成员位置	可访问外部所有成员（含私有）	new 外部类().new 内部类()	依赖外部类实例，随外部类存活
静态内部类	外部类成员位置 + static	仅访问外部静态成员	new 外部类.内部类()	独立于外部类，类似 “独立类”
局部内部类	外部类方法 / 代码块中	可访问外部局部变量（需 final）	方法内直接 new	仅方法内可见，临时使用
匿名内部类	表达式中（如方法参数）	按所在位置决定	new 接口/抽象类(){...}	无类名，一次性实现，用完即扔

代码示例

// 1. 成员内部类
class Outer {
    private int x = 1;
    class Inner { // 成员内部类
        void print() {
            System.out.println(x); // 访问外部私有属性
        }
    }
}
// 实例化
new Outer().new Inner().print(); // 输出：1

// 2. 静态内部类
class Outer2 {
    static int y = 2;
    static class Inner2 { // 静态内部类
        void show() {
            System.out.println(y); // 仅访问外部静态属性
        }
    }
}
// 实例化
new Outer2.Inner2().show(); // 输出：2

// 3. 匿名内部类（实现接口）
interface Runable {
    void run();
}
// 一次性实现接口
Runable r = new Runable() {
    @Override
    void run() {
        System.out.println("匿名内部类运行");
    }
};
r.run();

四、接口

接口是 “规范契约”，定义方法签名，无具体实现，支持多实现。

1. 定义规则

• 关键字：interface
• 成员默认修饰符：
  • 方法：public abstract（可省略）
  • 属性：public static final（可省略）
• 核心限制：不能实例化，无构造方法

2. 核心特性

• 多实现：一个类可实现多个接口（解决 Java 单继承问题）
• 多继承：接口可继承多个接口（扩展方法）
• default 方法：Java 8+ 新增，提供默认实现，子类可重写

// 1. 定义接口
interface Fly {
    void fly(); // 抽象方法
    // default方法
    default void land() {
        System.out.println("降落");
    }
}

// 2. 实现接口（多实现）
class Bird implements Fly, Runable {
    @Override
    public void fly() {
        System.out.println("鸟飞");
    }
    @Override
    public void run() {
        System.out.println("鸟跑");
    }
}

// 3. 接口多继承
interface SuperFly extends Fly, Runable {
    // 继承 Fly 和 Runable 的所有方法
}

3. 接口 vs 抽象类（核心区别）

维度	接口	抽象类
方法	仅抽象方法 /default 方法	可含抽象方法、普通方法
属性	仅静态常量	可含任意属性
继承 / 实现	多实现、多继承	单继承
构造方法	无	有
核心用途	定义规范（如 “能飞”“能跑”）	定义模板（如 “动物” 基类）

五、Object 类

Java 所有类的父类，自带 6 个核心方法，需掌握 equals()、hashCode()、toString()。

1. 核心方法解析

方法名	作用	重写要点
equals(Object o)	比较对象是否 “相等”	默认比较地址，重写后比较业务逻辑（如属性）
hashCode()	返回对象哈希码（整数）	与 equals() 保持一致：相等对象哈希必相等
toString()	返回对象字符串表示（默认 “类名 @地址”）	重写后返回属性信息（如 “Dog {name=' 阿黄 '}”）
getClass()	获取对象的类信息（反射用）	不可重写
wait()/notify()	线程等待 / 唤醒（多线程用）	需在同步代码块中使用

2. == vs equals() vs hashCode()（高频考点）

维度	==	equals()	hashCode()
本质	运算符	Object 实例方法	Object 实例方法
比较内容	基本类型比数值，引用类型比地址	默认比地址，重写后比业务逻辑	映射对象为整数（默认用地址）
能否重写	不能	能	能
关系	-	相等对象 → 哈希必相等	哈希相等 → 对象不一定相等（冲突）

3. 重写示例（Person 类）

class Person {
    private String id;
    private String name;

    // 重写equals()：id相同则认为相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id.equals(person.id);
    }

    // 重写hashCode()：与equals()保持一致
    @Override
    public int hashCode() {
        return id.hashCode();
    }

    // 重写toString()：返回属性信息
    @Override
    public String toString() {
        return "Person{id='" + id + "', name='" + name + "'}";
    }
}

总结

1. 包装类：关注拆装箱、常量池陷阱，equals() 比数值，== 比地址
2. 抽象类：不能实例化，强制子类重写抽象方法，禁止与 final/private/static 组合
3. 内部类：四种形态，按位置和访问权限区分，匿名内部类常用于快速实现接口
4. 接口：规范契约，支持多实现 / 多继承，default 方法提供默认实现
5. Object 类：重写 equals() 和 hashCode() 需保持一致，toString() 重写后便于调试