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;
}
}
}
