java泛型--概念、使用、自定义……

0，泛型不能有用于static的。

1，Class

Class<Boolean> clazz 等效于 Boolean.class;

Class<T> valueType 等效于 T.class

public void _testGeneric(Class<?>clazz)

等效于

public <B> void _testGeneric(Class<? extends B>clazz){

2，通配符

?只能用于方法泛型，不能用于类泛型。

扫描二维码关注公众号，回复： 640372 查看本文章

3，泛型就是不确定类型

//泛型如果为确定类型时，就没必要存在了，就想这个警告：
//The type parameter Plant is hiding the type Plant
public class Test2<Plant> {
	private Plant t;
	public Plant get(){
		return t;
	}
}

4，把子类使用的其他具体类型传给父类，让父类统一处理。

例子：class Apple extends Fruit extends Plant implements Living

public class PlantFSM<T extends Plant> {
	private T owner;
	public PlantFSM(){}
	public PlantFSM(T owner){
		this.owner = owner;
	}
	public T getOwner() {
		return owner;
	}
	public void setOwner(T owner) {
		this.owner = owner;
	}
}

public class AppleFSM extends PlantFSM<Apple> {
	public AppleFSM(){}
	public AppleFSM(Apple owner) {
		super(owner);
	}
	public static void main(String[] args) {
		AppleFSM appleFSM = new AppleFSM();
		Apple apple = new Apple();
//		自动为Apple类型：com.generic.PlantFSM.setOwner(Apple owner)
		appleFSM.setOwner(apple);
//		自动为Apple类型：Apple com.generic.PlantFSM.getOwner()
		appleFSM.getOwner();
	}
	//方法定义的泛型F
	public <F> F getF(){
		return null;
	}
}

反编译后

public class PlantFSM{
    public PlantFSM(){}
    public PlantFSM(Plant owner){
        this.owner = owner;
    }
    public Plant getOwner(){
        return owner;
    }
    public void setOwner(Plant owner){
        this.owner = owner;
    }
    private Plant owner;
}

public class AppleFSM extends PlantFSM{
    public AppleFSM(){}
    public AppleFSM(Apple owner){
        super(owner);
    }
    public static void main(String args[]){
        AppleFSM appleFSM = new AppleFSM();
        Apple apple = new Apple();
        appleFSM.setOwner(apple);
        appleFSM.getOwner();
    }
    public Object getF(){
        return null;
    }
}

5，

例子2

public interface IProcessor {
	public String process(String idipPacket);
	public int getReqCmdId();
	public int getRespCmdId();
}

/**
 * <"B">与<"BODY">没任何区别，只是一个类型定义（占位符）。
 * @author naijiang.wang
 */
public abstract class AbstractProcessor<BODY> implements IProcessor{
	@Override
	public String process(String json) {
		DataPacket<BODY> dataPacket = getDataPacket(json);
		response = response(dataPacket, serverId);
		Object response = null; 
		try {
			dataPacket = getDataPacket(json);
			response = response(dataPacket, serverId);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(response == null) {
				response = responseForResult(dataPacket.getHead(), ResultType.API_ERROR);
			}
			resp = JsonUtils.toJson(response);
		}
		return resp ;
	}
	//返回的泛型范围，可以大于真实具体的类型返回。比如：DataPacket.body是QueryReq类型。
	private DataPacket<BODY> getDataPacket(String json) {
		return JsonUtils.toBean(json, DataPacket.class, getRequestBodyClass());
	}
	public abstract Class<BODY> getRequestBodyClass();
	private DataPacket<?> response(DataPacket<BODY> dataPacket, Integer serverId) {
		DataPacket<?> response = process(dataPacket.getHead(), dataPacket.getBody(), serverId);
		return response;
	}
	//子类方法中body比如是：QueryReq类型。<?>表示不是BODY泛型
	public abstract DataPacket<?> process(DataHeader head, BODY body, Integer serverId);
}

public class QueryProcessor extends AbstractProcessor<QueryReq>{
	@Override
	public Class<QueryReq> getRequestBodyClass() {
		return QueryReq.class;
	}
	@Override
	public DataPacket<?> process(DataHeader head, QueryReq body, Integer serverId) {
		QueryResp queryResp = new QueryResp();
		//填充数据
		return new DataPacket<QueryResp>(head, queryResp);
	}
}

http://www.infoq.com/cn/articles/cf-java-generics

java泛型--概念、使用、自定义……

猜你喜欢