java学习-泛型

1、泛型概述

泛型即是参数化类型，定义方法时候传入形式参数，调用方法时候传入实际参数，泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。

2、一个例子

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){    
	String item = (String)arrayList.get(i);
	Log.d("泛型测试","item = " + item);
}

毫无疑问，程序的运行结果会以崩溃结束：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

在前面我们说到。list可以存放不同类型的数据，例子中加入了String和Integer类型数据，会报错，为了解决这种问题，我们在编译时候可以解决，例如泛型

**泛型只在编译阶段有效。**看下面的代码：

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
     
    Log.d("泛型测试","类型相同");
}

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

3、泛型三种使用方式

3.1泛型类

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

基本写法

class people

常见泛型标识 T、E、K、V等形式参数用于表示泛型

3.2泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：

//定义一个泛型接口
public interface Generator<T> {
     
	public T next();
	}

当实现泛型接口的类，未传入泛型实参时：

/** 
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中 
*即：class FruitGenerator implements Generator{ 
* 如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错："Unknown class" 
*/
class FruitGenerator<T> implements Generator<T>{
         
    @Override    
    public T next() {
     
        return null;    
    }
}

当实现泛型接口的类，传入泛型实参时：

/** 
* 传入泛型实参时： 
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator 
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。 
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型 
* 即：Generator，public T next();中的的T都要替换成传入的String类型。 
*/
public class FruitGenerator implements Generator<String> {
     
    private String[] fruits = new String[]{
     "Apple", "Banana", "Pear"};
    @Override    
    public String next() {
             
        Random rand = new Random();        
        return fruits[rand.nextInt(3)];    
    }
}

3.3泛型方法

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。

尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。 泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

光看上面的例子有的同学可能依然会非常迷糊，我们再通过一个例子，把我泛型方法再总结一下。

/**  * 这才是一个真正的泛型方法。 
* 首先在public与返回值之间的必不可少，这表明这是一个泛型方法，并且声明了一个泛型T 
* 这个T可以出现在这个泛型方法的任意位置. 
* 泛型的数量也可以为任意多个  
*    如：public  K showKeyName(Generic container){ 
*        ... 
*        } 
*/
public class 泛型方法 {
         
    @Test    
    public void test() {
             
        test1();        
        test2(new Integer(2));        
        test3(new int[3],new Object());
        //打印结果
        //        null
        //        2
        //        [I@3d8c7aca
        //        java.lang.Object@5ebec15    }    
        //该方法使用泛型T   
        public <T> void test1() {
             
            T t = null;        
            System.out.println(t);    
        }    
        //该方法使用泛型T    
        //并且参数和返回值都是T类型    
        public <T> T test2(T t) {
             
            System.out.println(t);        
            return t;    
        }
    //该方法使用泛型T,E    
        //参数包括T,E    
        public <T, E> void test3(T t, E e) {
             
            System.out.println(t);        
            System.out.println(e);    
        }
    }

3.4泛型通配符

public void showKeyValue1(Generic<?> obj){
        
    Log.d("泛型测试","key value is " + obj.getKey());
}

类型通配符一般是使用？代替具体的类型实参，注意， 此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型

public void showKeyValue(Genericobj){ System.out.println(obj); }

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
public void test () {
     
    //        showKeyValue(gInteger);该方法会报错    
     showKeyValue1(gInteger);
}
public void showKeyValue1(Generic<?> obj) {
         
    System.out.println(obj);
}
// showKeyValue这个方法编译器会为我们报错：Generic
// cannot be applied to Generic
// showKeyValue(gInteger);