<T>,<E>,<K,V> 首先这些实际都是泛型中的占位符，也可以换成A-Z都是可以的。不是一定要写成这些，也可以A,B,C都是可以的。不过约定俗成的东西方便大家理解，尽量不擅自改动。
在贴录代码之前先说明一下相关类的关系
TypeClass类与TypeClass1是并行的两个演示bean，TypeClassA extends TypeClass, TypeClassB extends TypeClassA
这是基础的关系，下附相关代码
package generic.bean;
/**
*/
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;
/**
*/
public class TypeClassA extends TypeClass {
private String typeClassA ;
public void getTypeClassA(){
System.out.println("当前对象类型:"+this.getClass().getSimpleName());}
}
package generic.bean;
/**
*/
public class TypeClassB extends TypeClassA {
private String typeClassB ;
public void getTypeClassB(){
System.out.println("当前对象类型:"+this.getClass().getSimpleName());}
}
下边首先是<T>的描述，<T> 主要用来表示类型的泛型，有接口泛型，方法泛型和类的泛型
接口泛型，
package generic.t.interfaces;
/**
@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;
/**
*/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;
/**
*/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;
/**
*/
public class GenericClass<T> {
private T t;
public GenericClass(T t){
this.t = t;
}
/*
/*
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;
/**
*/
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());
}
}}
}
下附执行结果
原文：https://blog.51cto.com/4890631/2488309