Java 包装类与泛型核心解析 | 极客日志

Javajava

Java 包装类与泛型核心解析

Java 包装类将基本数据类型封装为对象，支持装箱拆箱及自动转换机制。泛型提供类型安全与代码重用，通过类型擦除在运行时消除泛型信息。本文涵盖包装类映射、自动装箱原理、泛型定义与上界约束、泛型方法及通配符使用规则。

随缘发布于 2026/3/170 浏览

Java 包装类与泛型核心解析

一、包装类

1.1. 基本类型和对应的包装类

Java 共有 8 种基本数据类型，Java 给这些基本类型都提供了一个类进行表示，来对这些类进行一个封装，这就是包装类。

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

1.2. 装箱和拆箱

在 Java 当中，提供了一些操作，使包装类和内置类型可以相互转换。内置类型转为包装类型称为装箱，包装类型转为内置类型称为拆箱。但这些代码写法已经过时了，我们需要重点掌握的是自动装箱和自动拆箱。

1.3. 自动装箱和自动拆箱

public class Main {
    public static void main(String[] args) {
        int i = 10;
        Integer ii = i; // 自动装箱
        Integer ij = (Integer) i; // 自动装箱，后面的 (Integer) 可有可无
        int j = ii; // 自动拆箱
        int k = (int)ii; // 自动拆箱，后面的 (int) 可有可无
    }
}

我们可以通过 javap -c 查看字节码文件内容，观察装箱和拆箱的操作。我们可以在 IDEA 里面装一个 jclasslib ByteCode Viewer 的插件，然后点击 View，再点击 Show Bytecode With Jclasslib。我们点到 main 方法，点击 code，就可以看到所对应的字节码文件。

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

Keycode 信息
查找任何按下的键的javascript键代码、代码、位置和修饰符。在线工具，Keycode 信息在线工具，online
Escape 与 Native 编解码
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。在线工具，Escape 与 Native 编解码在线工具，online
JavaScript / HTML 格式化
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。在线工具，JavaScript / HTML 格式化在线工具，online
JavaScript 压缩与混淆
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。在线工具，JavaScript 压缩与混淆在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online

public class Main {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b); // true
        Integer c = 128;
        Integer d = 128;
        System.out.println(c == d); // false
        Integer e = 126;
        System.out.println(a == e); // false
    }
}

class 泛型名称<参数列表> {
    // 这里可以使用类型参数;
}
class ClassName<T1,T2,……,Tn> {}

private T[] arrays = new T[]; // 这种写法是错误的

T[] arrays = (T[]) new Object[10];

class MyArray<T> {
    T[] arrays = (T[]) new Object[10];
    public T get(int index) {
        return arrays[index]; // 获取数组的下标
    }
    public void set(int index, T value) {
        arrays[index] = value; // 对数组进行赋值
    }
}
// 上面的 T 不用再进行强转了
// 对方法的实现
public class Main {
    public static void main(String[] args) {
        MyArray<String> array1 = new MyArray<>(); // 里面可以存放字符。代码是灰色的，表示可以不写
        MyArray<Integer> array2 = new MyArray<>(); // 里面可以存放整数
        MyArray array4 = new MyArray(); // 裸类型，这种写法是不科学的
        // MyArray<int> array3 = new MyArray<>(); // error: Type argument cannot be of primitive type
    }
}

class MyArray<T> {
    T[] arrays = (T[]) new Object[10];
    public T get(int index) {
        return arrays[index];
    }
    public void set(int index, T value) {
        arrays[index] = value;
    }
}

// 擦除前
class MyArray<T> {
    public Object[] arrays = new Object[10];
    public T getPos(int pos) {
        return (T)this.arrays[pos];
    }
    public void setVal(int pos, T val) {
        this.arrays[pos] = val;
    }
}
// 擦除后
class MyArray<T> {
    public Object[] arrays = new Object[10];
    public Object getPos(int pos) {
        return this.arrays[pos];
    }
    public void setVal(int pos, T val) {
        this.arrays[pos] = val;
    }
}

class 泛型名称<类型实参 extends 类型边界> {}

class MyArray<E extends Number> {
    MyArray<Integer> l1; // 正常
    MyArray<String> l2; // 错误
}

方法限定符 <类型形参列表> 返回值类型 方法名称 {}

public class Main {
    // 静态的泛型方法需要在 static 后面用<>声明泛型类型参数
    public static <E> void swap(E[] array, int i, int j) {
        E t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

class MyClass<T> {}
public class Main {
    public static void main(String[] args) {
        MyClass<Integer> obj1 = new MyClass<>();
        MyClass<String> obj2 = new MyClass<>();
        MyClass<Integer> obj3 = new MyClass<>();
        obj1 = obj3; // 正常
        obj1 = obj2; // 错误
    }
}

MyClass<?> obj4 = obj3;

MyClass<? extends Number> obj5 = obj1;
obj5 = obj2; // 这个代码不符合要求，约定 obj5 的通配符，只能匹配到 Number 和它的子类;
// 因为通配符只能在泛型实例化时使用

MyClass<? super Integer> obj6 = obj1; // 此处的通配符只能匹配到 Integer 和它的父类
obj6 = new MyClass<double>(); // double 并不是 Integer 的子类，所以会报错
obj6 = new MyClass<Number>(); // Number 是 Integer 的父类。