java集合(泛型向(上下)限定

/*
 * 泛型的限定：
 * 1.向上限定<? extends E>:可以接收E类型或者E的子类型。
 */
import java.util.*;
public class GennericDemo6 {
public static void main(String[] args) {
//定义一个存储Person类对象的容器。
ArrayList<Person> a1=new ArrayList<Person>();
a1.add(new Person("java01"));
a1.add(new Person("java02"));
a1.add(new Person("java03"));
//定义一个存储Student1类对象的容器。
ArrayList<Student1> a2=new ArrayList<Student1>();
a2.add(new Student1("java001"));
a2.add(new Student1("java002"));
a2.add(new Student1("java003"));
print(a1);
print(a2);
}
//<?>这是一个通配符,可以接收任意类型的对象。
//我们只需要接收Person和Person子类的对象，使用泛型的限定，<? extends E>泛型的向上限定。
public static void print(ArrayList<? extends Person> a)
{
Iterator<? extends Person> it=a.iterator();
while(it.hasNext())
{
sop(it.next().getName());
}
}



public static<T> void sop(T t) {
System.out.println(t);
}
}
class Person{
private String name;
Person(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
class Student1 extends Person{ 
Student1(String name)
{
super(name);
}

}

import java.util.*;
/*
 * *2.向下限定<? super E>:可以接收E类型，或者E的父类型。
 */
public class GenericDemo8 {
public static void main(String[] args) {
//定义TreeSet对象，并且使用泛型限定为只能传递Student2对象。
TreeSet<Student2> ts=new TreeSet<Student2>(new Mycompare());
ts.add(new Student2("abc3"));
ts.add(new Student2("abc1"));
ts.add(new Student2("abc2"));
//对容器里的元素进行输出
for(Iterator<Student2> it=ts.iterator();it.hasNext();)
{
sop(it.next().getName());
}

//定义TreeSet对象，并且使用泛型限定为只能传递Student2对象。
//因为Mycompare方法限定为Student2类型，素以Worker不能调用，所以我们将其改成Person2
TreeSet<Worker2> ts1=new TreeSet<Worker2>(new Mycompare());
ts.add(new Student2("abc3"));
ts.add(new Student2("abc1"));
ts.add(new Student2("abc2"));
for(Iterator<Student2> it=ts.iterator();it.hasNext();)
{
sop(it.next().getName());
}
}
public static<T> void sop(T t) {
System.out.println(t);
}
}
class Person2{
private String name;
Person2(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
//Comparable<? super E>此处使用向下限定，Comparable的参数里面既可以是Student2也可以是Person2
class Student2 extends Person2 implements Comparable<Person2> { 
Student2(String name)
{
super(name);
}
public int compareTo(Person2 s)
{
return this.getName().compareTo(s.getName());
}


}
class Worker2 extends Person2
{
Worker2(String name)
{
super(name);
}
}


/*TreeSet(Comparator<? super E> comparator) 
构造一个新的空 TreeSet，它根据指定比较器进行排序。
Comparator的接口的原型里面的泛型就是向下限定的。
所以在传递Student2和他的父类Person2都行。
*/
class Mycompare implements Comparator<Person2>
{
public int compare(Person2 s1,Person2 s2)
{
int num=s1.getName().compareTo(s2.getName());
return num;
}
}