泛型

今天在博客上看到一篇非常好的文章，关于泛型的：http://www.importnew.com/24029.html

本篇基本搬运（其实就是抄袭了- -、）链接中的内容。红色部分是我个人的见解。

一、泛型基础

1，泛型类

定义一个简单的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> {
	// T stands for "Type"
	private T t;
	public void set(T t) { this.t = t; }
	public T get() { return t; }
}

这样我们的Box类便可以得到复用，我们可以将T替换成任何我们想要的类型：

Box<Integer> integerBox = new Box<Integer>();
Box<Double> doubleBox = new Box<Double>();
Box<String> stringBox = new Box<String>();

2，泛型方法

声明一个泛型方法很简单，只要在返回类型前面加上一个类似<K, V>的形式就行了：

public class Util {
	public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
		return p1.getKey().equals(p2.getKey()) &&
			p1.getValue().equals(p2.getValue());
	}
}
public class Pair<K, V> {
	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; }
}

像下面这样去调用泛型方法：

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);

或者在Java1.7/1.8利用type inference，让Java自动推导出相应的类型参数：

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

最简单的泛型方法是下面这种形式的：

public <T> T method1(T t) {
	return t;
}

public <T> void method2(T t) {
	
}

3，边界符

现在我们要实现这样一个功能，查找一个泛型数组中大于某个特定元素的个数，我们可以这样实现：

public static <T> int countGreaterThan(T[] anArray, T elem) {
	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<T> {
	public int compareTo(T o);
}

做一个类似于下面这样的声明，这样就等于告诉编译器类型参数T代表的都是实现了Comparable接口的类，这样等于告诉编译器它们都至少实现了compareTo方法。

public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
	int count = 0;
	for (T e : anArray)
		if (e.compareTo(elem) > 0)
			++count;
	return count;
}

这个有点类似Object对象里的equals()方法，只不过equals()是重写（@Override），而这里是实现这个Comparable接口。

下面的是我的实现，和上面的不太一样，个人觉得他写的是有点问题的，按照他那Comparable接口的写法，

实现类是写不出来的。因为不知道这个T究竟是指代的啥？不知道T是啥，那如何比较T？因为比较总是要有依据的。

比如T指代的是人，人有高矮，胖瘦，美丑等之分，那比较的时候，是依据啥比较？

个人见解，望指正

-----------------------------------本人实现 START--------------------------------------------

Comparable接口：

public interface Comparable {
	<T> boolean compareTo(T t);
}

Comparable的实现类：IntegerComparable

public class IntegerComparable implements Comparable {

	private int a;

	@Override
	public <T> boolean compareTo(T t) {
		IntegerComparable it = (IntegerComparable) t;
		return this.a > it.getA();
	}
	
	// Getters And Setters
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;
	}
}

测试类：

public class Test {

	public static <T extends Comparable> int countGreaterThan(T[] anArray, T elem) {
		int count = 0;
		for (T e : anArray)
			if (e.compareTo(elem))
				++count;
		return count;
	}
	
	public static void main(String[] args) {
		Comparable[] anArray = new IntegerComparable[3];
		IntegerComparable elem1 = new IntegerComparable();
		elem1.setA(9);
		IntegerComparable elem2 = new IntegerComparable();
		elem2.setA(11);
		IntegerComparable elem3 = new IntegerComparable();
		elem3.setA(12);
		anArray[0] = elem1;
		anArray[1] = elem2;
		anArray[2] = elem3;
		
		IntegerComparable elem = new IntegerComparable();
		elem.setA(10);
		
		int i =  countGreaterThan(anArray, elem);
		System.out.println(i);
	}
}

-----------------------------------本人实现  END--------------------------------------------

二、通配符

在了解通配符之前，我们首先必须要澄清一个概念，还是借用我们上面定义的Box类，假设我们添加一个这样的方法：

public class Test {
	public static void boxTest(Box<Number> n) {
		
	}
	public static void main(String[] args) {
		Box<Number> n = new Box<Number>();
		boxTest(n);
		
//		Box<Integer> i = new Box<Integer>();
		// The method boxTest(Box<Number>) in the type Test is not applicable for the arguments (Box<Integer>)
//		boxTest(i);
	}
}

那么现在Box<Number> n允许接受什么类型的参数？我们是否能够传入Box<Integer>或者Box<Double>呢？答案是否定的，虽然Integer和Double是Number的子类，但是在泛型中Box<Integer>或者Box<Double>与Box<Number>之间并没有任何的关系。这一点非常重要，接下来我们通过一个完整的例子来加深一下理解。

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}

下面这个例子中，我们创建了一个泛型类Reader，然后在f1()中当我们尝试Fruit f = fruitReader.readExact(apples);编译器会报错，因为List<Fruit>与List<Apple>之间并没有任何的关系。

public class GenericReading {
	public static List<Apple> apples = Arrays.asList(new Apple());
	public static List<Fruit> fruit = Arrays.asList(new Fruit());
	public static class Reader<T> {
		T readExact(List<T> list) {
			return list.get(0);
		}
	}
	public static void f1() {
		Reader<Fruit> fruitReader = new Reader<Fruit>();
		// The method readExact(List<Fruit>) in the type GenericReading.
		// Reader<Fruit> is not applicable for the arguments (List<Apple>)
//		Fruit f = fruitReader.readExact(apples);
	}
	public static void main(String[] args) {
		f1();
	}
}

但是按照我们通常的思维习惯，Apple和Fruit之间肯定是存在联系，然而编译器却无法识别，那怎么在泛型代码中解决这个问题呢？我们可以通过使用通配符来解决这个问题，上面的GenericReading类更改如下：

static class CovariantReader<T> {
	T readCovariant(List<? extends T> list) {
		return list.get(0);
	}
}
static void f2() {
	CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
	Fruit f = fruitReader.readCovariant(fruit);
	Fruit a = fruitReader.readCovariant(apples);
}
public static void main(String[] args) {
	f2();
}

这样就相当与告诉编译器， fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身)，这样子类和父类之间的关系也就关联上了。