泛型学习的例子

例一：

package genericType;

public class Pair<T> {
	
	// 构造器一
	public Pair() {
		this.min = null;
		this.max = null;
	}
	//构造器二
	public Pair(T _min,T _max){
		this.min = _min;
		this.max = _max;
	}
	
	//设置器、访问器
	public T getMin() {
		return min;
	}
	public void setMin(T min) {
		this.min = min;
	}
	public T getMax() {
		return max;
	}
	public void setMax(T max) {
		this.max = max;
	}

	// 私有域
	private T min;
	private T max;
}

 

package genericType;

public class ArrayAlg {
	
	//定义一个泛型方法,含有类型变量的限定，
	//只能被实现了Comparable接口的类的数组调用
	public static < T extends Comparable<? super T> > 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<T>(min,max);
	}
	
	//定义一个泛型方法
	public static <T> T getMiddle(T[] a){
		return a[a.length / 2];
	}
}

 

package genericType;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class PairTest {
	public static void main(String[] args) {
		
		
		String[] words = {"Mary","had","a","little","lamb"}; 
		Pair<String> mm = ArrayAlg.minmax(words);
		System.out.println("Min = " + mm.getMin());
		System.out.println("Max = " + mm.getMax());
		
		
		Integer[] names = {1,2,3};
		Integer middle = ArrayAlg.getMiddle(names);
		System.out.println("Middle = " + middle);
		
		
		GregorianCalendar[] birthdays = {
			new GregorianCalendar(1906,Calendar.DECEMBER,9),
			new GregorianCalendar(1815,Calendar.DECEMBER,10),
			new GregorianCalendar(1903,Calendar.DECEMBER,3),
			new GregorianCalendar(1910,Calendar.JUNE,22),
		};
		Pair<GregorianCalendar> nn = ArrayAlg.minmax(birthdays); 
		System.out.println("Min = " + nn.getMin().getTime());
		System.out.println("Max = " + nn.getMax().getTime());
	}
}

 

结果：

Min = Mary

Max = little

Middle = 2

Min = Sun Dec 10 00:00:00 CST 1815

Max = Wed Jun 22 00:00:00 CST 1910

 

 

例二：

package genericType2;

import java.util.Date;
import java.util.GregorianCalendar;


public class Employee {
	
	// 构造器
	public Employee() {
		
	}	
	public Employee(String n,double s,int year,int month,int day) {
		this.name = n;
		this.salary = s;
		GregorianCalendar calendar = new GregorianCalendar(year,month-1,day);
		this.hireDay = calendar.getTime();
	}
	
	// 访问器 、 更改器
	public String getName() {
		return name;
	}
	public double getSalary() {
		return salary;
	}
	public Date getHireDay() {
		return hireDay;
	}
	
	// 工资计算
	public void raiseSalary(double byPercent){
		double raise = this.salary * byPercent / 100 ;
		this.salary = this.salary + raise ;
	}
	
	// 私有域
	private String name ;
	private double salary ;
	private Date hireDay ;
}

 

package genericType2;

public class Manager extends Employee {
	
	// 构造器
	public Manager(String n,double s,int year,int month,int day) {
		super(n,s,year,month,day);
		this.bonus = 0 ;
	}
	
	// 覆盖父类方法
	public double getSalary(){
		double baseSalary = super.getSalary();
		return baseSalary + bonus ;
	}
	
	//访问器  、 更改器
	public double getBonus() {
		return bonus;
	}

	public void setBonus(double bonus) {
		this.bonus = bonus;
	}
	
	// 私有域
	private double bonus ;	
}

 

package genericType2;

public class Pair<T> {
	
	// 构造器一
	public Pair() {
		this.min = null;
		this.max = null;
	}
	//构造器二
	public Pair(T _min,T _max){
		this.min = _min;
		this.max = _max;
	}
	
	//设置器、访问器
	public T getMin() {
		return min;
	}
	public void setMin(T min) {
		this.min = min;
	}
	public T getMax() {
		return max;
	}
	public void setMax(T max) {
		this.max = max;
	}

	// 私有域
	private T min;
	private T max;
}

 

package genericType2;

public class PairAlg {

	public static boolean hashNulls(Pair<?> p){
		return p.getMin() == null || p.getMax() == null;
	}
	
	//通配符捕获
	public static void swap(Pair<?> p){
		swapHelper(p);
	}
	// 辅助swap方法
	public static <T> void swapHelper(Pair<T> p) {
		T t = p.getMin();
		p.setMin(p.getMax());
		p.setMax(t);
	}
}

 

package genericType2;

public class PairTest2 {
	public static void main(String[] args) {
		
		Manager ceo = new Manager("张作强", 800000, 2008, 12, 15);
		Manager cfo = new Manager("陈惠仪", 600000, 2008, 12, 15);
		Pair<Manager> buddies = new Pair<Manager>(ceo,cfo);
		printBuddies(buddies);
		
		ceo.setBonus(1000000);
		cfo.setBonus(500000);
		Manager[] managers = {ceo , cfo};
		
		Pair<Employee> result = new Pair<Employee>();
		minMaxBonus(managers , result);
		System.out.println("Min : " + result.getMin().getName() + 
				" , Max : " + result.getMax().getName());
		
		System.out.println("-------- swap --------");
		
		maxMinBonus(managers,result);
		System.out.println("Min : " + result.getMin().getName() + 
				" , Max : " + result.getMax().getName());
	}

	// 通配符的超类型限定<? super Manager>
	private static void maxMinBonus(Manager[] a, Pair<? super Manager> result) {
		
		minMaxBonus(a, result);
		// OK -- swapHelper captures wildcard type
		PairAlg.swapHelper(result);
	}

	// 通配符的超类型限定<? super Manager>
	private static void minMaxBonus(Manager[] a, Pair<? super Manager> result) {
		
		if(a == null || a.length == 0)
			return;
		Manager min = a[0];
		Manager max = a[0];
		for (int i = 1; i < a.length; i++) {
			if(min.getBonus() > a[i].getBonus())
				min = a[i];
			if(max.getBonus() < a[i].getBonus())
				max = a[i];
		}
		result.setMin(min);
		result.setMax(max);
	}

	//通配符类型<? extends Employee>
	private static void printBuddies(Pair<? extends Employee> p) {
		Employee min = p.getMin();
		Employee max = p.getMax();
		System.out.println(min.getName() + " and " + max.getName() + " are buddies.");
	}
}

 

结果：

张作强 and 陈惠仪 are buddies.

Min : 陈惠仪 , Max : 张作强

-------- swap --------

Min : 张作强 , Max : 陈惠仪