Java 泛型的用法

1. 泛型类

泛型类是指在类定义时利用范例参数来指定类的范例。如许可以在类的内部利用这些范例参数来定义字段、方法的返回范例和参数范例。

1. public class Box<T> {
2.     private T t;
4.     public void set(T t) {
5.         this.t = t;
6.     }
8.     public T get() {
9.         return t;
10.     }
11. }

复制代码

在这个例子中，Box 类利用了一个范例参数 T，可以在创建 Box 对象时指定详细的范例。

1. Box<Integer> integerBox = new Box<>();
2. integerBox.set(10);
3. Integer value = integerBox.get();
5. Box<String> stringBox = new Box<>();
6. stringBox.set("Hello");
7. String message = stringBox.get();

复制代码

2. 泛型接口

泛型接口与泛型类类似，允许在接口定义时利用范例参数。

1. public interface Cache<K, V> {
2.     V get(K key);
3.     void put(K key, V value);
4. }
6. public class MemoryCache<K, V> implements Cache<K, V> {
7.     private Map<K, V> map = new HashMap<>();
9.     @Override
10.     public V get(K key) {
11.         return map.get(key);
12.     }
14.     @Override
15.     public void put(K key, V value) {
16.         map.put(key, value);
17.     }
18. }

复制代码

在这个例子中，Cache 接口利用了两个范例参数 K 和 V，分别表现键和值的范例。MemoryCache 类实现了 Cache 接口，并利用了这些范例参数。

1. Cache<String, Integer> cache = new MemoryCache<>();
2. cache.put("one", 1);
3. Integer number = cache.get("one");

复制代码

3. 泛型方法

泛型方法是指在方法定义时利用范例参数。如许可以在方法内部利用这些范例参数来定义方法的返回范例和参数范例。

1. public class Util {
2.     public static <T> T getFirst(T[] array) {
3.         if (array == null || array.length == 0) {
4.             return null;
5.         }
6.         return array[0];
7.     }
8. }

复制代码

在这个例子中，getFirst 方法利用了一个范例参数 T，可以在调用方法时指定详细的范例。

1. Integer[] intArray = {1, 2, 3};
2. Integer firstInt = Util.getFirst(intArray);
4. String[] stringArray = {"Hello", "World"};
5. String firstString = Util.getFirst(stringArray);

复制代码

4. 范例通配符

范例通配符 ? 用于表现未知范例，可以用于方法参数和返回范例，以提高代码的灵活性。

1. 无界通配符：? 表示任意类型。

复制代码

1. public void printList(List<?> list) {
2.     for (Object elem : list) {
3.         System.out.print(elem + " ");
4.     }
5.     System.out.println();
6. }

复制代码

}
有界通配符：

1. 上界通配符：? extends T 表示类型参数是 T 的子类型。

复制代码

1. public static double sumOfList(List<? extends Number> list) {
2.     double s = 0.0;
3.     for (Number n : list) {
4.         s += n.doubleValue();
5.     }
6.     return s;
7. }

复制代码

下界通配符：? super T 表现范例参数是 T 的父范例。

1. public static void addNumbers(List<? super Integer> list) {
2.     for (int i = 1; i <= 10; i++) {
3.         list.add(i);
4.     }
5. }

复制代码

5. 泛型的范例擦除

Java 泛型在编译时会被擦除，即编译后的字节码中不包罗泛型信息。这意味着在运行时，泛型范例参数会被替换为它们的上界（如果有上界）或 Object（如果没有上界）。

1. public class Box<T> {
2.     private T t;
4.     public void set(T t) {
5.         this.t = t;
6.     }
8.     public T get() {
9.         return t;
10.     }
11. }

复制代码

编译后，Box 类的字节码中 T 会被替换为 Object：

1. public class Box {
2.     private Object t;
4.     public void set(Object t) {
5.         this.t = t;
6.     }
8.     public Object get() {
9.         return t;
10.     }
11. }

复制代码

6. 泛型的限制

不能利用根本数据范例：泛型只能利用对象范例，不能利用根本数据范例。例如，不能创建 Box，但可以创建 Box。
范例参数不能是 final 范例：不能利用 final 范例作为范例参数。
静态上下文中不能利用范例参数：不能在静态方法或静态初始化块中利用类的范例参数。
范例参数不能是非常范例：不能利用非常范例作为范例参数。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。