范型方法 & 范型参数 & 范型返回值

Java范型类

public class FanXingClassTest {
    public static void main(String args[]){
        Test<Integer> intObj = new Test<Integer>(123);
        Test<String> strObj = new Test<String>("一二三");
        intObj.showType();
        strObj.showType();
    }
}

/**
 * 定义范型类
 * @param <T>
 */
class Test<T>{
    private T ob; //定义范型的成员变量

    public Test(T ob){
        this.ob = ob;
    }

    public void setT(T ob){
        this.ob = ob;
    }
    public T getT(){
        return this.ob;
    }

    public void showType(){
        System.out.println("T的实际类型是:"+ob.getClass());
    }
}

　　对比一下没有使用范型类(如下代码)，也可以输出一样的结果，为什么要使用范型类？类型检查？？

public class FanXingClassTest {
    public static void main(String args[]){
        Test intObj = new Test(123);
        Test strObj = new Test("一二三");
        intObj.showType();
        strObj.showType();
    }
}
/**
 * 定义普通类
 */
class Test{
    private Object ob; // 不能定义T类型的变量？？

    public Test(Object ob){
        this.ob = ob;
    }

    public void setT(Object ob){
        this.ob = ob;
    }
    public Object getT(){
        return this.ob;
    }

    public void showType(){
        System.out.println("T的实际类型是:"+ob.getClass());
    }
}

我们做实验如下：

// 两个基本类：StringDemo和DoubleDemo
public class StringDemo {
    private String str;

    public StringDemo(String str){
        this.str = str;
    }

    public void setStr(String str){
        this.str = str;
    }
    public String getStr(){
        return this.str;
    }
}
public class DoubleDemo {
    private Double doubleVal;

    public DoubleDemo(Double doubleVal){
        this.doubleVal = doubleVal;
    }
    public void setDoubleVal(Double doubleVal){
        this.doubleVal = doubleVal;
    }
    public Double getDoubleVal(){
        return this.doubleVal;
    }
}

// 因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了，实际上就是“Object泛型”，暂时这么称呼。
public class ObjectDemo {
    private Object obj;

    public ObjectDemo(Object obj){
        this.obj = obj;
    }
    public void setObj(Object obj){
        this.obj = obj;
    }
    public Object getObj(){
        return this.obj;
    }
}
public class MyDemo {
    public static void main(String args[]){
        ObjectDemo str = new ObjectDemo("string");
        ObjectDemo dble = new ObjectDemo(123d);
        ObjectDemo obj = new ObjectDemo(new Object());
        System.out.println(str.getObj());
        System.out.println(dble.getObj());
        System.out.println(obj.getObj());
    }
}

// 在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，
// 然后才可以调用对象上的方法。强制类型转换很麻烦，我还要事先知道各个Object具体类型是什么，才能做出正确转换。否则，要是转换的类型不对，比如将
// “Hello Generics!”字符串强制转换为Double,那么编译的时候不会报错，可是运行的时候就挂了。那有没有不强制转换的办法----有，改用 Java5泛型来实现，
// 示例见最上面FanXingClassTest<T>范型类的定义。

范型类语法解释

1. 使用<T>来声明一个类型持有者名称，然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。
2. class GenericsTest<T> 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsTest<T extends Object>。
3. 与Object泛型类相比，使用泛型所定义的类在声明和构造实例的时候，可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如
GenericsTest<Double> douTest=new GenericsTest<Double>(new Double("33"));
4. 实际上，当构造对象时不指定类型信息的时候，默认会使用Object类型，这也是要强制转换的原因.

限制范型

　　在上面的例子中，由于没有限制class GenericsTest<T>类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做：class GenericsTest<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。注意：<T extends Collection>这里的限定使用关键字extends，后面可以是类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。

// 限制范型
public class CollectionGenTest<T extends Collection> {
    private T x;
    public CollectionGenTest(T x){
        this.x = x;
    }
    public T getX(){
        return this.x;
    }
    public void setX(T x){
        this.x = x;
    }
}
public class CollectionGenTestDemo {
    public static void main(String args[]){
        CollectionGenTest<ArrayList> test = new CollectionGenTest<ArrayList>(new ArrayList());
        System.out.println("实例化完成");
    }
}

// 多接口限制
<T extends SomeClass & interface1 & interface2 & interface3>

// 通配符范型
<T extends Collection> //向下限制
<?> //任意类型，相当于Object
<T super Double> // 向上限制，Double类型或者其父类

Java范型方法

/**
 * 范型方法:只需在返回值前添加<T>
 */
public class ExampleA {
    public <T> void f(T x){
        System.err.println(x.getClass().getName());
    }

    public static void main(String args[]){
        ExampleA exampleA = new ExampleA();
        exampleA.f("");
        exampleA.f(123);
        exampleA.f('a');
        exampleA.f(exampleA);
    }
}

// 使用泛型方法时，不必指明参数类型，编译器会自己找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样
// 一个static方法，无法访问泛型类的类型参数，所以，若要static方法需要使用泛型能力，必须使其成为泛型方法。

方法

1. 定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，

2. Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

3.   http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html