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

    }

}
下附执行效果