java泛型的使用

使用泛型的好处是：在编译的时候检查类型的使用（转化）是否安全，并且所有转化都是自动和隐式的，以及提高了代码重用性。

package org.example.fanxing;

/**
 * DOC 类泛型事例一<br/>
 * 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
 * 
 * @param <T>
 */
public class SomeThing<T> {

    private T t;

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

    private void showType() {
        System.out.println(t.getClass().getName());
    }

    private static class Test {

        public static void main(String[] args) {
            new SomeThing("str").showType();
            new SomeThing(100).showType();
            new SomeThing('a').showType();
            // test results:
            /**
             * java.lang.String<br/>
             * java.lang.Integer<br/>
             * java.lang.Character
             */
        }
    }

}

package org.example.fanxing;

/**
 * 
 * DOC 泛型示例2<br/>
 * 假设要重构两个类，这两个类的变量和方法都一样，就是类型不一样,如StringSub和IntSub<br/>
 * 现在重构这两个类，只要使用泛型就可以了
 * 
 */
public class ObjectFanXing<T> {

    private T a;

    public ObjectFanXing(T t) {
        this.a = t;
    }

    public T getA() {
        return this.a;
    }

    public void setA(T t) {
        this.a = t;
    }

    private static class Test {

        public static void main(String[] args) {
            System.out.println("string.getA=" + new ObjectFanXing<String>("str").getA());
            System.out.println("double.getA=" + new ObjectFanXing<Double>(12.2222335).getA());
            System.out.println("object.getA=" + new ObjectFanXing<Object>(new Object()).getA());
            // test results:
            /**
             * string.getA=str<br/>
             * double.getA=12.2222335<br/>
             * object.getA=java.lang.Object@dc8569
             */
        }
    }

    /**
     * private class StringSub {
     * 
     * String a;
     * 
     * public String getA() { return this.a; }
     * 
     * public void setA(String a) { this.a = a; }
     * 
     * }
     * 
     * private class IntSub {
     * 
     * private Integer a;
     * 
     * public Integer getA() { return this.a; }
     * 
     * public void setA(Integer a) { this.a = a; } }
     */

}

package org.example.fanxing;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 
 * DOC 泛型示例3<br/>
 * 带限制的泛型，可以限制传入的泛型为某个类的子类，或者实现了某个接口的类 <br/>
 * ? 表示通用泛型<br/>
 * 如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。<br/>
 * 通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。
 * 
 * 
 */
public class LimitFanxing<T extends Collection> {

    private T t;

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

    public T getT() {
        return this.t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public static class Test {

        public static void main(String[] args) {
            LimitFanxing<ArrayList> fanxing = new LimitFanxing<ArrayList>(new ArrayList());
            LimitFanxing<? extends Collection> fanxing2 = new LimitFanxing<ArrayList>(new ArrayList());
        }
    }

}