Java泛型

当把一个对象丢进集合中后，集合就会忘记这个对象的数据类型，再次取出时变成了Object，有可能出现异常。

    public class ListErr {
        public static void main(String[] args) {
            List strList = new ArrayList();
            strList.add("a");
            strList.add("b");
            strList.add(5);
            // 企图把Interger转成String，导致异常
            strList.forEach(str -> Symtem.out.println(((String)str).length()));
        }
    }

所以对集合的类型需要进行规范。再来看一下ArrayList

ArrayList<String> strList = new ArrayList<String>();  
ArrayList<Integer> intList = new ArrayList<Integer>(); 
ArrayList<Double> doubleList = new ArrayList<Double>(); 

大家对ArrayList很熟悉，这里构造了三个List,分别盛装String、Integer和Double；这就是ArrayList的过人之处：即各种类型的变量都可以组装成对应的List，而不必针对每个类型分别实现一个构建ArrayList的类。

没有泛型的后果

    //设置Integer类型的点坐标  
    class IntegerPoint{  
        private Integer x ;       // 表示X坐标  
        private Integer y ;       // 表示Y坐标  
        public void setX(Integer x){  
            this.x = x ;  
        }  
        public void setY(Integer y){  
            this.y = y ;  
        }  
        public Integer getX(){  
            return this.x ;  
        }  
        public Integer getY(){  
            return this.y ;  
        }  
    }  
    //设置Float类型的点坐标  
    class FloatPoint{  
        private Float x ;       // 表示X坐标  
        private Float y ;       // 表示Y坐标  
        public void setX(Float x){  
            this.x = x ;  
        }  
        public void setY(Float y){  
            this.y = y ;  
        }  
        public Float getX(){  
            return this.x ;  
        }  
        public Float getY(){  
            return this.y ;  
        }  
    }  

除了变量类型不一样，一个是Integer一个是Float以外，其它并没有什么区别！那我们能不能合并成一个呢？

    //定义  
    // T此处可以随便写标识符号
    class Point<T> {    
        private T x ;        
        private T y ;        
        public void setX(T x){//作为参数  
            this.x = x ;  
        }  
        public void setY(T y){  
            this.y = y ;  
        }  
        public T getX(){//作为返回值  
            return this.x ;  
        }  
        public T getY(){  
            return this.y ;  
        }  
    };  

在new的同时指定了类型

    //IntegerPoint使用
    Point<Integer> p = new Point<Integer>() ;   
    p.setX(new Integer(100)) ;   
    System.out.println(p.getX());

大写字母的规范一般是

• E — Element，常用在java Collection里，如：List<E>,Iterator<E>,Set<E>
• K,V — Key，Value，代表Map的键值对
• N — Number，数字
• T — Type，类型，如String，Integer等等

菱形语法

在Java7之前，构造器的后面也必须带泛型

    List<String> strList = new ArrayList<String>();

从Java7之后可以简化为

    List<String> strList = new ArrayList<>();

在类、接口中定义

所谓泛型，就是允许在定义类、接口和方法时使用类型形参，如下所示

    public interface List<E> {
        void add(E x);
        Iterator<E> interator();
    }
    public interface Iterator<E> {
        E next();
        boolean hasNext();
    }

当使用List< String>的时候，等同于如下接口

    public interface ListString extends List {
        void add(String x);
        Iterator<String> interator();
    }

具体例子

这里看下具体例子

    public class ServiceResult<T> implements Serializable {
        private static final long serialVersionUID = 1340563394201259857L;
        protected boolean success;
        protected String errorCode;
        protected String errorMsg;
        protected T result;
        protected Object[] arguments;

        public Object[] getArguments() {
            return this.arguments;
        }

        public void setArguments(Object[] arguments) {
            this.arguments = arguments;
        }

        public String getErrorCode() {
            return this.errorCode;
        }

        public void setErrorCode(String errorCode) {
            this.errorCode = errorCode;
        }

        public String getErrorMsg() {
            return this.errorMsg;
        }

        public void setErrorMsg(String errorMsg) {
            this.errorMsg = errorMsg;
        }

        public ServiceResult() {
        }

        public boolean isSuccess() {
            return this.success;
        }

        public void setSuccess(boolean success) {
            this.success = success;
        }

        public T getResult() {
            return this.result;
        }

        public void setResult(T result) {
            this.result = result;
        }
        // 共出现了三个T，第一个是用来声明类型参数的，后面的两个才是泛型的实现
        public static <T> ServiceResult<T> getSuccessResult(T v) {
            ServiceResult<T> result = new ServiceResult();
            result.setSuccess(true);
            result.setResult(v);
            return result;
        }

        public static <T> ServiceResult<T> getFailureResult(String errorCode, String msg) {
            ServiceResult<T> result = new ServiceResult();
            result.setSuccess(false);
            result.setErrorCode(errorCode);
            result.setErrorMsg(msg);
            return result;
        }
    }

在使用的时候

    ServiceResult<xxVO> orgResult = orgService.getOrgInfo(xxId);
    xxVO xx = orgResult.getResult();