Java泛型 #

// 没有泛型
List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0);  // 需要类型转换

// 使用泛型
List<String> list2 = new ArrayList<>();
list2.add("Hello");
String s2 = list2.get(0);  // 无需类型转换

public class Box<T> {
    private T value;
    
    public void set(T value) {
        this.value = value;
    }
    
    public T get() {
        return value;
    }
}

// 使用
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String value = stringBox.get();

Box<Integer> intBox = new Box<>();
intBox.set(100);
Integer num = intBox.get();

public class Pair<K, V> {
    private K key;
    private V value;
    
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    
    public K getKey() { return key; }
    public V getValue() { return value; }
}

// 使用
Pair<String, Integer> pair = new Pair<>("age", 25);

public interface Generator<T> {
    T generate();
}

// 实现方式1：指定具体类型
public class StringGenerator implements Generator<String> {
    @Override
    public String generate() {
        return "Hello";
    }
}

// 实现方式2：保留泛型
public class GenericGenerator<T> implements Generator<T> {
    @Override
    public T generate() {
        return null;
    }
}

public class Utils {
    // 泛型方法
    public static <T> void print(T value) {
        System.out.println(value);
    }
    
    // 多个类型参数
    public static <K, V> void printPair(K key, V value) {
        System.out.println(key + " = " + value);
    }
    
    // 返回泛型
    public static <T> T getFirst(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }
}

// 使用
Utils.print("Hello");
Utils.print(100);
Utils.printPair("name", "张三");

public class Box<T> {
    private T value;
    
    // 泛型类的类型参数T
    public void set(T value) {
        this.value = value;
    }
    
    // 泛型方法，使用新的类型参数E
    public <E> void print(E element) {
        System.out.println(element);
    }
}

public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
    // list.add("test");  // 错误：不能添加元素
}

// 接受Number及其子类
public double sum(List<? extends Number> list) {
    double total = 0;
    for (Number num : list) {
        total += num.doubleValue();
    }
    return total;
}

// 使用
List<Integer> ints = Arrays.asList(1, 2, 3);
List<Double> doubles = Arrays.asList(1.5, 2.5, 3.5);
System.out.println(sum(ints));
System.out.println(sum(doubles));

// 接受Integer及其父类
public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
    list.add(3);
}

// 使用
List<Number> numbers = new ArrayList<>();
addNumbers(numbers);

List<Object> objects = new ArrayList<>();
addNumbers(objects);

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (T item : src) {
        dest.add(item);
    }
}

// 编译前
public class Box<T> {
    private T value;
}

// 编译后（类型擦除）
public class Box {
    private Object value;
}

public class StringBox extends Box<String> {
    @Override
    public void set(String value) {
        // ...
    }
    
    // 编译器生成的桥方法
    public void set(Object value) {
        set((String) value);
    }
}

// 错误
// List<int> list = new ArrayList<>();

// 正确：使用包装类
List<Integer> list = new ArrayList<>();

public class Box<T> {
    // 错误
    // T value = new T();
    
    // 正确：使用反射
    public T create(Class<T> clazz) throws Exception {
        return clazz.getDeclaredConstructor().newInstance();
    }
}

// 错误
// T[] array = new T[10];

// 正确
@SuppressWarnings("unchecked")
T[] array = (T[]) new Object[10];