泛型

在类中使用泛型
public class Pair<T>{

	private T first;
	
	public Pair(T first){
		this.first = first;
	}

	public T getFirst(){
		return first;	
	}
	
	public void setFirst(T  newvalue){
		first = newvalue;
	}	
}

public class Pair<T,U>{  //泛型类可以有多个类型变量，使用逗号分隔
	T first;
	U second;

}


在方法中使用泛型

clas A{

	public static <T> T getMiddle(T a){
			return a;
	}
	
	public static <T extends Comparable> T min(T[] a){  // T是 Comparable的子类
		return a[0];
	}
	
	
	//一个类型变量或通配符可以有多个限定，使用&分隔，在Java继承中，可以根据需要拥有多个接口超类型，但最多有一个限定可以是类，如果有一个类作为限定，它必须是限定列表中的第一个限定。
	pubic static <T extends Comparable & Serilizable> T min(T[] a){
		return a[0];
	}

}

虚拟机没有泛型类型对象，所有对象都属于普通类，无论何时定义一个泛型类型，都会自动提供一个相应的原始类型，这个原始类型的名字就是去吊类型参数后的泛型类型名。
对于无限定的变量则替换为Object

例如：上面例子的Pair<T> 会被替换为
public class Pair{
	private Object first;
	private Object second;
}

例如:
public class Interval<T extends Comparable & Serializable> {
	private T lower;
}

会被替换为
public class Interval{
	private Commparable lower;
}


你可能想知道限定切换为class Interval<T extends Serializable & Comparable>会发生什么，如果这样做，原始类型会用Serializable替换T，而编译器在必要时要向Comparable插入强制类型转换。为了提高效率
应该
将标签接口(既没有方法的接口)放在限定列表的末尾。

java不支持泛型类型的数组。但是可以使用集合，例如：ArrayList<Pair<String>>


实例化变量的一个例子

Pair<String> p = Pair.makePair(String.class);

public static <T> Pair<T> makePair(Class<T> cl){

	try{
		return new Pair<>(cl.getConstructor.newInstance())
	}catch(Exception e){
		return null;
	}
}
============================================================================================================================================================================

public class Pair<T>{

}

public class Employee{

}

public class Manager extends Employee{

}

Pair<Manager> 不是Pair<Employee>的子类， 他们没有任何关系

通配符 ？

类型Pair<Manager> 是Pair<? extends Employee>的子类型


List<? extends A> list ;  //定义上限A 参数类型全部是A或A的子类
集合元素只能get，不能set


List<? super B> list;  //定义下限B  参数类型全部是B或B的父类
只能元素只能set B或B的子类，不能get


通配符，抛离集合的另外使用

interface Processor<T> {
    void process(T item);
}

// 定义：Processor<? extends Number>
Processor<? extends Number> producer = ...;
producer.process(123); // ❌ 不允许写：不能确定是 Integer/Float/Double

// 定义：Processor<? super Integer>
Processor<? super Integer> consumer = ...;
consumer.process(123); // ✅ 可以写入 Integer