JAVA 泛型

package com.xindatai.ibs.lime;

/**
 * 泛型类定义
 * 
 * @author Liang
 *
 * 2017年4月7日
 */
public class Point<T> {

    private T x;
    private T y;
    public Point() {
        super();
        // TODO Auto-generated constructor stub
    }
    /**
     * 泛型类的构造方法定义
     * 
     * @author Liang
     *
     * 2017年4月7日
     */
    public Point(T x, T y) {
        super();
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public T getY() {
        return y;
    }
    public void setY(T y) {
        this.y = y;
    }
    @Override
    public String toString() {
        return "Point [x=" + x + ", y=" + y + "]";
    }
}

package com.xindatai.ibs.lime;

/**
 * 指定多个泛型类型
 * 
 * 如果一个类中有多个属性需要使用不同的泛型声明，则可以在声明类时指定多个泛型类型。
 * 
 * @author Liang
 *
 * 2017年4月7日
 */
public class Notepad<K,V> {

    private K key;
    private V value;
    public Notepad() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Notepad(K key, V value) {
        super();
        this.key = key;
        this.value = value;
    }
    @Override
    public String toString() {
        return "Notepad [key=" + key + ", value=" + value + "]";
    }
    public K getKey() {
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

package com.xindatai.ibs.lime;

public class Info<T> {

    private T var;

    public Info() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Info(T var) {
        super();
        this.var = var;
    }

    @Override
    public String toString() {
        return "Info [var=" + var + "]";
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

}

package com.xindatai.ibs.lime;

/**
 * 在类的声明处指定泛型的上限范围
 * 
 * @author Liang
 *
 * 2017年4月7日
 */
public class InfoNum<T extends Number> {

    private T var;

    public InfoNum() {
        super();
        // TODO Auto-generated constructor stub
    }

    public InfoNum(T var) {
        super();
        this.var = var;
    }

    @Override
    public String toString() {
        return "InfoNum [var=" + var + "]";
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
    
}

package com.xindatai.ibs.lime;

/**
 * 声明泛型接口
 * 
 * @author Liang
 *
 * 2017年4月7日
 */
public interface InfoInter<T> {

    public T getVar();
}

package com.xindatai.ibs.lime;

/**
 * 定义泛型接口子类 方式一：在子类的定义上声明泛型类型
 * @author Liang
 *
 * 2017年4月7日
 */
public class InfoInterImpl1<T> implements InfoInter<T> {

    private T var;
    
    public InfoInterImpl1() {
        super();
        // TODO Auto-generated constructor stub
    }
    public InfoInterImpl1(T var) {
        super();
        this.var = var;
    }
    @Override
    public String toString() {
        return "InfoInterImpl1 [var=" + var + "]";
    }
    @Override
    public T getVar() {
        // TODO Auto-generated method stub
        return null;
    }
    public void setVar(T var) {
        this.var = var;
    }
}

package com.xindatai.ibs.lime;

/**
 * 定义泛型接口子类 方式二：直接在接口中指定具体类型
 * @author Liang
 *
 * 2017年4月7日
 */
public class InfoInterImpl2 implements InfoInter<String>{

    private String var;
    
    public InfoInterImpl2() {
        super();
        // TODO Auto-generated constructor stub
    }
    public InfoInterImpl2(String var) {
        super();
        this.var = var;
    }
    @Override
    public String toString() {
        return "InfoInterImpl2 [var=" + var + "]";
    }
    @Override
    public String getVar() {
        // TODO Auto-generated method stub
        return null;
    }
    public void setVar(String var) {
        this.var = var;
    }

}

package com.xindatai.ibs.lime;

public class Demo {

    /**
     * 定义泛型方法
     * 
     * @author Liang
     *
     * 2017年4月7日
     */
    public <T> T fun(T t){
        return t;
    }
}

package com.xindatai.ibs.lime;

public class InfoNest<T,V> {

    private T var;
    private V value;
    public InfoNest() {
        super();
        // TODO Auto-generated constructor stub
    }
    public InfoNest(T var, V value) {
        super();
        this.var = var;
        this.value = value;
    }
    @Override
    public String toString() {
        return "InfoNest [var=" + var + ", value=" + value + "]";
    }
    public T getVar() {
        return var;
    }
    public void setVar(T var) {
        this.var = var;
    }
    public V getValue() {
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
    
}

package com.xindatai.ibs.lime;

public class DemoNest<S> {

    private S info;

    public DemoNest() {
        super();
        // TODO Auto-generated constructor stub
    }

    public DemoNest(S info) {
        super();
        this.info = info;
    }

    @Override
    public String toString() {
        return "DemoNest [info=" + info + "]";
    }

    public S getInfo() {
        return info;
    }

    public void setInfo(S info) {
        this.info = info;
    }
    
}

package com.xindatai.ibs.lime;

public class Lime {

    public static void main(String[] args) {
        {
            /**
             * 泛型对象定义
             */
            Point<Integer> point = new Point<Integer>();
            point.setX(1);
            point.setY(2);
            System.out.println(point);
        }
        {
            Point<String> point = new Point<String>();
            point.setX("北纬23度");
            point.setY("东经23度");
            System.out.println(point);
        }
        {
            /**
             * 泛型类的构造方法定义 实例化
             */
            Point<Integer> point = new Point<Integer>(1, 2);
            System.out.println(point);
        }
        {
            /**
             * 指定多个泛型类型 实例化
             */
            Notepad<Integer,String> notepad = new Notepad<Integer, String>(1, "lime");
            System.out.println(notepad);
        }
        {
            
            Info info = new Info();        //警告，没有指定泛型类型
            info.setVar("lime");
            System.out.println(info.getVar());
        }
        {
            Info<String> info = new Info<String>("lime");
            fun(info);
        }
        {
            Info<?> info = new Info<String>();
            info.setVar(null);
            System.out.println(info);
        }
        {
            Info<Integer> infoA = new Info<Integer>();
            Info<Float> infoB = new Info<Float>();
            infoA.setVar(20);
            infoB.setVar(20.1f);
            funExtends(infoA);
            funExtends(infoB);
            
        }
        {
            /**
             * 泛型对象声明只能是Number类或Number的子类
             */
            InfoNum<Integer> infoNum = new InfoNum<Integer>();
            System.out.println(infoNum);
        }
        {
            Info<Object> infoA = new Info<Object>();
            Info<String> infoB = new Info<String>();
            infoA.setVar(new Object());
            infoB.setVar("lime");
            funSuper(infoA);
            funSuper(infoB);
        }
        {
            /**
             * 泛型与子类继承的限制
             */
        }
        {
            /**
             * 定义泛型接口
             */
        }
        {
            /**
             * 定义泛型接口的子类 方式一：直接在子类后声明泛型
             */
            {
                InfoInter<String> i = null;
                i = new InfoInterImpl1<String>("lime");
                System.out.println(i);
            }
            /**
             * 定义泛型接口的子类 方式二：直接在接口中指定具体类型
             */
            {
                InfoInter<String> i = null;
                i = new InfoInterImpl2("lime");
                System.out.println(i);
            }
        }
        {
            /**
             * 泛型方法
             */
            Demo demo = new Demo();
            String str = demo.fun("lime");
            Integer i = demo.fun(2);
            System.out.println(str);
            System.out.println(i);
        }
        {
            /**
             * 通过泛型方法返回泛型类实例
             * 
             * 必须在方法的返回类型声明处明确地指定泛型标识
             */
            Info<Integer> info = funInstance(30);
            System.out.println(info);
        }
        {
            /**
             * 使用泛型统一传入的参数类型
             */
            Info<String> i1 = new Info<String>("lime");
            Info<String> i2 = new Info<String>("oracle");
            add(i1,i2);
        }
        {
            /**
             * 泛型数组
             */
            Integer i[] = fun1(1,2,3,4,5,6);
            fun2(i);
        }
        {
            /**
             * 泛型的嵌套设置
             */
            DemoNest<InfoNest<String, Integer>> d = null;
            InfoNest<String, Integer> i = null;
            i = new InfoNest<String, Integer>("lime",23);
            d = new DemoNest<InfoNest<String,Integer>>(i);
            System.out.println(i);
            System.out.println(d);
            System.out.println(d.getInfo().getVar());
            System.out.println(d.getInfo().getValue());
        }
    }

    private static <T> void fun2(T[] i) {
        System.out.println("接收泛型数组");
        for(T t : i){
            System.out.println(t);
        }
    }

    private static <T> T[] fun1(T...arg) {
        return arg;
    }

    private static <T> void add(Info<T> i1, Info<T> i2) {
        System.out.println(i1);
        System.out.println("---------");
        System.out.println(i2);
    }

    /**
     * <T extends Number> : 表示方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定。
     * @author Liang
     *
     * 2017年4月7日
     */
    private static <T extends Number> Info<T> funInstance(T i) {
        Info<T> info = null;
        info = new Info<T>(i);
        return info;
    }

    /**
     * 在引用传递中设置一个泛型对象的范围下限
     * 
     * 接收Info对象，范围上限设置为String，所以只能接收String 或  Object类型的引用
     * 
     * @author Liang
     *
     * 2017年4月7日
     */
    private static void funSuper(Info<? super String> info) {
        System.out.println(info);
    }

    /**
     * 在引用传递中设置一个泛型对象的范围上限
     * 
     * 接收Info对象，范围上限设置为Number，所以只能接收数字类型。
     * @author Liang
     *
     * 2017年4月7日
     */
    private static void funExtends(Info<? extends Number> info) {
        System.out.println(info);
    }

    /**
     * 通配符"?" 表示可以接收此类型的任意泛型对象。
     * 
     * @author Liang
     *
     * 2017年4月7日
     */
    private static void fun(Info<?> info) {
        System.out.println(info);
    }

}