Java泛型程序设计之定义简单泛型类、泛型方法、以及类型变量的限定

在学习使用泛型定义一个简单的类之前，首先需要唠嗑几句关于泛型的几个概述：

1：从Java程序设计语言1.0版发布以来，变化最大的部分就是泛型。

2：使用泛型机制编写的程序代码要比那些杂乱的使用Object变量，然后在进行强制类型转换的的代码具有更好的安全性和可读性。

3：泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。

4：在Java中增加泛型类之前，泛型程序设计是用继承实现的，使用这种方法有两个问题：当获取一个值时必须进行强制类型转换；此外这里也没有错误检查，也就是说可以向数组列表中添加任何类的对象。

5：泛型通过提供一个类型参数，用来指示元素类型，从而解决了使用继承实现泛型的弊端，使得程序具有更好的可读性和安全性。

好了，以上就是关于泛型的最基本的概述，下面正式叙述一下如何定义和使用一个简单的泛型类。

一个泛型类就是具有一个或多个类型变量的类

下面是一个例子：

package GenericProgramma;

public class PairTest1 {
	public static void main(String[] args) {
		String[] words= {"Mary","had","a","little","lamb"};
		Pair<String> mm=ArrayAlg.minmax(words);
		System.out.println("min="+mm.getFirst());
		System.out.println("max="+mm.getSecond());
	}
}

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

class ArrayAlg{
	public static Pair<String> minmax(String[] a){
		if(a==null || a.length==0) {
			return null;
		}
		String min=a[0];
		String max=a[0];
		for(int i=0;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<>(min,max);
	}
}

上面这个程序从一个字符数组中找出最小和最大的字符串，并且以Pair类型返回，其中Pair就是一个简单的泛型类。

下面，我么来分析一下泛型类应该如何写：

Pair类引入了一个类型变量T，用尖括号(<>)括起来，并放在类名后面，泛型类可以有多个泛型变量。例如，可以将Pair类定义成以下形式：class Pair<T,U>{…}

类定义中的类型变量指定方法的返回类型以及域和局部变量的类型。如private  T first;

用具体的类型替换类型变量就可以实例化泛型类型，例如：Pair<String>

有一点需要注意：类型变量使用大写形式，且比较短，这是很常见的。在库中，使用变量E表示集合的元素类型。K和V分别表示表的关键字与值的类型，T（需要时还可以用临近的字母U和S）表示任意类型。

以上是关于泛型类的定义和使用，下面就介绍关于泛型方法的定义和使用：

也是首先观察一个示例：

package Generic;

import java.util.Arrays;

public class PairTest2 {
	public static void main(String[] args) {
		Integer[] testInt=new Integer[] {1,2,3,4,5,6,7};
		System.out.println(Arrays.toString(testInt));
		testInt=ArrayAlg.swap(testInt, 2, 34);
		//这是完整写法
		//testInt=ArrayAlg.<Integer>swap(testInt, 2, 3);
		//一般情况下省略类型参数不会出现问题,但是如果传入
		//参数，，编译器不足以推断出类型时就会出现错误
		System.out.println(Arrays.toString(testInt));
	}
}

class ArrayAlg{
	//用于交换传入数组的两个下标的值
	public static <T> T[] swap(T[] t,int index1,int index2) throws IndexOutOfBoundsException{
		try {
			T temp=t[index1];
			t[index1]=t[index2];
			t[index2]=temp;
		}catch(IndexOutOfBoundsException e) {
			throw e;
		}
		return t;
	}
}

首先我们发现，这个泛型方法并不是在泛型类中定义的，也就是说，泛型方法不一定非得定义在泛型类中。

下面介绍一下详细规则：

类型变量（尖括号中的变量）放在修饰符的后面，返回类型的前面。

当调用一个泛型方法时，在方法名前的尖括号中放入具体的类型。（有时候也可以省略）

最后，是关于类型变量的限定：

同样地，先上例子：

package Generic;

public class PairTest3 {
	public static void main(String[] args) {
		Integer[] testInt=new Integer[] {1,2,6,5,7,3,2,1};
		System.out.println(ArrayAlg.findMax(testInt));
	}
}

class ArrayAlg{
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static <T extends Comparable> T findMax(T[] a) throws IndexOutOfBoundsException{
		T temp=a[0];
		for(T t:a) {
			if(t.compareTo(temp)>0)temp=t;
		}
		return temp;
	}
}

观察上面程序，我们使用了extends关键字，意思就是，只有实现了Comparable接口的类才可以使用这个泛型方法。