Java 包装类与泛型深度拆解：从基础到源码核心

int i = 10;
// 手动装箱（两种方式）
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 手动拆箱
int j = ii.intValue();

int i = 10;
Integer ii = i; // 自动装箱
int j = ii;     // 自动拆箱

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

class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) { return array[pos]; }
    public void setVal(int pos, Object val) { array[pos] = val; }
}
// 使用
MyArray myArray = new MyArray();
myArray.setVal(0, 10);
myArray.setVal(1, "hello");
String ret = (String) myArray.getPos(1); // 必须强转，编译不报错、运行可能异常

class 类名<类型形参> {
    // 可直接使用类型形参
}

class MyArray<T> { // T为类型形参
    public Object[] array = new Object[10];
    public T getPos(int pos) { return (T) array[pos]; }
    public void setVal(int pos, T val) { array[pos] = val; }
}
// 使用
MyArray<Integer> myArray = new MyArray<>(); // 指定类型为Integer
myArray.setVal(0, 10);
int ret = myArray.getPos(0); // 无需强转，编译自动转换
myArray.setVal(1, "hello"); // 编译报错！类型不匹配

MyArray<Integer> list = new MyArray<>(); // 等价于new MyArray<Integer>()

MyArray list = new MyArray(); // 裸类型，等价于MyArray<Object>

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

// 父类
class Node<T> {
    public void setData(T data) {}
}
// 子类
class StringNode extends Node<String> {
    @Override
    public void setData(String data) {}
}
// 擦除后，编译器自动生成桥接方法
class StringNode extends Node {
    public void setData(String data) {}
    // 桥接方法
    public void setData(Object data) {
        setData((String) data);
    }
}

class 类名<T extends 上界类型> {}

// 仅允许Number及其子类（Integer、Double等）
class MyArray<E extends Number> {}
MyArray<Integer> l1; // 合法
MyArray<String> l2; // 编译报错，String不是Number子类

修饰符 <类型形参> 返回值 方法名(参数列表) {}

class Util {
    // 交换数组元素
    public static <E> void swap(E[] array, int i, int j) {
        E temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}
// 使用
Integer[] arr = {1,2,3};
Util.swap(arr, 0, 1); // 自动推导类型
Util.<Integer>swap(arr, 0, 1); // 手动指定类型

class Message<T> {
    private T msg;
    public T getMsg() { return msg; }
    public void setMsg(T msg) { this.msg = msg; }
}
public class Test {
    // 接收任意Message类型
    public static void fun(Message<?> temp) {
        System.out.println(temp.getMsg());
    }
    public static void main(String[] args) {
        Message<String> m1 = new Message<>();
        Message<Integer> m2 = new Message<>();
        fun(m1);
        fun(m2);
    }
}

class Fruit {}
class Apple extends Fruit {}
class Plate<T> {
    private T data;
    public T getData() { return data; }
    public void setData(T data) { this.data = data; }
}
public class Test {
    // 接收Fruit及其子类
    public static void fun(Plate<? extends Fruit> temp) {
        System.out.println(temp.getData()); // 可读
        temp.setData(new Apple()); // 编译报错，不可写
    }
}

public class Test {
    // 接收Fruit及其父类
    public static void fun(Plate<? super Fruit> temp) {
        temp.setData(new Apple()); // 可写（子类）
        System.out.println(temp.getData()); // 可读
        Fruit fruit = temp.getData(); // 编译报错，无法确定父类类型
    }
}