JAVA SE (13)

–> JAVA SE (12)
泛型提供了编译时类型安全检测机制，可以在编译时检测到非法的类型。
泛型的本质是参数化类型–所操作的数据类型被指定为一个参数。泛型方法可以一法多用。
一个泛型参数也称为类型变量。
类型参数只能代表引用类型而不能代表原始类型（int、double等）

泛型方法

使用泛型方法打印不同字串的元素：

package binaryheap.test;

public class BH{
		
	public static void main(String[] args) {
		Integer[] intgr = {1,2,3,4,5,6};
		Double[] dbl = {1.0,2.0,3.0,(double) 4,(double) 5,(double) 6};
		Character[] chrtr = {'1','2','3','4','5','6'};
		
		System.out.println("Integer-------------------------");
		print(intgr);
		
		System.out.println("\nDouble------------------------");
		print(dbl);
		
		System.out.println("\nCharacter---------------------");
		print(chrtr);
	}
	
	
	public static <T> void print(T[] inputArray) {
		for (T t : inputArray) {
			System.out.printf("%s ",t);
		}
	}
	
}

结果

Integer-------------------------
1 2 3 4 5 6 
Double------------------------
1.0 2.0 3.0 4.0 5.0 6.0 
Character---------------------
1 2 3 4 5 6 

泛型类

泛型类的声明和非泛型类的声明类似，多了在类名后面添加类型参数声明部分。
和泛型方法一样，类型参数声明部分包含一个或者多个类型参数，用逗号隔开。
定义泛型类：

package binaryheap.test;

class MyClass<T>{
		
	private T t;
	public void add(T t) {
		this.t = t;
	}
	public T get() {
		return t;
	}
	
}
public class BH{
	
	public static void main(String[] args) {
		MyClass<Integer> myInt = new MyClass<>();
		MyClass<String> myStr = new MyClass<>();
		myInt.add(new Integer(1));
		myStr.add(new String("TxL"));
		
		System.out.printf("整型值：%d" , myInt.get());
		System.out.printf("\n字符串：%s" , myStr.get());
	}
	
	
}

结果

整型值：1
字符串：TxL

类型通配符

使用“？”代替具体的类型。如List<?> 是所有List<具体类型参数类型>的父类。
例1：普通

package binaryheap.test;

import java.util.ArrayList;
import java.util.List;

public class BH{
	
	public static void main(String[] args) {
		
		List<Integer> intList = new ArrayList<Integer>();
		List<String> strList = new ArrayList<String>();
		List<Character> charList = new ArrayList<Character>();
		
		intList.add(190);
		intList.add(110);
		intList.add(120);
		intList.add(130);
		strList.add("ssss");
		strList.add("rrrr");
		charList.add('h');
		charList.add('t');
		
		getData(intList);
		getData(strList);
		getData(charList);
		
	}
	
	public static void getData(List<?> data) {
		
		System.out.println("第2个数据：" + data.get(1));
		
	}
}

结果

第2个数据：110
第2个数据：rrrr
第2个数据：t

例2：通配符+有界类型参数

package binaryheap.test;

import java.util.ArrayList;
import java.util.List;

public class BH{
	
	public static void main(String[] args) {
		
		List<Integer> intList = new ArrayList<Integer>();
		//List<String> strList = new ArrayList<String>();
		List<Number> numList = new ArrayList<Number>();
		
		intList.add(190);
		intList.add(110);
		intList.add(120);
		intList.add(130);
//		strList.add("ssss");
//		strList.add("rrrr");
		numList.add(123);
		numList.add(2334);
		
		getData(intList);
		getData(numList);
		
	}
	
	public static void getData(List<? extends Number> data) {
		
		System.out.println("第2个数据：" + data.get(1));
		
	}	
}

结果

第2个数据：110
第2个数据：2334

类型通配符下限通过如List<? super Number>，表示只能接受Number及其父类类型，如Object类。

对于泛型，只是允许程序员在编译时检测到非法的类型而已，在运行时期，泛型标志会变化为Object。

List<Integer> list = new ArrayList<>();

list.add(12);
//这里直接添加会报错
list.add("a");
Class<? extends List> clazz = list.getClass();
Method add = clazz.getDeclaredMethod("add", Object.class);
//但是通过反射添加，是可以的
add.invoke(list, "kl");

System.out.println(list)

–> JAVA SE (14)