java——泛型总结

对泛型一直半知半解，做下总结，顺便学习一下，本博文仅供参考。先来点概念压压惊。

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），

然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，

操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

一个被人举烂的例子。

这里有点不懂 网上那些大佬为啥非要强转为String型，或许是为了说明泛型的重要性吧。好了，开个玩笑。

这里那些大佬说的是在声明list的时候加上String ，然后在编译的时候不符合String的类型编译器就会给我们报错。

泛型应运而生。

总结一哈，使用泛型就是逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。

泛型的用处

三种方式：类、接口以及方法。

先举个类和方法的例子

泛型类

import java.util.LinkedList;
/**
 * 模拟队列,即先进先出
 * @author hydra
 *
 * @param <T>
 */
public class GenericsDemo<T> { //泛型类
	private LinkedList<T> list;
	
	public GenericsDemo() {//在构造方法中，实例化list对象
		list = new LinkedList<>();
	}
	
	/**
	 * 往队列里添加元素
	 * @param obj
	 */
	public void put(T obj) {//虽然使用了泛型，但不是泛型方法
		//从LinkedList的头部添加元素
		list.addFirst(obj);
	}
	
	/**
	 * 从队列里获取元素
	 * @return
	 */
	public T get1() {  //虽然使用了T并且返回值也为T，但并不是泛型方法
		T obj = list.removeLast();
		return obj;
	}
	public <T> T get2() { 
		//从LinkedList的尾部获取元素
//		T obj = list.getLast();//队列中获取元素后，应该将该元素删除
		T obj = (T) list.removeLast();
		return obj;
	}
	
	public <E> T get3() {
		T obj = list.removeLast();
		return obj;
	}
	
	public boolean isEmpty() {
		return list.isEmpty();
	}
}

仔细观察上面的代码，其实get2()和get3()中的<T>和<E>是一样的，都是全新的。

测试类

public class TestGenerics {
	public static void main(String[] args) {
		
		GenericsDemo<Student> list1 = new GenericsDemo<>();//实例化泛型对象,类型为Student
		Student stu1 = new Student(1, "ljz");
		Student stu2 = new Student(2, "zty");
		list1.put(stu1);
		list1.put(stu2);
		
//		System.out.println(list1.get().getName());
		while(!list1.isEmpty()) {
			Student stu = list1.get1(); //向下转型
			System.out.println(stu.getName());
		}
		GenericsDemo<String> list2 = new GenericsDemo<String>();
		list2.put("aa");
		System.out.println((String)list2.get1());
	}
}

泛型类和方法的代码实现其实挺简单的。

泛型接口

public interface Generator<T> { //泛型接口
	public T print();
}

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

public class PrinterGenerator<T> implements Generator<T> {//此处未传入泛型实参，因此PrinterGenerator<T>不能改变

	@Override
	public T print() { //和类继承其他接口一样，需要重写方法
		return null;
	}	
}

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

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

}

泛型通配符

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

类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参 。重要说三遍！此处’？’是类型实参，而不是类型形参 ！ 此处’？’是类型实参，而不是类型形参 ！再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

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

泛型方法与可变参数

再看一个泛型方法和可变参数的例子（这里的 T 可以同时传入不同类型）：

public <T> void printMsg( T... args){

    for(T t : args){

    Log.d("泛型测试","t is " + t);

    }

}

printMsg("111",222,"aaaa","2323.4",55.55);

泛型上下边界

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

• 为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

• 
      public void showKeyValue1(Generic<? extends Number> obj){
  
      Log.d("泛型测试","key value is " + 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> 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;

}

通过上面的两个例子可以看出：泛型的上下边界添加，必须与泛型的声明在一起 。

 参考：https://www.cnblogs.com/coprince/p/8603492.html