Java中泛型的各种使用

转自：http://www.tuicool.com/articles/mmYnyqN
1.普通的泛型使用

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

public class MyClass1<T> {//此处定义的泛型是T
private T var;

public T getVar() {
return var;
    }

public void setVar(T var) {
this.var = var;
    }
}
/**
 * 最普通的泛型使用，只有一个泛型类型
 */
@Test
public 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;
    }

}

/**
 * 含有两个泛型类型的使用
 */
@Test
public 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 类型>
 */
@Test
public 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();
    }

}

/**
 * 定义类的泛型的时候都给定泛型的限制
 */
@Test
public 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;
    }
}

/**
 * 泛型接口的使用
 */
@Test
public 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();
    }
}

/**
 * 泛型方法的使用
 */
@Test
public 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);

}

/**
 * 泛型数组的使用
 */
@Test
public 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;
}

/**
 * 嵌套泛型
 */
@Test
public 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());
}