JAVA开发过程中经常会涉及到跟踪源码或查看架构师核心代码的活动。在核心代码或源码中常见有<T>,<E>,<K,V>,Class<?>,<? extends T> <? super T> 相关的代码。看起来十分高大上，又不容易看懂，可能会吓退一些同学。在此做一次整理，并附相应代码供调试理解。

<T>,<E>,<K,V> 首先这些实际都是泛型中的占位符，也可以换成A-Z都是可以的。不是一定要写成这些，也可以A,B,C都是可以的。不过约定俗成的东西方便大家理解，尽量不擅自改动。

在贴录代码之前先说明一下相关类的关系
TypeClass类与TypeClass1是并行的两个演示bean，TypeClassA extends TypeClass, TypeClassB extends TypeClassA

这是基础的关系，下附相关代码
package generic.bean;

/**

• 测试Bean类
• @author zhousjmas@hotmail.com

• */
  public class TypeClass {

  private static String key ;

  private static String value;

  static {
  key = "key-TypeClass";
  value = "value-TypeClass";
  name = "name-TypeClass";
  }

  public int num ;

  private static String name;

  public void getKey() {

  System.out.println("key:"+key);

  }

  public void getValue() {

  System.out.println("value:"+value);

  }

  public void getName() {

  System.out.println("name:"+name);

  }

}

package generic.bean;

public class TypeClass1 {

private static String key ;

private static String value;

static {
    key = "key-TypeClass1";
    value = "value-TypeClass1";
    name = "name-TypeClass1";
}

public int num ;

private static String name;

public void getKey() {

    System.out.println("key:"+key);
}

public void getValue() {

    System.out.println("value:"+value);
}

public void getName() {

    System.out.println("name:"+name);
}

}

package generic.bean;

/**

• 测试Bean类,继承TypeClass
• @author zhousjmas@hotmail.com

• */
  public class TypeClassA extends TypeClass {

  private String typeClassA ;

  public void getTypeClassA(){

  System.out.println("当前对象类型:"+this.getClass().getSimpleName());

  }

}

package generic.bean;

/**

• 测试Bean类,继承TypeClassA
• @author zhousjmas@hotmail.com

• */
  public class TypeClassB extends TypeClassA {

  private String typeClassB ;

  public void getTypeClassB(){

  System.out.println("当前对象类型:"+this.getClass().getSimpleName());

  }
  }

下边首先是<T>的描述，<T> 主要用来表示类型的泛型，有接口泛型，方法泛型和类的泛型

接口泛型，
package generic.t.interfaces;

/**

• 泛型接口
• @author zhousjmas@hotmail.com

• @param <T>
  */
  public interface IGenericT<T> {

  public T getResult() throws InstantiationException, IllegalAccessException;

}

对接口泛型的一种实现，在实现中指定具体的类，ublic class GenericTIImpl implements IGenericT<TypeClass>

package generic.t.interfaces;

import generic.bean.TypeClass;

/**

• 泛型类实现及测试,指定具体类实现
• @author zhousjmas@hotmail.com

• */br/>@SuppressWarnings("rawtypes")
  public class GenericTIImpl implements IGenericT<TypeClass>{

  @Override
  public TypeClass getResult() {

  return new TypeClass();

  }

  public static void main(String[] args) throws InstantiationException, IllegalAccessException {

  IGenericT t = new GenericTIImpl();
  
  TypeClass type =  (TypeClass)t.getResult();
  
  type.getKey();
  
  type.getValue();
  
  type.getName();

  }

}

对接口泛型的第二种实现，不指定具体的类
package generic.t.interfaces;

import generic.bean.TypeClass1;

/**

• 泛型类实现及测试,不指定具体类实现
• @author zhousjmas@hotmail.com

• */br/>@SuppressWarnings("rawtypes")
  public class GenericT1IImpl<T> implements IGenericT<T>{

  private Class clazz;
  public GenericT1IImpl(Class clazz){
  this.clazz = clazz;
  }

  @Override
  public T getResult() throws InstantiationException, IllegalAccessException {
  T t = (T) clazz.newInstance();
  return t;
  }

  public static void main(String[] args) throws InstantiationException, IllegalAccessException {

  IGenericT t = new GenericTIImpl();
  
  TypeClass1 type =  (TypeClass1)t.getResult();
  
  type.getKey();
  
  type.getValue();
  
  type.getName();

  }

}

泛型方法与泛型类的实现，该类就是泛型类的实现，其中getT方法根据入参不同，进行了重载，是需要重点关注的部分

package generic.t.classes;

import generic.bean.TypeClass;
import generic.bean.TypeClass1;

/**

• 泛型类示例
• @author zhousjmas@hotmail.com

• */
  public class GenericClass<T> {

  private T t;

  public GenericClass(T t){
  this.t = t;
  }

  /*

  • 使用了泛型的成员方法并不是泛型方法
    */
    public T getT(){
    return this.t;
    }

  /*

  • 声明了<T>的方法是泛型方法
    */
    public <T>T getT(Class<T> tClass){
    T tt = null;
    try {
    tt = tClass.newInstance();
    } catch (InstantiationException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    } catch (IllegalAccessException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    return tt;
    }

  public static void main(String[] args) {

  //泛型TypeClass的实现
  GenericClass<TypeClass> genericClassA = new GenericClass<TypeClass>(new TypeClass());
  //泛型TypeClass1的实现
  GenericClass<TypeClass1> genericClassB = new GenericClass<TypeClass1>(new TypeClass1());
  
  //调用非泛型方法
  TypeClass typeClass = genericClassA.getT();
  
  TypeClass1 typeClass1 = genericClassB.getT();
  
  typeClass.getName();
  
  typeClass1.getName();
  
  //调用泛型方法
  typeClass = genericClassA.getT(TypeClass.class);
  
  typeClass1 = genericClassA.getT(TypeClass1.class);
  
  typeClass.getName();
  
  typeClass1.getName();

  }

}

在泛型实现的潜在规则中。<K，V> 通常表示键值对，也就是map<key,value>中的key,value的意思 。 <E> 通常表示集合中的元素。
在下附的代码中，对 E,K,V 同时进行了实现

package generic.kve;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import generic.bean.TypeClass;
import generic.bean.TypeClass1;

/**

• KVE占位使用例子
• @author zhousjmas@hotmail.com

• */
  public class GenericKVE<K,V,E> {

  public Map<K,V> map;

  public List<E> list;

  public GenericKVE(Map<K,V> map) {
  this.map = map;
  E e = (E) this.map;
  this.list = new ArrayList<E>();
  this.list.add(e);
  }

  public List<E> getList() {
  return this.list;
  }

  public static void main(String[] args) {

  Map<TypeClass,TypeClass1> typeMap = new HashMap<TypeClass,TypeClass1>();
  
  typeMap.put(new TypeClass(), new TypeClass1());
  
  GenericKVE kve = new GenericKVE(typeMap);
  
  List list = kve.getList();
  
  for(int i=0;i<list.size();i++) {
  
      //打印对象类型名称
      System.out.println(list.get(i).getClass().getSimpleName());
  
      Map map = (Map) list.get(i);
  
      Iterator it = map.keySet().iterator();
  
      while(it.hasNext()) {
  
          Object key = it.next();
          //获取key，也就是k的类型
          System.out.println(key.getClass().getSimpleName());
  
          Object val = map.get(key);
          //获取value，也就是v的类型
          System.out.println(val.getClass().getSimpleName());
      }
  }

  }

}
下附执行结果