在使用类的时候后面的<>中的类型就是我们确定的类型。

public class MyClass1<T> {//此处定义的泛型是T    private T var;    public T getVar() {        return var;    }    public void setVar(T var) {        this.var = var;    }}/** * 最普通的泛型使用，只有一个泛型类型 */@Testpublic void testMyClass1() {    MyClass1<String> clazz = new MyClass1<String>();//此事确定对象对应的泛型T是String    clazz.setVar("stringType");    String str = clazz.getVar();    System.out.println(str);}

和普通的泛型使用基本一样，只是我们可以在使用类的时候定义两个不同的泛型类型，当然我们也可以定义多个，只要我们业务需要。

public class MyClass2<K, V> {//此处定义两个泛型类型    private K var1;//第一个变量的类型是K对应的具体类型    private V var2;//第二个变量的类型是V对应的具体类型    public K getVar1() {        return var1;    }    public void setVar1(K var1) {        this.var1 = var1;    }    public V getVar2() {        return var2;    }    public void setVar2(V var2) {        this.var2 = var2;    }}/** * 含有两个泛型类型的使用 */@Testpublic void testMyClass2() {    //此处确定定义的clazz对象的第一个泛型类型是Integer，第二个泛型类型是String    MyClass2<Integer, String> clazz = new MyClass2<Integer, String>();    clazz.setVar1(1); //此处只能用int类型的参数    clazz.setVar2("string");//此处只能用String类型的参数    System.out.println(clazz.getVar1() + "," + clazz.getVar2());}

这里面又包含3种：没限制的通配符、使用extends限制、使用super限制

public class MyClass3<T> {    private T var;    public T getVar() {        return var;    }    public void setVar(T var) {        this.var = var;    }    @Override    public String toString() {        return var.toString();    }}/** * 通配符？的使用 包括<?>、<？extends 类型>和<？ super 类型> */@Testpublic void testMyClass3() {    MyClass3<Boolean> clazz = new MyClass3<Boolean>();    clazz.setVar(false);    fun(clazz);//调运该方法的时候，对泛型没有限制，任何类型的泛型都可以使用    MyClass3<Integer> clazzInt = new MyClass3<Integer>();    clazzInt.setVar(1);    funExtends(clazzInt);//调运该方法的时候，只能使用Number类型或者其子类型    MyClass3<Double> clazzDouble = new MyClass3<Double>();    clazzDouble.setVar(2.2);    funExtends(clazzDouble);//调运该方法的时候，只能使用Number类型或者其子类型    MyClass3<String> clazzString = new MyClass3<String>();    clazzString.setVar("string");    funSuper(clazzString);//调运该方法的时候，只能使用String类型或者其父类型    MyClass3<Object> clazzObject = new MyClass3<Object>();    clazzObject.setVar(new Object());    funSuper(clazzObject);//调运该方法的时候，只能使用String类型或者其父类型}public void fun(MyClass3<?> clazz) {//没有限制的泛型使用    System.out.println(clazz);}public void funExtends(MyClass3<? extends Number> clazz) {//只能使用Number及其子类的泛型    System.out.println(clazz);}public void funSuper(MyClass3<? super String> clazz) {//只能使用String及其父类的泛型    System.out.println(clazz);}

4.定义类的时候就对泛型进行限制

public class MyClass4<T extends Number> {//定义类的泛型的时候进行泛型的限制    private T var;    public T getVar() {        return var;    }    public void setVar(T var) {        this.var = var;    }    @Override    public String toString() {        return this.var.toString();    }}/** * 定义类的泛型的时候都给定泛型的限制 */@Testpublic void testMyClass4() {    //同样只能定义Number及其子类的泛型    // MyClass4<String> clazzString = new MyClass4<String>();    MyClass4<Integer> clazzInt = new MyClass4<Integer>();    MyClass4<Double> clazzDouble = new MyClass4<Double>();    MyClass4<Float> clazzFClass4 = fun(1.1f);    //此处调运的参数是float类型，这就确定了返回类型必须是float}public <T extends Number> MyClass4<T> fun(T arg) {    return new MyClass4<T>();}

public interface MyInterface<T> {    public T getVar();}//两种实现方式。1，在实现的时候还是使用泛型，到具体定义对象的时候再确定public class MyInterface1Impl<T> implements MyInterface<T> {    private T var;    public MyInterface1Impl() {    }    public MyInterface1Impl(T var) {        this.var = var;    }    @Override    public T getVar() {        return this.var;    }}//第二种实现方式，在实现的时候就确定泛型的类型public class MyInterface2Impl implements MyInterface<String> {    private String varStr;    public MyInterface2Impl() {    }    public MyInterface2Impl(String varStr) {        this.varStr = varStr;    }    @Override    public String getVar() {        return this.varStr;    }}/** * 泛型接口的使用 */@Testpublic void testMyInterface() {    //实现类可以定义为任意类型的泛型    MyInterface1Impl<String> varStr = new MyInterface1Impl<String>("abc");    System.out.println(varStr.getVar());    MyInterface1Impl<Integer> varInt = new MyInterface1Impl<Integer>(123);    System.out.println(varInt.getVar());    //之前已经在类实现的时候已经确定了只能是String    MyInterface2Impl var = new MyInterface2Impl("cba");    String str = var.getVar();    System.out.println(str);}

public class MyFunction {    public <T> T fun1(T arg) {//传入参数和返回参数都是同样的泛型类型        return arg;    }    public <T> void fun2(T arg) {//传入参数是泛型，不需要返回        if (arg instanceof String) {            System.out.println("T is StringType");        } else if (arg instanceof Integer) {            System.out.println("T is IntegerType");        } else {            System.out.println("T is OtherType");        }    }    public <T> String fun3(T arg) {//传入的参数是泛型，返回的确定类型        return arg.toString();    }}/** * 泛型方法的使用 */@Testpublic void MyFunction() {    MyFunction clazz = new MyFunction();        //传入什么类型，返回什么类型    String var1 = clazz.fun1("abc");    int var2 = clazz.fun1(12);    System.out.println(var1);    System.out.println(var2);    //无论传入的是什么类型，都没关系    clazz.fun2(1);    clazz.fun2(false);    clazz.fun2("string");    //无论传入什么，都返回的是String    String var3 = clazz.fun3(123);    String var4 = clazz.fun3("string");    System.out.println(var3);    System.out.println(var4);}

/** * 泛型数组的使用 */@Testpublic void testArray(){    Integer[] arr = fun(1,2,3);   }public <T> T[] fun(T... args){//传入什么类型，T就是什么类型，并且可以使用泛型遍历    for(T t:args){        System.out.println(t.toString());    }    return args;}

/** * 嵌套泛型 */@Testpublic void testNest(){    //外层泛型的类型其实就是内层泛型，当内层泛型确定了，那外层泛型也就确定了    MyClass1<MyClass2<Integer, String>> nestOut = new MyClass1<MyClass2<Integer,String>>();    MyClass2<Integer, String> nestIn = new MyClass2<Integer,String>();    nestIn.setVar1(1);    nestIn.setVar2("a");    nestOut.setVar(nestIn);    System.out.println(nestOut.getVar().getVar1());    System.out.println(nestOut.getVar().getVar2());}

Java中的泛型的使用