Java基础之泛型

概述

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

什么是泛型？

​ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

​ 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

为什么要使用泛型？

​ Java语言引入泛型的好处是安全简单。可以将运行时错误提前到编译时错误。在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型的特性

泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

public class Generics<T> {	
	 
    private T key; 
 
    public Generics(T key) { 
        this.key = key;
    }
    public T getKey(){ 
        return key;
    }
    
	public static void main(String[] args) {
		
	    Class genericInteger = new Generics<Integer>(123456).getClass();
	    Class genericNumber = new Generics<Number>(456).getClass();
		Class genericString = new Generics<String>("key_vlaue").getClass();
		
		System.out.println(genericInteger==genericString);
		System.out.println(genericInteger==genericNumber);

//output
true,true //在泛型内部，无法获得任何有关泛型参数类型的信息。Generics<String>和Generics<Integer>是相同的类型

泛型通配符

我们知道Ingeter是Number的一个子类，上述代码也验证过Generic<Ingeter>与Generic<Number>实际上是相同的一种基本类型。那么问题来了，在使用Generic<Number>作为形参的方法中，能否使用Generic<Ingeter>的实例传入呢？在逻辑上类似于Generic<Number>和Generic<Ingeter>是否可以看成具有父子关系的泛型类型呢？

public class Generics<T> {		 
    private T key; 
    public Generics(T key) { 
        this.key = key;
    }
    public T getKey(){ 
        return key;
    }
    public static void showKeyValue(Generics<Number> obj){
    	System.out.println("key is " + obj.getKey());
    }
	public static void main(String[] args) {
		
		Generics<Integer> genericInteger = new Generics<Integer>(123456);
		Generics<Number> genericNumber = new Generics<Number>(456);
	    showKeyValue(genericInteger);// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> 
									// cannot be applied to Generic<java.lang.Number>
	    showKeyValue(genericNumber);	
	}
}

我们可以将上面的方法改一下：

public static void showKeyValue(Generics<?> obj){
    	System.out.println("key is " + obj.getKey());
}

此处’？’是类型实参，而不是类型形参 。再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

泛型的上界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

普通法的上界

上述例子

public static void showKeyValue(Generics<?> obj){
    	System.out.println("key is " + obj.getKey());
}
....
Generics<String> genericString = new Generics<String>("abc");
showKeyValue(genericString); //没问题

修改成

public static void showKeyValue(Generics<? extends Number> obj){
    	System.out.println("key is " + obj.getKey());
}
....
Generics<String> genericString = new Generics<String>("abc");
showKeyValue(genericString); //报错

类的上界

上述例子

public class Generics<T> {
  
}

修改成

public class Generics<T extends number> {

}
Generics<String> genericString = new Generics<String>("abc"); //报错

泛型方法的上界

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

泛型的下界

既然有了通配符的上界，自然有着通配符的下界。使用（? super ），类的父类都可以，子类不行，我们知道Integer是Number的一个子类，如果

public static void showKeyValue(Generics<? extends Number> obj){
    	System.out.println("key is " + obj.getKey());
}
Generics<Integer> genericInteger = new Generics<Integer>(123456);
showKeyValue(genericInteger);//没问题


public static void showKeyValue(Generics<? super Number> obj){
    	System.out.println("key is " + obj.getKey());
}
Generics<Integer> genericInteger = new Generics<Integer>(123456);
showKeyValue(genericInteger);//报错

泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

注意：泛型的类型参数只能是类类型，不能是简单类型；不能对确切的泛型类型使用instanceof操作。

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generics<T> {	
	 
    private T key; //key这个成员变量的类型为T,T的类型由外部指定 
 
    public Generics(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
		//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
		Generics<Integer> genericInteger = new Generics<Integer>(123456);
		//传入的实参类型需与泛型的类型参数类型相同，即为String.
		Generics<String> genericString = new Generics<String>("key_vlaue");
		System.out.println("泛型测试 , key is " + genericInteger.getKey());
		System.out.println("泛型测试 , key is " + genericString.getKey());
      
      
        //如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型
      	Generics generic = new Generics(67890);
		System.out.println("泛型测试 , key is " + generic.getKey());
	}
}
//output
泛型测试 , key is 123456
泛型测试 , key is key_vlaue
泛型测试 , key is 67890

泛型接口

import java.util.Random;  
interface Generator<T> {  
    public T next();  
}  //定义一个泛型接口
class Coffee{  
    public String toString(){  
        return getClass().getSimpleName();  
    }  
}   
class Mocha extends Coffee{}  
class Cappuccino extends Coffee{}  
class Breve extends Coffee{}  
class Latte extends Coffee{}  
/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class CoffeeGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class CoffeeGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class CoffeeGenerator implements Generator<Coffee>{ //T为Coffee  
    private static Random rand = new Random();  
    private Class[] types = {Latte.class, Mocha.class, Cappuccino.class, Breve.class};
	@Override
	public Coffee next() {//T为Coffee 
		try {  
            return (Coffee)  
                    types[rand.nextInt(types.length)].newInstance();  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }   
	}  
}  
public class Genericstest {
	public static void main(String[] args) {
		        CoffeeGenerator gen = new CoffeeGenerator();  
		        for(int i=0; i<4; i++){  
		            System.out.println(gen.next());  
		        }  
	 }
}

泛型方法

​ 泛型方法使得该方法能独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数。所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

示例如下：

public class Genericsmethod {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}
class Fruit{
    @Override
    public String toString() {
        return "fruit";
    }
}
class Apple extends Fruit{
    @Override
    public String toString() {
        return "apple";
    }
}
class Person{
    @Override
    public String toString() {
        return "Person";
    }
}
class GenerateTest<T>{
    public void show_1(T t){
        System.out.println(t.toString());
    }
    //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
    //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
    public <E> void show_2(E t){
        System.out.println(t.toString());
    }
    //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
    public <T> void show_3(T t){
        System.out.println(t.toString());
    }
}

如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法如下：

public static void show_1(T t){
        System.out.println(t.toString());
    } // 错误
public static <T>void show_1(T t){
        System.out.println(t.toString());
    } // 正确

泛型的示例

泛型数组

List<?>[] ls = new ArrayList<?>[10]; //正确
List<String>[] ls = new ArrayList[10];//正确
List<String>[] ls = new ArrayList<String>[10];//错误

元组的使用

/**
 * 容纳两个对象
 * @param <A>
 * @param <B>
 */
public class TwoTuple<A,B> {
//定义成final,返回后不可修改
	public final A first;
	public final B second;
	public TwoTuple(A a,B b)
		{
			first=a;
			second=b;
		}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return first.toString()+second.toString();
	}
	
	public static TwoTuple<String,Integer> f()
	{
		TwoTuple<String,Integer> two=new TwoTuple<String,Integer>("asfdsaf", 55535);
		return two;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TwoTuple<String,Integer> two=f();
		System.out.println(two);
		System.out.println(two.first);
		System.out.println(two.second);
		 
		}
}

/**
 * 
 * 容纳三个对象
 *
 * @param <A>
 * @param <B>
 * @param <C>
 */
class ThreeTuple<A,B,C> extends TwoTuple<A, B>{
	public final C third;
	public ThreeTuple(A a,B b,C c)
	{
		super(a, b);
		third=c;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString()+third.toString();
	}
}

普通泛型

class Point<T>{       // 此处可以随便写标识符号，T是type的简称  
    private T var ; // var的类型由T指定，即：由外部指定  
    public T getVar(){  // 返回值的类型由外部决定  
        return var ;  
    }  
    public void setVar(T var){  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
};  
public class GenericsDemo06{  
    public static void main(String args[]){  
        Point<String> p = new Point<String>() ; // 里面的var类型为String类型  
        p.setVar("it") ;        // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
};  
----------------------------------------------------------  
class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey(){  
        return this.key ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
    public void setKey(K key){  
        this.key = key ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
};  
public class GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  
  
    }  
};

通配符

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo14{  
    public static void main(String args[]){  
        Info<String> i = new Info<String>() ;       // 使用String为泛型类型  
        i.setVar("it") ;                            // 设置内容  
        fun(i) ;  
    }  
    public static void fun(Info<?> temp){     // 可以接收任意的泛型对象  
        System.out.println("内容：" + temp) ;  
    }  
};

受限泛型

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo17{  
    public static void main(String args[]){  
        Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象  
        Info<Float> i2 = new Info<Float>() ;            // 声明Float的泛型对象  
        i1.setVar(30) ;                                 // 设置整数，自动装箱  
        i2.setVar(30.1f) ;                              // 设置小数，自动装箱  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? extends Number> temp){  // 只能接收Number及其Number的子类  
        System.out.print(temp + "、") ;  
    }  
};  
----------------------------------------------------------  
class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo21{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;      // 声明String的泛型对象  
        Info<Object> i2 = new Info<Object>() ;      // 声明Object的泛型对象  
        i1.setVar("hello") ;  
        i2.setVar(new Object()) ;  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型  
        System.out.print(temp + "、") ;  
    }  
};

泛型无法向上转型

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo23{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;      // 泛型类型为String  
        Info<Object> i2 = null ;  
        i2 = i1 ;                               //这句会出错 incompatible types  
    }  
};

泛型接口

interface Info<T>{        // 在接口上定义泛型  
    public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
    private T var ;             // 定义属性  
    public InfoImpl(T var){     // 通过构造方法设置属性内容  
        this.setVar(var) ;    
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
};  
public class GenericsDemo24{  
    public static void main(String arsg[]){  
        Info<String> i = null;        // 声明接口对象  
        i = new InfoImpl<String>("汤姆") ;  // 通过子类实例化对象  
        System.out.println("内容：" + i.getVar()) ;  
    }  
};  
----------------------------------------------------------  
interface Info<T>{        // 在接口上定义泛型  
    public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl implements Info<String>{   // 定义泛型接口的子类  
    private String var ;                // 定义属性  
    public InfoImpl(String var){        // 通过构造方法设置属性内容  
        this.setVar(var) ;    
    }  
    public void setVar(String var){  
        this.var = var ;  
    }  
    public String getVar(){  
        return this.var ;  
    }  
};  
public class GenericsDemo25{  
    public static void main(String arsg[]){  
        Info i = null;      // 声明接口对象  
        i = new InfoImpl("汤姆") ;    // 通过子类实例化对象  
        System.out.println("内容：" + i.getVar()) ;  
    }  
};

泛型方法

class Demo{  
    public <T> T fun(T t){            // 可以接收任意类型的数据  
        return t ;                  // 直接把参数返回  
    }  
};  
public class GenericsDemo26{  
    public static void main(String args[]){  
        Demo d = new Demo() ;   // 实例化Demo对象  
        String str = d.fun("汤姆") ; //   传递字符串  
        int i = d.fun(30) ;     // 传递数字，自动装箱  
        System.out.println(str) ;   // 输出内容  
        System.out.println(i) ;     // 输出内容  
    }  
};

通过泛型方法返回泛型类型实例

class Info<T extends Number>{ // 指定上限，只能是数字类型  
    private T var ;     // 此类型由外部决定  
    public T getVar(){  
        return this.var ;     
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){       // 覆写Object类中的toString()方法  
        return this.var.toString() ;      
    }  
};  
public class GenericsDemo27{  
    public static void main(String args[]){  
        Info<Integer> i = fun(30) ;  
        System.out.println(i.getVar()) ;  
    }  
    public static <T extends Number> Info<T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定  
        Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info  
        temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中  
        return temp ;   // 返回实例化对象  
    }  
};

使用泛型统一传入的参数类型

class Info<T>{    // 指定上限，只能是数字类型  
    private T var ;     // 此类型由外部决定  
    public T getVar(){  
        return this.var ;     
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){       // 覆写Object类中的toString()方法  
        return this.var.toString() ;      
    }  
};  
public class GenericsDemo28{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;  
        Info<String> i2 = new Info<String>() ;  
        i1.setVar("HELLO") ;        // 设置内容  
        i2.setVar("汤姆") ;       // 设置内容  
        add(i1,i2) ;  
    }  
    public static <T> void add(Info<T> i1,Info<T> i2){  
        System.out.println(i1.getVar() + " " + i2.getVar()) ;  
    }  
};

泛型数组

public class GenericsDemo30{  
    public static void main(String args[]){  
        Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组  
        fun2(i) ;  
    }  
    public static <T> T[] fun1(T...arg){  // 接收可变参数  
        return arg ;            // 返回泛型数组  
    }  
    public static <T> void fun2(T param[]){   // 输出  
        System.out.print("接收泛型数组：") ;  
        for(T t:param){  
            System.out.print(t + "、") ;  
        }  
    }  
};

泛型的嵌套设置

class Info<T,V>{      // 接收两个泛型类型  
    private T var ;  
    private V value ;  
    public Info(T var,V value){  
        this.setVar(var) ;  
        this.setValue(value) ;  
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
};  
class Demo<S>{  
    private S info ;  
    public Demo(S info){  
        this.setInfo(info) ;  
    }  
    public void setInfo(S info){  
        this.info = info ;  
    }  
    public S getInfo(){  
        return this.info ;  
    }  
};  
public class GenericsDemo31{  
    public static void main(String args[]){  
        Demo<Info<String,Integer>> d = null ;       // 将Info作为Demo的泛型类型  
        Info<String,Integer> i = null ;   // Info指定两个泛型类型  
        i = new Info<String,Integer>("汤姆",30) ;    // 实例化Info对象  
        d = new Demo<Info<String,Integer>>(i) ; // 在Demo类中设置Info类的对象  
        System.out.println("内容一：" + d.getInfo().getVar()) ;  
        System.out.println("内容二：" + d.getInfo().getValue()) ;  
    }  
};

参考：

http://blog.csdn.net/caihuangshi/article/details/51278793

http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html

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

http://blog.csdn.net/androidstudio/article/details/18567239