JAVA泛型（代码级解释）

/**
 * Program  : LearnPattern.java
 * Author   : tanx
 * Create   : 2013-5-10 下午4:22:46
 *
 */
package pattern;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @author tanx
 * @version 1.0.0
 * @2013-5-10 下午4:22:46
 */
public class LearnPattern<K, V> {
	// 推荐的命名约定是使用大写的单个字母名称作为类型参数。这与 C++ 约定有所不同（参阅 附录 A：与 C++
	// 模板的比较），并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式，推荐的名称是：
	//
	// K —— 键，比如映射的键。
	// V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。
	// E —— 异常类。
	// T —— 泛型

	// Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，
	// tanx:显示的约定，而不是存在于程序员的头脑中，注释里，编译器帮我们杜绝错误，而不是运行BUG

	// 消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
	// 类型检查从执行时挪到了编译时，这会提高可靠性并加快开发速度

	public void put(K key, V value) {//使用类定义的   相同的类型

	}
	public V get(K key) {//使用类定义的   相同的类型
		return null;
	}

	//限定传入参数类型与返回类型相同，没在类定义泛型就要在方法名前加<T> ,T可以是其他字母
	public <T> T addTest(T value) { 
		return null;
	}

	public void testCase1() {
		LearnPattern<Integer, String> bb = new LearnPattern<Integer, String>();
		bb.put(1, "test"); // 一定传对参数
		String test = bb.get(1); // 无需类型转换
	}

	public void testCase2() {
		List<Integer> intList = new ArrayList<Integer>();
		intList.add(2);
		// List<Number> numberList = intList; // 无法转换 ，泛型不是协变的
		// numberList.add(2.0); // 如果能转换，那么这个2.0就能加，但实际intList不能加2.0
		List<?> numberList = intList; // 可以转成 ? 时常用于升级代码，消除转换警告，但请注意下面
		// numberList.add(2);// ? 无法添加
		System.out.println(numberList.get(0));// ? 能做查询
		numberList.clear();// ? 能做删除
	}

	// 多个参数约束
	public <T> T ifThenElse(boolean b, T first, T second) {
		return b ? first : second;
	}

	public void testCase3() {
		String s = ifThenElse(false, "a", "b");
		Integer i = ifThenElse(false, new Integer(1), new Integer(2));
		// 非法，不仅仅是口头约束，注释，或者直接运行时出错
		// String s = ifThenElse(b, "pi", new Float(3.14));
	}

	// 限制类型 //明白无误告诉别人，这个类里面属性test只能为Number子类
	public class testCase4<T extends Number> {
		private T test;
	}

	interface Collection<V> {
		boolean addAll(Collection<? extends V> c); // 不改变原来的语义，可添加集合及子类集合
		boolean removeAll(Collection<?> c); // 删除混合的集合类
	}

	// class Enum<E extends Enum<E>>
	// 类型参数 E 用于 Enum 的各种方法中，比如 compareTo() 或 getDeclaringClass()。
	// 为了这些方法的类型安全，Enum 类必须在枚举的类上泛型化。
	//
	// Enum<E> 这个是它本身 ， E extends Enum<E> 表示是它本身的子类型
	// 因为枚举类实现了implements Comparable<E>  ，有如下方法：
	// public final int compareTo(E o) {
	// 		Enum other = (Enum)o;
	// 		Enum self = this;
	// 		if (self.getClass() != other.getClass() && // optimization
	// 		self.getDeclaringClass() != other.getDeclaringClass())
	// 		throw new ClassCastException();
	// 		return self.ordinal - other.ordinal;
	// }
	
	// public final Class<E> getDeclaringClass() {
	// 		Class clazz = getClass();
	// 		Class zuper = clazz.getSuperclass();
	// 		return (zuper == Enum.class) ? clazz : zuper;
	// }	
	//API解释
	//public final Class<E> getDeclaringClass()
	//返回与此枚举常量的枚举类型相对应的 Class 对象。
	//    当且仅当 e1.getDeclaringClass() == e2.getDeclaringClass() 时，
	//    两个枚举常量 e1 和 e2 的枚举类型才相同。（由该方法返回的值不同于由 Object.getClass() 
	//    方法返回的值，Object.getClass() 方法用于带有特定常量的类主体的枚举常量。）
	//返回：
	//与此枚举常量的枚举类型相对应的 Class 对象

	// public native Class<? super T> getSuperclass(); //Class的本地方法，返回该类的父类型
	public Class<? super Integer> testCase5() { // 返回Integer的父类类型
		return null;
	}
	
	//特殊效果演示
	abstract class Foo <T extends Foo<T>>{
		public abstract T subclassAwareDeepCopy();		
	}

	class Bar extends Foo<Bar> {
	    public Bar subclassAwareDeepCopy() {
	        Bar b = new Bar();
	        // ...
	        return b;
	    }	    	   
	}
	
	public class testCase5<T extends Number> {
		Bar b = new Bar();
    	Foo<Bar> f = b; // 子类和父类相互赋值
    	Bar bb2 = b.subclassAwareDeepCopy();
    	Bar bb3 = f.subclassAwareDeepCopy(); // 父类直接返回子类的实例，而且不用Cast
    	
    	Bar1 b1 = new Bar1();
		Foo1<Foo1> f1 = b1; // 子类和父类相互赋值
    	Bar1 b12 = b1.subclassAwareDeepCopy();
    	Bar1 b13 = (Bar1)f1.subclassAwareDeepCopy(); // 父类返回子类的实例，需要Cast
    	
    	Bar2 b2 = new Bar2();
    	Foo2 f2 = b2; // 子类和父类相互赋值
    	Bar2 b22 = b2.subclassAwareDeepCopy();
    	Bar2 b23 = (Bar2)f2.subclassAwareDeepCopy(); // 父类返回子类的实例，需要Cast
    	
	}

	//对比1  -----------------------------------------------------------------------
	abstract class Foo1<T> {
		public abstract T subclassAwareDeepCopy();		
	}

	//这里因为没有约束，所以我们可以随意填，你可能认为这填Bar1就不用转型了，
	//但那只存在于我们脑海中，如果是给别人提供api接口，显然要用 <T extends Foo<T>>
	class Bar1 extends Foo1<Foo1> {
	    public Bar1 subclassAwareDeepCopy() {
	        Bar1 b = new Bar1();
	        // ...
	        return b;
	    }	    	   
	}
	
	//对比2  -----------------------------------------------------------------------
	abstract class Foo2 {
		public abstract Foo2 subclassAwareDeepCopy();		
	}

	class Bar2 extends Foo2 {
	    public Bar2 subclassAwareDeepCopy() {
	        Bar2 b = new Bar2();
	        // ...
	        return b;
	    }	    	   
	}
	

}