java中的泛型

什么是泛型？
泛型是就是在不明确数据类型的情况下使用的一种定义的一种类型参数。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类，接口和方法中，分别被称为泛型类，泛型接口，泛型方法。
泛型类型在逻辑上看可以看成多个不同类型，但是不同的类型只仅仅体现在编译阶段，泛型的信息不会进入到运行时阶段。
泛型的使用
泛型类
泛型类用于类的定义中，被称为泛型类。通过反省可以完成对一组类的操作对外开放相同的接口，最典型的就是各种容器类，如：List、set、Map。

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

//泛型的类型参数只能是类类型（包括自定义类），不能时简单类型
//传入的实参类型需与泛型的类型参数类型相同
Generic<Integer>genericInteger=new Generic<Integer>(123456);  //输出结果为123456

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String>genericString=new Generic<String>("key");    //输出结果为“key”

定义的泛型类时候并不一定传入泛型实参。如果传入了泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型实参，在泛型类中使用泛型的方法或成员变量的定义可以为任何的类型。

Generic generic1=new Generic("111111");		//输出：“111111”
Generic generic2=new Generic(4444);			//输出：4444
Generic generic3=new Generic(55.55);		//输出  55.55
Generic generic4=new Geneic(false);			//输出  false

注意：

• 泛型的类型参数只能是类类型，不能是简单类型。
• 不饿能对确切的泛型类使用instaceof操作。如下面的操作是非法的，编译时会出错。

if(ex_num instanceof Generic<Number>){}

泛型接口
泛型接口与泛型类的定义和使用基本相同。泛型接口常被用在各种类的生产器中。

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

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

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

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

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，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)];
    }
}

泛型方法
我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中包含着泛型方法。泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

public <T> T genericMethod(Class<T> tClass) throws InstantiationException,IllegalAccessException{
	T instance =tClass.newInstace();
	return instance;		
}

Object obj=genericMethod(Class.forname("com.test.test));

泛型方法的基本用法

public class Generic<T>{
	private T key;

	public Generic(T key){
		this.key=key;
	}
	//下面这个方法虽然使用了泛型，但这并不是一个泛型方法。
	//这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型
	//所以这个方法中才可以继续使用T这个泛型。
	public T getKey(){
		return key;
}
}
	//这才是一个真正的泛型方法。首先在public返回值之间的<T>必不可少，这表明是要给泛型方法，并且声明了一个泛型T，这个T可以出现在这个泛型方法的任意位置。
	public <T> T showKeyName(Generic<T> container){
	System.out.println("container key"+container.getKey());
	T test=container.getKey();
	return test;
}

	//这不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型做形参而已。
	public void showKeyValue(Generic<Number> obj){
	System.out.println("key value is"+obj.getKey());
}
	//这也不是一个泛型方法，使用了泛型通配符？
	//同时这也印证了泛型通配符章节所描述的，？是一种类型实参，可以看作为Number等所有类的夫类。
	public void showKeyValue2(Generic<?> obj){
	System.out.println(obj.getValue());
}

类中的泛型方法
泛型方法可以出现在任何地方使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时：

public class GenericFruit{
	public void show_1(T t){
	System.out.println(t.toString());
}
	//在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类相关，可以类型与T相同，也可以不同。
	//由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
	//下面这里例子中<E>表明为一个泛型方法，在泛型方法任意的地方可以使用该泛型。返回值为void
	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 main(String[] args){
	Apple apple=new Apple();   //继承了fruit类
	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);
}
}

泛型方法与可变参数

public<T>void printMsg(T...args){   //传入的参数可以是任何类型
	for(T t:args){			//使用循环遍历参数集合args
	System.out.println(t);
}
}

静态方法与泛型
如果静态方法要使用泛型的话，必须将静态方法页定义成泛型方法。

public class StaticGenerator<T>{
	//如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明(将这个方法定义成泛型方法)
	//如：public static void show(T t){...}，此时编译器会提示错误信息：
	public static<T>void show(T t){}
}

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

public void  showKeyValue1(Generate<? extends Number>obj){
	System.out.pintLn(obj.getKey());
}
Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//showKeyValue1(generic1);

showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

如果我们把泛型类型的定义改一下：

public class Generic<T extends Number>{
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}
//这一行代码也会报错，因为String不是Number的子类
Generic<String> generic1 = new Generic<String>("11111");

泛型方法的边界

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
public<T extends Number>T showkeyName(Generic<T> container){
	System.out.printLn("Container key:"+container.getKey());
	T test=container.getKey();
	return test;
}

通过上面两个例子可以看出：泛型的上下边界添加，必须与泛型的声明在一起。
关于泛型数组
在java中是不能创建一个确切的泛型类型的数组。

List<String>[] Ls=new ArrayList<String>[10]//这是不允许的

使用通配符常见泛型数组是可以的。

List<?>[] ls=new ArrayList<?>[10];

下面这样也是可以的：

List<String>[]ls=new ArrayList[10];