包装类与泛型介绍

独断万古他化

发布于 2026-01-15 13:06:32

1130

文章被收录于专栏：Java 攻略Java 攻略

1. 包装类

1.1 什么是包装类

在Java中，为了在泛型代码支持基本类型，java给每个基本类型都对应了一个包装类型。如下为基本数据类型对应的包装类

1.2 装箱和拆箱

装箱操作就是创建一个包装类的类对象，将基本类型的数据放入对象的某个属性中。

int i = 10;
Integer it = Integer.valueOf(i);

那么拆箱就是将包装类类对象中的值取出，放入到基本类型中。

int i1 = it.intValue();

1.3 自动装箱与自动拆箱

java提供了自动机制帮我们进行拆箱与装箱，减少了我们的代码量。

int i = 10;
        
Integer it = i;             //自动拆箱
Integer it1 = (Integer)i;   //自动拆箱
        
int j = it;                 //自动装箱
int j1 = (int)it;           //自动装箱

2. 泛型

2.1 什么是泛型

泛型就是适用于许多类型，就是将类型进行了参数化。泛型的主要目的：指定当前的容器，要持有什么类型的对象，就是将类型作为参数传递。

2.2 泛型语法

基础写法：class 泛型类名称< 类型形参列表 >{} 示例：

public class MyArray<T> {

}

代表占位符，表示当前类是一个泛型类。

3. 泛型类的使用

3.1 语法

语法：定义一个泛型类引用：class 泛型类名称< 类型形参列表 > 实例化泛型类对象：new 泛型类<类型实参>(构造方法实参); 示例：

MyArray<Integer> list = new MyArray<Integer>();

泛型类可进行类型推导：编译器可根据上下文推导出类型的实参，因此可以省略后面类型实参的填写，但是不可以省略<>；示例：

MyArray<Integer> list = new MyArray<>();

4. 泛型的编译

4.1 擦除机制

泛型是如何进行编译的呢？

1.基本概念：

在编译时，Java 编译器会将泛型类型信息从代码中移除，这个过程就叫做类型擦除。
擦除后，泛型类型会被替换为其边界类型（通常是 Object）或者指定的类型。

2.擦除过程：

将泛型参数替换为其边界或 Object。
在必要的地方插入类型转换以保持类型安全。
⽣成桥接方法以保持多态性。

3.示例：擦除前：

class MyArray<T> {

	public Object[] array = new Object[10];
	
	public T getPos(int pos) {
		return (T)this.array[pos];
	}
	
	public void setVal(int pos,T val) {
		this.array[pos] = val;
	}
}

擦除后：

class MyArray {

	public Object[] array = new Object[10];
	
	public Object getPos(int pos) {
		return this.array[pos];
	}
	
	public void setVal(int pos, Object val) {
		this.array[pos] = val;
	}
}

5. 泛型的上界

在定义泛型时，有时需要对传入的类型参数做一定的约束，可以通过类型边界来约束。

语法：class 泛型类名称<类型形参 extends 类型边界> { ... }
示例：

public class MyArray<E extends Number> {
...
}

此时表示传入的类型参数只能为Number或者Number的子类，否则会编译错误。而当没有指定类型边界E时，可以视为默认上界为Object。

复杂示例：

public class MyArray<E extends Comparable<E>> {
...
}

此时代表的是传入的类型参数必须是实现了Comparable接口的。

6. 泛型方法

定义语法：⽅法限定符 <类型形参列表> 返回值类型⽅法名称(形参列表) { ... }
示例：

public class Util {

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

7. 通配符

什么是通配符：将？用在泛型类中，即为通配符

通配符解决什么样的问题：我们给出一个例子：

class Message<T> {
	private T message ;
	public T getMessage() {
		return message;
	}
	public void setMessage(T message) {
		this.message = message;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Message<String> message = new Message<>() ;
		message.setMessage("泛型传参为String类型...");
		fun(message);
	}
	
	public static void fun(Message<String> temp){
		System.out.println(temp.getMessage());
	}
}

当我们想要设置类型为Integer时代码就行不通了

public class TestDemo {

	public static void main(String[] args) {
		Message<Integer> message = new Message() ;
		message.setMessage(999);
		fun(message); 
}

	public static void fun(Message<String> temp){
		System.out.println(temp.getMessage());
	}
}

此时出现错误，因为参数类型不一样了，那我们如何解决这个问题呢，此时就需要用到通配符？来进行处理，它可以接受所有类型的泛型类型，并且又不可以让用户随意更改。

示例：

public class TestDemo {

	public static void main(String[] args) {
		Message<Integer> message = new Message() ;
		message.setMessage(55);
		fun(message);
}

	// 此时使⽤通配符"?"描述的是它可以接收任意类型
	public static void fun(Message<?> temp){
		System.out.println(temp.getMessage());
	}
}