浅谈Java中的泛型类与泛型方法

本人是初学Java的小菜鸟，最近刚好学习了一下泛型类跟泛型方法，做了点笔记，如有错误，欢迎指正交流

先看一段用于求解整形数组中的最大值与最小值：

public class pair {       //pair用来存数组中的最大值与最小值
	private int min;
	private int max;

	public pair(int min, int max) {
		this.max = max;
		this.min = min;
	}

	public int getmax() {
		return this.max;
	}

	public int getmin() {
		return this.min;
	}
}

public class sort {  //用来排序
	
	public pair minmax(int num[]) {
		int min = num[0];
		int max = num[0];
		for (int i = 1; i < num.length; i++) {
			if (num[i] >max )
				max = num[i];
			if (num[i]<min )
				min = num[i];
		}
		return new pair<T>(min, max);
	}


public static void main(String[] args) {
		
		intnums[] = new int[] { 1, 2, 3, 5, 9, 11 };
		sort result = new sort();
		System.out.println("max=" + result.minmax(nums).getmax() + "  min=" + result.minmax(nums).getmin());
		
	}

}

输出结果为：

那么问题来了，如果我还想用sort类里的方法得到字符串数组 String []strs=new String(){"a","b","c"}; 的最大最小值，是不是还重写一个pair类呢？

有没有方法让不同类型的数组都共用pair类跟sort类来解决问题，所以能不能将数组的数据类型作为参数传递呢？

Java泛型类与泛型方法就可以实现将数据类型作为参数传递

/**
 * 
 * @author Gemin_Chang
 *
 * @param <T> pair<T> <T>用来确定数据类型，即数据类型参数
 */
public class pair<T> {
	private T min;
	private T max;

	public pair(T min, T max) {
		this.max = max;
		this.min = min;
	}

	public T getmax() {
		return this.max;
	}

	public T getmin() {
		return this.min;
	}
}

public class sort {
	/**
	 * 这是一个泛型方法
	 * 
	 * @param <T  extends Comparable> 使用Comparable接口，这里不是继承,在泛型中extends既可能表示继承也可能表示接口
	 * @param num
	 * @return
	 */
	public static <T extends Comparable> pair<T> minmax(T num[]) {
		T min = num[0];
		T max = num[0];
		for (int i = 1; i < num.length; i++) {
			if (num[i].compareTo(max) > 0) // 只有使用了Comparable接口才能调用compareTo点方法
				max = num[i];
			if (num[i].compareTo(min) < 0)
				min = num[i];
		}
		return new pair<T>(min, max);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer nums[] = new Integer[] { 1, 2, 3, 5, 9, 11 };// 泛型必须是包装类
		sort result = new sort();
		System.out.println("max=" + result.minmax(nums).getmax() + "  min=" + result.minmax(nums).getmin());
		String array[] = new String[] { "aaaa", "bbbb", "cccc" };
		result.minmax(array);
		System.out.println("max=" + result.minmax(array).getmax() + "  min=" + result.minmax(array).getmin());

	}

}

输出结果：

可以看到，使用相同的pair类和sort类能够解决不同数据类型的数组最值问题

下面用一个具体的Student类来演示一遍，要求是找出学生数组中年龄最大与最小的学生；

public class Student  {
	private String StuName;
	private String StuNo;
	private int StuAge;

	public Student(String stuName, String stuNo, int stuAge) {
		super();
		StuName = stuName;
		StuNo = stuNo;
		StuAge = stuAge;
	}

	public String getStuName() {
		return StuName;
	}

	public void setStuName(String stuName) {
		StuName = stuName;
	}

	public String getStuNo() {
		return StuNo;
	}

	public void setStuNo(String stuNo) {
		StuNo = stuNo;
	}

	public int getStuAge() {
		return StuAge;
	}

	public void setStuAge(int stuAge) {
		StuAge = stuAge;
	}

    @Override
	public String toString() {
		return "Student [StuName=" + StuName + ", StuNo=" + StuNo + ", StuAge=" + StuAge + "]";
	}


}

public class sort {
	/**
	 * 这是一个泛型方法
	 * 
	 * @param <T  extends Comparable> 使用Comparable接口，这里不是继承,在泛型中extends既可能表示继承也可能表示接口
	 * @param num
	 * @return
	 */
	public static <T extends Comparable> pair<T> minmax(T num[]) {
		T min = num[0];
		T max = num[0];
		for (int i = 1; i < num.length; i++) {
			if (num[i].compareTo(max) > 0) // 只有使用了Comparable接口才能调用compareTo点方法
				max = num[i];
			if (num[i].compareTo(min) < 0)
				min = num[i];
		}
		return new pair<T>(min, max);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		sort result = new sort();
		result.minmax(students);
		System.out.println("max=" + result.minmax(students).getmax().toString() + "  min=" + result.minmax(students).getmin().toString());
	}

}

这么写，编译的时候就会出错，为什么呢？

因为sort类中的minmax方法必须是能用于比较的对象，而Student类是自定义类，默认继承于Java.object类，并没有提供比较方法需要在Student类中加入比较方法，将Student类做以下修改

public class Student implements Comparable {//在Student类中加入Comparable接口
	private String StuName;
	private String StuNo;
	private int StuAge;

	public Student(String stuName, String stuNo, int stuAge) {
		super();
		StuName = stuName;
		StuNo = stuNo;
		StuAge = stuAge;
	}

	public String getStuName() {
		return StuName;
	}

	public void setStuName(String stuName) {
		StuName = stuName;
	}

	public String getStuNo() {
		return StuNo;
	}

	public void setStuNo(String stuNo) {
		StuNo = stuNo;
	}

	public int getStuAge() {
		return StuAge;
	}

	public void setStuAge(int stuAge) {
		StuAge = stuAge;
	}
	
	@Override
	public String toString() {
		return "Student [StuName=" + StuName + ", StuNo=" + StuNo + ", StuAge=" + StuAge + "]";
	}

	@Override
	public int compareTo(Object o) {
                //这样是特别危险的，因为任何一个类型的对象都可以传进来与Student对象比较；
		//建议在类定义时加入泛型定义即Student implements Comparable<Student>  
		if (!(o instanceof Student)) {
			return -1;
		} else {
			Student ob = (Student) o;
			if (this.StuAge > ob.StuAge) {
				return 1;
			} else if (this.StuAge < ob.StuAge) {
				return -1;
			} else
				return 0;

		}
	}

}

再次运行：

最后做个总结：

上述代码中pair类称为泛型类，sort类中的minmax方法称为泛型方法，泛型的本质就是把数据类型当做参数来传递 ，使代码更加简洁更好维护。