JAVA——泛型限定（占位符）

?通配符。也可以理解为占位符。
泛型的限定:
？extends E: 可以接受E类型或者E的子类型。上限
？super E: 可以接收E类型或者E的父类型。下限

import java.util.*;
class GenericDemo6
{
    public static void main(String[] args)
    {
        ArrayList<String>al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        ArrayList<Integer>al1 = new ArrayList<Integer>();
        al1.add(4);
        al1.add(5);
        al1.add(6);

        printColl(al);
        printColl(al1);
    }
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?>it = al.iterator(); 
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

结果：
abc1
abc2
abc3
4
5
6

import java.util.*;
class GenericDemo7 
{
    public static void main(String[] args) 
    {

        TreeSet<Student> ts = new TreeSet<Student>(new Comp());

        ts.add(new Student("abc03"));
        ts.add(new Student("abc02"));
        ts.add(new Student("abc06"));
        ts.add(new Student("abc01"));

        Iterator<Student> it = ts.iterator();

        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
        /**/



        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());

        ts1.add(new Worker("wabc--03"));
        ts1.add(new Worker("wabc--02"));
        ts1.add(new Worker("wabc--06"));
        ts1.add(new Worker("wabc--01"));


        Iterator<Worker> it1 = ts1.iterator();

        while(it1.hasNext())
        {
            System.out.println(it1.next().getName());
        }
    }
}

/*
class StuComp implements Comparator<Student>
{
    public int compare(Student s1,Student s2)
    {
        return s1.getName().compareTo(s2.getName());
    }
}

class WorkerComp implements Comparator<Worker>
{
    public int compare(Worker s1,Worker s2)
    {
        return s1.getName().compareTo(s2.getName());
    }
}
*/

class Comp implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        return p2.getName().compareTo(p1.getName());
    }
}


class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public String toString()
    {
        return "person :"+name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }

}

class Worker extends Person
{
    Worker(String name)
    {
        super(name);
    }
}

看代码中注释的部分，因为Student和Worker不具备可比性，我们分别为两个类准备了相应的比较器。但是我们看这样似乎有点代码的冗余。因此，我们换成了如下代码：

class Comp implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        return p2.getName().compareTo(p1.getName());
    }
}

这里用到了所谓的下限。