Java泛型你必须知道的知识

墨蓝 2022-10-31 10:58 233阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ2FpaHVpbWluZw_size_16_color_FFFFFF_t_70_pic_center]

## 一 什么是泛型 ##

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

简单理解就是：泛型指定编译时的类型，减少运行时由于对象类型不匹配引发的异常。其主要用途是提高我们的代码的复用率。

我们Java标准库中的`ArrayList`就是泛型使用的典型应用：

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { 
           
          ......
    
    	public ArrayList(Collection<? extends E> c) { 
    		elementData = c.toArray();
    		if ((size = elementData.length) != 0) { 
    			// c.toArray might (incorrectly) not return Object[] (see 6260652)
    			if (elementData.getClass() != Object[].class)
    				elementData = Arrays.copyOf(elementData, size, Object[].class);
    		} else { 
    			// replace with empty array.
    			this.elementData = EMPTY_ELEMENTDATA;
    		}
    	}
    
    	public void sort(Comparator<? super E> c) { 
    		final int expectedModCount = modCount;
    		Arrays.sort((E[]) elementData, 0, size, c);
    		if (modCount != expectedModCount) { 
    			throw new ConcurrentModificationException();
    		}
    		modCount++;
    	}
       
      .....
    
    	public E get(int index) { 
    		rangeCheck(index);
    
    		return elementData(index);
    	}
    
    	public boolean add(E e) { 
    		ensureCapacityInternal(size + 1);  // Increments modCount!!
    		elementData[size++] = e;
    		return true;
    	}
    
    }

*  源码中，`ArrayList<E>`中的`E`称为类型参数变量，而整个`ArrayList<E>`我们称为泛型类型。 我们可以指定除基本类型之外的任何类型，如：`ArrayList<String>`。
 *  源码中`Collection<? extends E>` 中`?` 通配符类型`<? extends T>` **表示类型的上界**，表示参数化类型的可能是`T` 或是 `T`的子类。
 *  源码中`Comparator<? super E>` **表示类型下界**（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至`Object`。

## 二 extends和super通配符 ##

在定义泛型类型`Generic<T>`的时候，也可以使用`extends`通配符来限定`T`的类型：

public class Generic<T extends Number> { ... }

现在，我们只能定义：

Generic<Number> p1 = null;
    Generic<Integer> p2 = new Generic<>(1, 2);
    Generic<Double> p3 = null;

因为`Number`、`Integer`和`Double`都符合`<T extends Number>`。

非`Number`类型将无法通过编译：

Generic<String> p1 = null; // compile error!
    Generic<Object> p2 = null; // compile error!

因为`String`、`Object`都不符合`<T extends Number>`，因为它们不是`Number`类型或`Number`的子类。

我们看一个例子：

public class Test { 
    
    	static class Food { 
    
    	}
    
    	static class Fruit extends Food { 
    	}
    
    	static class Apple extends Fruit { 
    	}
    
    	static class Orange extends Fruit { 
    	}
    
    	public void testExtend() { 
    		List<? extends Fruit> list = new ArrayList<Apple>();
    
    		//无法安全添加任何具有实际意义的元素,报错,extends为上界通配符,只能取值,不能放.
    		//因为Fruit的子类不只有Apple还有Orange,这里不能确定具体的泛型到底是Apple还是Orange，所以放入任何一种类型都会报错
    
    		//list.add(new Apple());
    		//list.add(new Orange());
    
    		//可以添加null，因为null可以表示任何类型
    		list.add(null);
    
    		//可以正常获取，用java多态
    		Food foot = list.get(0);
    		Apple apple = (Apple) list.get(0);
    	}
    
    	public void testSuper() { 
    		List<? super Fruit> list = new ArrayList<Fruit>();
    
    		//super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲，
    		list.add(new Fruit());
    		list.add(new Apple());
    
    		//无法确定Fruit的父类是否只有Food一个(Object是超级父类)
    		//因此放入Food的实例编译不通过，只能放自己的实例 或者根据java多态的特性放子类实例
    		//list.add(new Food());
    		//List<? super Fruit> list2 = new ArrayList<Apple>();
    		//Fruit fruit = list.get(0); //不能确定返回类型
    
    	}
    
    }

在`testExtend`方法中，因为泛型中用的是`extends`，在向list中存放元素的时候，我们并不能确定List中的元素的具体类型，即可能是`Apple`也可能是`Orange`。因此调用`add`方法时，不论传入`new Apple()`还是`new Orange()`，都会出现编译错误。

理解了extends之后，再看super就很容易理解了，即我们不能确定`testSuper`方法的参数中的泛型是Fruit的哪个父类，因此在调用get方法时只能返回Object类型。结合extends可见，在获取泛型元素时，使用extends获取到的是泛型中的上边界的类型(本例子中为Fruit),范围更小。

**总结：**

*  在使用泛型时，存取元素时用super。
 *  获取元素时，用extends。

有了上面的结论我们看下Java标准库的`Collections`类定义的`copy()`方法，这个`copy()`方法的定义就完美地展示了`extends`和`super`的意图：

*  `copy()`方法内部不会读取`dest`，因为不能调用`dest.get()`来获取`T`的引用；
 *  `copy()`方法内部也不会修改`src`，因为不能调用`src.add(T)`。

public class Collections { 
        // 把src的每个元素复制到dest中:
        public static <T> void copy(List<? super T> dest, List<? extends T> src) { 
            for (int i=0; i<src.size(); i++) { 
                T t = src.get(i);
                dest.add(t);
            }
        }
    }

## 三 泛型擦除 ##

Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，这个过程成为类型擦除

我们看一个示例：

public class Test2 { 
    
    	public static void main(String[] args) { 
    		Map<String, Animal> map = new HashMap<>();
    		Animal animal = new Animal();
    		animal.setVegetarian(true);
    		animal.setEats("fish");
    		map.put("cat", animal);
    
    		String json = new Gson().toJson(map);
    		System.out.println(json);
    
    		Map<String, Animal> jsonToMap = fromJson(json);
    		System.out.println(jsonToMap);
    
    		Animal animal1 = jsonToMap.get("cat");
    		System.out.println(animal1.getEats());
    	}
    
    	public static <T> T fromJson(String str) { 
    		return new Gson().fromJson(str, new TypeToken<T>() { 
    		}.getType());
    	}
    
    }

上的代码运行会提示如下异常：

Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.uaf.rabbitmq.producer.Animal
    	at com.uaf.rabbitmq.producer.Test2.main(Test2.java:30)

异常原因主要是这句：`new Gson().fromJson(str, new TypeToken<T>() {}.getType());`

这句在实际执行的时候，`List<T>`中的T并未传入实际的泛型参数，导致`Gson`按照`LinkedTreeMap`来解析`JSON`，以致发生了错误；这就是一个在编译期泛型类型擦除所导致的问题；

解决这个问题我们需要修改`fromJson`方法

public class Test2 { 
    
    	public static void main(String[] args) { 
    		Map<String, Animal> map = new HashMap<>();
    		Animal animal = new Animal();
    		animal.setVegetarian(true);
    		animal.setEats("fish");
    		map.put("cat", animal);
    
    		String json = new Gson().toJson(map);
    		System.out.println(json);
    
    		Map<String, Animal> jsonToMap = fromJson(json, 
    		new TypeToken<Map<String, Animal>>() { }.getType());
    		System.out.println(jsonToMap);
    
    		Animal animal1 = jsonToMap.get("cat");
    		System.out.println(animal1.getEats());
    
    	}
    
    	public static <T> T fromJson(String str, Type type) { 
    		return new Gson().fromJson(str, type);
    	}
    
    }

在`Gson`中提供了`TypeToken`解决泛型运行时类型擦除问题，`TypeToken` 这个类来帮助我们捕获像`Map`这样的泛型信息。上文创建了一个匿名内部类，这样Java编译器就会把泛型信息编译到这个匿名内部类里，然后在运行时就可以被`getType()`方法用反射API提取到。

--------------------

欢迎关注公众号： **编码是个技术活**

![在这里插入图片描述][20210219162337578.jpg_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ2FpaHVpbWluZw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/53ca129dab37466daed6818a9ecaf9f9.png
[20210219162337578.jpg_pic_center]: /images/20221024/e7ad66c7b809408e855dbb5499d1f7ef.png