泛型限定的概括

//Person类

package en.iteast.generic.domain;

import java.util.Comparator;

public class Person{
	private int age;
	private String name;
	
	public Person() {
		super();
	}

	public Person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + "]";
	}

	@Override
	public int hashCode() {
		final int NUMBER = 36;
		return this.name.hashCode() + age*NUMBER;
	}
	@Override
	public boolean equals(Object obj) {
		/**
		 * equals指定的类型本来就是Object，无法运用泛型对其进行指定
		 * （ComparatorByName implements Comparator<Person>）
		 * 该语句就可以指定类型为Person,从而其中compare的参数并不依赖于Object，
		 * 从而并不需要进行强制类型转换，也就使代码根据安全性，设计更简便。
		 */
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Person)) {
			throw new ClassCastException();
		}
		
		Person person  = (Person)obj;
		return this.name.equals(person.name) && this.age == person.age;
				
		
	}

}

//Worker类

package en.iteast.generic.domain;

public class Worker extends Person{
	public Worker() {
		super();
	}

	public Worker(int age, String name) {
		super(age, name);
	}
	@Override
	public String toString() {
		return "worker [name="+getName()+",age"+getAge()+"]";
	}

}

//Student类

package en.iteast.generic.domain;

public class Student extends Person{
	public Student() {
		super();
	}
	public Student(int age,String name) {
		super(age,name);
	}
	@Override
	public String toString() {
		return "Student [name="+getName()+",age"+getAge()+"]";
	}
	
}

package en.iteast.generic.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import en.iteast.generic.domain.Person;
import en.iteast.generic.domain.Student;
import en.iteast.generic.domain.Worker;

public class GenericDemo7 {
	public static void main(String[] args) {
		
		Set<Worker> set = new HashSet<Worker>();//利用hash值进行排序
		
		set.add(new Worker(18,"lixin"));
		set.add(new Worker(19,"ting"));
		set.add(new Worker(18,"lidan"));
		set.add(new Worker(19,"ni"));
		
		inputeCollection(set);
		
		List<Student> list = new ArrayList<Student>();
		list.add(new Student(21,"zhang3"));
		list.add(new Student(22,"lki4"));
		list.add(new Student(23,"wang5"));
		list.add(new Student(24,"LiXinTing"));
		
		inputeCollection(list);
	}
	
//限定泛型的范围：	
	
	private static void inputeCollection(Collection<? extends Person> coll){ 
		for (Iterator<? extends Person> iterator = coll.iterator(); iterator.hasNext();) {
			//Object obj = iterator.next();
			/**
			 * 既然限定了对象范围不超过Person，那么就可以用Person类型对其进行接受
			 * 而且遍历时，可以对单个属性进行遍历
			 * 格式：
			 * 泛型上限：<? extends E>:接收E类型或者E的子类型。
			 * 泛型下限：<? super E>:接收E类型或者E的父类型。
			 */
			Person obj = iterator.next();
			System.out.println(obj.getName());
		}
	}

}

输出结果：

ni
lixin
ting
lidan
zhang3
lki4
wang5
LiXinTing