java：详解泛型
java：详细了解泛型
引言 ：泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。
泛型基础-----泛型类
首先定义一个简单的Box类：
public class Box {
private String object;
public void set(String object) {
this.object = object;
}
public String get() {
return object;
}
}
这是最常见的做法，这样做的一个坏处是Box里面现在只能装入String类型的元素，今后如果我们需要装入Integer等其他类型的元素，还必须要另外重写一个Box，代码得不到复用，使用泛型可以很好的解决这个问题。
public class Box
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
这样我们的Box类便可以得到复用，我们可以将T替换成任何我们想要的类型：
Box
Box
Box
泛型基础-----泛型方法
声明一个泛型方法很简单，只要在返回类型前面加上一个类似
public class Pair
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public void setKey(K key) { this.key = key; }
public void setValue(V value) { this.value = value; }
public K getKey() { return key; }
public V getValue() { return value; }
}
public class Util {
public static
return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue());
}
}
调用泛型方法如下：
Pair
Pair
boolean same = Util.
或者在Java1.7/1.8利用type inference，让Java自动推导出相应的类型参数：
Pair
Pair
boolean same = Util.compare(p1, p2);
泛型拓展-----边界符
现在我们要实现这样一个功能，查找一个泛型数组中大于某个特定元素的个数，我们可以这样实现：
public static
int count = 0;
for (T e : anArray)
if (e > elem) // compiler error
++count;
return count;
}
但是这样很明显是错误的，因为除了short, int, double, long, float, byte, char等原始类型，其他的类并不一定能使用操作符>，所以编译器报错，那怎么解决这个问题呢？答案是使用边界符。
public interface Comparable
public int compareTo(T o);
}
做一个类似于下面这样的声明，这样就等于告诉编译器类型参数T代表的都是实现了Comparable接口的类，这样等于告诉编译器它们都至少实现了compareTo方法。
public static
int count = 0;
for (T e : anArray) {
if (e.compareTo(elem) > 0) {
++count;
}
}
return count;
}
泛型拓展-----通配符
在了解通配符之前，我们首先必须要澄清一个概念，还是借用我们上面定义的Box类，假设我们添加一个这样的方法：
public void boxTest(Box
/* ... */
}
那么现在Box
首先我们先定义几个简单的类，下面我们将用到它：
class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
下面这个例子中，我们创建了一个泛型类Reader，然后在metod1()中当我们尝试Fruit f = fruitReader.readExact(apples);编译器会报错，因为List
public class GenericReading {
static List
static List
static class Reader
T readExact(List
return list.get(0);
}
}
static void metod1() {
Reader
// Errors: List
Fruit f = fruitReader.readExact(apples);
}
public static void main(String[] args) {
metod1();
}
}
但是按照我们通常的思维习惯，Apple和Fruit之间肯定是存在联系，然而编译器却无法识别，那怎么在泛型代码中解决这个问题呢？我们可以通过使用通配符来解决这个问题：
static class CovariantReader
T readCovariant(List list) {
return list.get(0);
}
}
static void metod2() {
CovariantReader
Fruit f = fruitReader.readCovariant(fruit);
Fruit a = fruitReader.readCovariant(apples);
}
public static void main(String[] args) {
metod2();
}
这样就相当与告诉编译器， fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身)，这样子类和父类之间的关系也就关联上了。
泛型拓展-----PECS原则
上面我们看到了类似的用法，利用它我们可以从list里面get元素，那么我们可不可以往list里面add元素呢？我们来尝试一下：
public class GenericsAndCovariance {
public static void main(String[] args) {
List flist = new ArrayList
// Compile Error: can't add any type of object:
// flist.add(new Apple());
// flist.add(new Orange());
// flist.add(new Fruit());
// flist.add(new Object());
flist.add(null); // Legal but uninteresting
Fruit f = flist.get(0); // We Know that it returns at least Fruit:
}
}
答案是否定，Java编译器不允许我们这样做，为什么呢？对于这个问题我们不妨从编译器的角度去考虑。因为List flist它自身可以有多种含义：
List flist = new ArrayList
List flist = new ArrayList
List flist = new ArrayList
当我们尝试add一个Apple的时候，flist可能指向new ArrayList
当我们尝试add一个Orange的时候，flist可能指向new ArrayList
当我们尝试add一个Fruit的时候，这个Fruit可以是任何类型的Fruit，而flist可能只想某种特定类型的Fruit，编译器无法识别所以会报错。
所以对于实现了的集合类只能将它视为Producer向外提供(get)元素，而不能作为Consumer来对外获取(add)元素。
如果我们要add元素应该怎么做呢？可以使用：
public class GenericWriting {
static List
static List
static
list.add(item);
}
static void method1() {
writeExact(apples, new Apple());
writeExact(fruit, new Apple());
}
static
list.add(item)
}
static void method2() {
writeWithWildcard(apples, new Apple());
writeWithWildcard(fruit, new Apple());
}
public static void main(String[] args) {
method1(); method2();
}
}
这样我们可以往容器里面添加元素了，但是使用super的坏处是以后不能get容器里面的元素了，原因很简单，我们继续从编译器的角度考虑这个问题，对于List list，它可以有下面几种含义：
List list = new ArrayList
List list = new ArrayList
List list = new ArrayList
泛型拓展-----类型擦除
Java泛型中最令人苦恼的地方或许就是类型擦除了，特别是对于有C++经验的程序员。类型擦除就是说Java泛型只能用于在编译期间的静态类型检查，然后编译器生成的代码会擦除相应的类型信息，这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的，为了保持向下的兼容性，所以只能做类型擦除来兼容以前的非泛型代码。对于这一点，如果阅读Java集合框架的源码，可以发现有些类其实并不支持泛型。
说了这么多，那么泛型擦除到底是什么意思呢？我们先来看一下下面这个简单的例子：
public class Node
private T data;
private Node
public Node(T data, Node
this.data = data;
this.next = next;
}
public T getData() {
return data;
}
...
}
编译器做完相应的类型检查之后，实际上到了运行期间上面这段代码实际上将转换成：
public class Node {
private Object data;
private Node next;
public Node(Object data, Node next) {
this.data = data;
this.next = next;
}
public Object getData(){
return data;
}
...
}
这意味着不管我们声明Node
泛型拓展-----工厂模式
接下来我们利用泛型来简单的实现一下工厂模式，首先我们先声明一个接口Factory：
package typeinfo.factory;
public interface Factory
T create();
}
接下来我们来创建几个实体类FuelFilter和AirFilter以及FanBelt和GeneratorBelt。
class Filter extends Part {}
class FuelFilter extends Filter {
public static class Factory implements typeinfo.factory.Factory
public FuelFilter create() {
return new FuelFilter();
}
}
}
class AirFilter extends Filter {
public static class Factory implements typeinfo.factory.Factory
public AirFilter create() {
return new AirFilter();
}
}
}
class Belt extends Part {}
class FanBelt extends Belt {
public static class Factory implements typeinfo.factory.Factory
public FanBelt create() {
return new FanBelt();
}
}
}
class GeneratorBelt extends Belt {
public static class Factory implements typeinfo.factory.Factory
public GeneratorBelt create() {
return new GeneratorBelt();
}
}
}
Part类的实现如下，注意我们上面的实体类都是Part类的间接子类。在Part类我们注册了我们上面的声明的实体类。所以以后我们如果要创建相关的实体类的话，只需要在调用Part类的相关方法了。这么做的一个好处就是如果的业务中出现了CabinAirFilter或者PowerSteeringBelt的话，我们不需要修改太多的代码，只需要在Part类中将它们注册即可。
class Part {
static List
static {
partFactories.add(new FuelFilter.Factory());
partFactories.add(new AirFilter.Factory());
partFactories.add(new FanBelt.Factory());
partFactories.add(new PowerSteeringBelt.Factory());
}
private static Random rand = new Random(47);
public static Part createRandom() {
int n = rand.nextInt(partFactories.size());
return partFactories.get(n).create();
}
public String toString() {
return getClass().getSimpleName();
}
}
最后我们来测试一下：
public class RegisteredFactories {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println(Part.createRandom());
}
}
}