Java泛型的使用

• 泛型有三种使用方式：泛型类、泛型接口、泛型方法
• 泛型通配符，比如T、E、K、V等，为了增加可读性，通常情况下

“?”，表示不确定的java类型
“T(type)”，表示具体的一个java类型
“K V(key value)”，分别代表java键值中的key、value
“E(element)”，表示Element

一、泛型类

泛型类用于类的定义中，被称为泛型类。最典型的就是各种容器类，如List、Set和Map。
泛型类的最基本用法：

class 类名称<泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
	private 泛型标识 var;  //定义一个变量
	··· ···
}

例子：

public class Test<T> {
	private T key;
	public Test(T key) { 
		this.key = key;
	}
	public T getKey() {
		return key;
	}
	public static void main(String args[]) {
		Test<Integer> testInteger = new Test<Integer>(12345);
		Test<String> testString = new Test<String>("test");
		Test testBoolean = new Test(true); //不一定要传入泛型实参
		System.out.println("testInteger:::" + testInteger.getKey());
		System.out.println("testString:::" + testString.getKey());
		System.out.println("testBoolean:::" + testBoolean.getKey());
	}
}

注意：不能对确切的泛型类型使用instanceOf操作，下面的操作是非法的

if(testInteger instanceOf Test<Integer>) {}

二、泛型接口

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

//定义一个泛型接口
public interface Test<T> {
	public T next();
	//实现泛型接口的类，未传入泛型实参
	//在声明类的时候，需将泛型的声明也一起加到类中
	class One<T> implements Test<T>{
		@Override
		public T next() {
			return null;
		}
	}	
	//实现泛型接口的类，传入泛型实参
	//所有使用泛型的地方都要替换成传入的参数类型
	class Two implements Test<String>{	
		private String[] fruits = new String[] {"apple", "Banana", "Pear"};	
		@Override
		public String next() {
			Random random = new Random();
			return fruits[random.nextInt(2)];
		}
	}
}

三、泛型方法

3.1 泛型方法的使用

java中，泛型方法的定义较为复杂
泛型类，在实例化类的时候指明泛型的具体类型；
泛型方法，在调用方法的时候指明泛型的具体类型
泛型方法的定义例子：

public <T> T genericMethod(Class<T> tClass){
	T instance = tClass.newInstance();
	return instance;
}

注意：

• public 与 返回值T 中间的 < T>非常重要，有了这个，表示声明此方法为泛型方法
• 只有声明了< T>的方法才是泛型方法，泛型类中使用了泛型的成员变量并不表示其实一个泛型方法
• < T>表明该方法将使用泛型类型 T
• 泛型方法能使方法独立于类而产生变化，如果static方法要使用泛型能力，就必须使其成为泛型方法

下面的两个例子，注意看注释哦！
例1：

//泛型类
public class Generic<T>{     
	 private T key;

	 public Generic(T key) {
	      this.key = key;
	 }
     //不是一个泛型方法，只是类中一个普通的成员方法
	 public T getKey(){
	     return key;
	 }

/**
 * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
 * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
	 public E setKey(E key){
	     this.key = keu
	 }
*/
 }

例2：

public class GenericTest {

		 /** 
	     * 这才是一个真正的泛型方法。
	     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
	     * 这个T可以出现在这个泛型方法的任意位置.
	     * 泛型的数量也可以为任意多个 
	     *    如：public <T,K> K showKeyName(Generic<T> container){
	     *        ...
	     *        }
	     */
	    public <T,K> T showKeyName(Generic<T> container){
	        System.out.println("container key :" + container.getKey());
	        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
	        T test = container.getKey();
	        return test;
	    }

	    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
	    public void showKeyValue1(Generic<Number> obj){
	        Log.d("泛型测试","key value is " + obj.getKey());
	    }

	    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
	    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
	    public void showKeyValue2(Generic<?> obj){
	        Log.d("泛型测试","key value is " + obj.getKey());
	    }

	     /**
	     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
	     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
	     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
	    public <T> T showKeyName(Generic<E> container){
	        ...
	    }  
	    */

	    /**
	     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
	     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
	     * 所以这也不是一个正确的泛型方法声明。
	    public void showkey(T genericObj){

	    }*/
}

  泛型方法可以出现在任何地方和任何场景中使用，但是 “泛型方法出现在泛型类中” 这种情况是非常特殊的

public class GenericFruit {
	static class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    static class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    static class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    static class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {   
        Person person = new Person();  //如果Person不声明为静态类时，会报错
        Apple apple = new Apple();

        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);
    }
}

3.2 泛型方法与可变参数

public class Test{
	public static <T> void printMsg(T... args){
		for(T t:args){
			System.out.println(t);
		}
	}
	
	public static void main(String args[]) {
		printMsg("111", 222, 2.333);
	}
}

3.3 静态方法与泛型

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

静态方法无法访问类上定义的泛型；
如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

//静态类
public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

//非静态类
public class Test{
	    /**
	     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
	     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
	     * 如：public static void show(T t){..},此时编译器会提示错误信息：
	          "StaticGenerator cannot be refrenced from static context"
	     */
	    public static <T> void show(T t){
	    	System.out.println(t);
	    }
	}

3.4 泛型上下界（宽泛地指定泛型类型）

3.4.1 为泛型添加上边界（传入的类型实参必须是指定类型的子类型）

class TestEphemeral<T extends Number>{
	private T key;
	public TestEphemeral(T key) {
		this.key = key;
	}
	public T getKey() {
		return key;
	}
}
public class Test<T>{
	
	public static void showKeyValue(TestEphemeral<? extends Number> obj) {
		System.out.println("泛型测试::key is:::" + obj.getKey());
	}
	
	public static <T extends Number> T showKeyName(TestEphemeral<T> container) {
		System.out.println("contains key :::" + container.getKey());
		T test = container.getKey();
		return test;
	}
	
	public static void main(String args[]) {
		TestEphemeral<Integer> ephemeral = new TestEphemeral<Integer>(666);
		TestEphemeral<Float> ephemeral2 = new TestEphemeral<Float>(2.33f);
		TestEphemeral<Double> ephemeral3 = new TestEphemeral<Double>(3.1415);
//		报错
//		TestEphemeral<String> ephemeral4 = new TestEphemeral<String>("test");
		showKeyName(ephemeral);
		showKeyName(ephemeral2);
		showKeyName(ephemeral3);
	}
}

四、泛型数组

在java中是不能创建一个确切的泛型类型的数组的

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

但是，使用通配符创建泛型数组时可以的：

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

五、使用Object表示泛型

class MemoryCell{
	private Object storedValue;
	public Object read() {
		return storedValue;
	}
	public void write(Object x) {
		storedValue = x;
	}
}
public class Test<T>{
	public static void main(String args[]) {
		MemoryCell m = new MemoryCell();
		m.write("22222");
		String val = (String)m.read(); // 注意这里的强转
	}
}

注意：

• 为了方法对象的特定的方法，必须要强制转换成正确的类型
• 不能使用基本类型，只能使用引用类型。

六、使用接口类表示泛型

首先说一下Java中的 IS-A关系和 Has-A 关系
IS-A 关系是继承关系，例如：苹果是一种水果

class Apple extends Fruit{}

Has-A关系是组成关系，例如：一个房间有一张桌子

class Room{
    ··· ···
	Table table = new Table();
	··· ···
}

Has-A 关系是动态（运行时）绑定，而继承关系是静态（编译时）绑定。

class FindMaxDemo{
	public static Comparable findMax(Comparable[] arr){
    	int maxIndex = 0;
        for(int i = 1; i < arr.length; i++ ){
        	if(arr[i].compareTo(arr[maxIndex])>0){
            	maxIndex = i;
            }
        }
        return arr[ maxIndex ];
    }
    
    public static void main(String [] args){
    	Shape[] sh1 = {new Circle(2.0)),
        			   new Square(2.0)),
        			   new Rectangle(2.0)};

        System.out.println(findMax(sh1)); //假设shape implements Comparable
    }
}
// 泛型findMax 案例，使用Shape和String 演示pre-Java 5

七、数组类型的兼容性（这里还不是很懂）

Employee IS-A Person，那么这是不是就代表数组 Employee[] IS-A Person[]？即一个方法接收 Person[] 作为参数，但是能不能把 Employee[] 作为参数传递进去？

假设除了Employee外，还有 Student IS-A Person，并且假设 Employee[] 和 Person[] 类型是兼容的。

//Student IS-A Person， Employee IS-A Person
Person[] arr = new Employee[5];
arr[0] = new Student(); //出现ClassCastException异常

参考文章：
Java泛型详解：https://blog.csdn.net/s10461/article/details/53941091
Java泛型指南：https://blog.csdn.net/qq_36622496/article/details/108998744
什么是泛型：https://www.liaoxuefeng.com/wiki/1252599548343744/1265102638843296