JAVA开发-泛型实例

2021-02-14 05:19

阅读：808

标签：核心 pac tac war 用例架构 object one this

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

,, 首先这些实际都是泛型中的占位符，也可以换成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());
```
}
}

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

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

/**

泛型接口
@author zhousjmas@hotmail.com
@param
*/
public interface IGenericT {

public T getResult() throws InstantiationException, IllegalAccessException;

}

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

package generic.t.interfaces;

import generic.bean.TypeClass;

/**

泛型类实现及测试,指定具体类实现
@author zhousjmas@hotmail.com
*/@SuppressWarnings(" rawtypes rel="nofollow">br/>@SuppressWarnings("rawtypes")
public class GenericTIImpl implements IGenericT{

@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
*/@SuppressWarnings(" rawtypes rel="nofollow">br/>@SuppressWarnings("rawtypes")
public class GenericT1IImpl implements IGenericT{

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 {

private T t;

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

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

声明了的方法是泛型方法
*/
public T getT(Class 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 genericClassA = new GenericClass(new TypeClass());
//泛型TypeClass1的实现
GenericClass genericClassB = new GenericClass(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();

}

在泛型实现的潜在规则中。通常表示键值对，也就是map中的key,value的意思。通常表示集合中的元素。
在下附的代码中，对 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 {

public Map map;

public List list;

public GenericKVE(Map map) {
this.map = map;
E e = (E) this.map;
this.list = new ArrayList();
this.list.add(e);
}

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

public static void main(String[] args) {
```
Map typeMap = new HashMap();

typeMap.put(new TypeClass(), new TypeClass1());

GenericKVE kve = new GenericKVE(typeMap);

List list = kve.getList();

for(int i=0;i
```
}