Java中泛型和Object类型 初级进阶教程（一）

在学习的过程中，常常看到某个类或者接口等中使用 List<T>, Test<T>，其中<T>的作用是什么呢？

1 在类中使用泛型

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

// 使用泛型类
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello, Generics!");
String content = stringBox.getContent();
System.out.println(content);

2 使用多个泛型

//多个泛型
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);
String key = pair.getKey();
Integer value = pair.getValue();
System.out.println(key + ": " + value);

3 在类中使用泛型

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

// 使用泛型类
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello, Generics!");
String content = stringBox.getContent();
System.out.println(content);

4 在方法中使用泛型

public class Utils {
    public static <T> T getLastElement(List<T> list) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        return list.get(list.size() - 1);
    }
}

// 使用泛型方法
List<String> stringList = Arrays.asList("One", "Two", "Three");
String lastElement = Utils.getLastElement(stringList);
System.out.println(lastElement);

5 限制泛型类型

public class NumberBox<T extends Number> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

// 使用限制泛型类型的类
NumberBox<Integer> integerBox = new NumberBox<>();
integerBox.setContent(42);
Integer content = integerBox.getContent();
System.out.println(content);

6 通配符 (Wildcard)

public class Printer {
    public static void printList(List<?> list) {
        for (Object element : list) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

// 使用通配符
List<String> stringList = Arrays.asList("One", "Two", "Three");
List<Integer> integerList = Arrays.asList(1, 2, 3);

Printer.printList(stringList);
Printer.printList(integerList);

总结：泛型和Object类型之间的区别

1. 类型安全：

   1. 泛型 T： 泛型提供了编译时类型检查，可以在编译时捕获一些类型错误。使用泛型时，你可以在代码中指定特定类型，而编译器会确保只能插入该类型的对象。这有助于在编译时发现潜在的类型错误，提高代码的安全性。

   2. Object： Object 不提供编译时类型检查，因此在运行时你可能会遇到类型转换异常。在使用 Object 时，你需要手动进行类型转换，并且编译器无法检查这些转换是否安全。

2. 代码重用性：

   1. 泛型 T： 泛型提供了更好的代码重用性，因为你可以创建通用的、与特定类型无关的代码。这使得代码更加灵活，可以适用于多种数据类型。

   2. Object： 当你使用 Object 时，你需要在每次使用时进行强制类型转换，这可能导致代码重复，并且使得代码更难以维护和理解。

3. 集合类型：

   1. 泛型 T： 在集合类中使用泛型可以避免类型转换，并提供更强的类型安全性。例如，List<T> 可以存储指定类型的元素，而不需要强制类型转换。

   2. Object： 在早期版本的Java中，集合类只能存储 Object 类型的元素，需要在取出元素时进行强制类型转换，容易引发运行时异常。

4. 灵活性：

   1. 泛型 T： 泛型提供了更灵活的类型参数化，可以在类、接口、方法级别使用。你可以为不同的上下文提供不同的类型参数。

   2. Object： Object 是所有类的父类，但它没有提供灵活的类型参数化。