java泛型程序设计

 class Pair<T>{

	private T first;
	private T second;
	
	public Pair(){
		this.first=null;
		this.second=null;
	}
	public Pair(T first,T second){
		this.first=first;
		this.second=second;		
	}
	public T getFirst() {
		return first;
	}
	public void setFirst(T first) {
		this.first = first;
	}
	public T getSecond() {
		return second;
	}
	public void setSecond(T second) {
		this.second = second;
	}

	
}

尖括号(<>)内是类型参数。可以用具体的类型实例化泛化类型eg Pair <String>     Pair<String ,String>

方法也可以使用泛型。请看！！

 class ArrayAlg{
		@SafeVarargs
		public static <T> T getMiddle(T... a){
			return a[a.length/2];	
		}
  }

 ...表示可变参数，传入的阐述都会被放入到一个数组当中(数组名就是...后面的),之后可以用for(T i: a){…………}

上例可以这样实例化：String middle=ArrayAlg.<String>getMiddle("John","Q.","Public");

有时候我们需要对类型变量加以约束。例如在下例子当中变量smallest的类型是T，这意味这它可以是任意一个变量的类。

怎样才能确定T所属的类有compareTo方法呢！！！！！------对类型变量设置限制。<T extends Comparable >

		public static <T extends Comparable> T min(T[] a){
			if(a==null||a.length==0) return null;
			T smallest =a[0];
			for (int i=1;i<a.length;i++){
				if(smallest.compareTo(a[i])>0) smallest=a[i];//如何确保T类型有方法！！！！！
			}
			return smallest;
		}

   限定中使用extends,因为extends 与子类的概念更接近！！！

    多个限制 <T extends Comparable & Serializable>

 

虚拟机中没有泛型类型对象----所有的对象都数据普通类，---无论何时定义了一个泛型类型，都会自动提供一个原始类型(raw type),原始类型的名字就是删去类型参数后的泛型类型名，擦除(erased)类型变量，并替换为限定类型！！！(无限定的变量用Object)

通配符类型，允许类型参数变化，例如：Pair<? extends Employee>表示任何泛型Pair,他的类型参数必须是Employee的子类，如Pair<Manager>,但不是Pair<String>!!  --这儿假设Employee拓展出Manager

通配符的超类型限定(supertype bound) eg ?super Manager 这个通配符限定为Manager的所有超类型！！

Comparable接口本身就是一个泛型类型 申明如下：

public interface Comparable<T>{

public int compareTo(T other)

}

egString类实现了Comparable<String> 则它的compareTo方法申明如下：public int compareTo(String other)

如果我们没有指明Comparable接口当中的<T>类型，那么实现的是需要强制类型转换---Object

<T extends Comparabel<? super T>>//对超类进行限定！！！！

完整测试代码如下：

​
package general;
import java.time.LocalDate;
import java.time.chrono.*;

public class Test {

	public static void main(String[] args) {
		LocalDate[] birdthdays={
				LocalDate.of(2005, 12, 9),
				LocalDate.of(2015, 1, 9),
				LocalDate.of(2009, 12, 6),
				
		};
		Pair<LocalDate> mm=ArrayAlg.minmax(birdthdays);
		System.out.println("min="+mm.getFirst());
		System.out.println("max="+mm.getSecond());
	}

}

 class Pair<T>{
	 
	private T first;
	private T second;
	
	public Pair(){
		this.first=null;
		this.second=null;
	}
	public Pair(T first,T second){
		this.first=first;
		this.second=second;		
	}
	public T getFirst() {
		return first;
	}
	public void setFirst(T first) {
		this.first = first;
	}
	public T getSecond() {
		return second;
	}
	public void setSecond(T second) {
		this.second = second;
	}

}
 class ArrayAlg{
		@SafeVarargs
		public static <T> T getMiddle(T... a){
			return a[a.length/2];	
		}
		public static <T extends Comparable> T min(T[] a){
			if(a==null||a.length==0) return null;
			T smallest =a[0];
			for (int i=1;i<a.length;i++){
				if(smallest.compareTo(a[i])>0) smallest=a[i];
			}
			return smallest;
		}
		public static <T extends Comparable> Pair<T> minmax(T[] a){
			if (a==null||a.length==0)return null;
			T min=a[0];
			T max=a[0];
			for (int i=1;i<a.length;i++){
				if(min.compareTo(a[i])>0)min= a[i];
				if(max.compareTo(a[i])<0) max=a[i];
			}
			return new Pair<>(max,min); //返回新建的类的引用！
		}
		
 }

​