import java.util.*;
class GenericDemo6
{
        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("abc08"));
                ts.add(new Student("abc09"));

                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("wwwabc03"));
                ts1.add(new Worker("wwwabc02"));
                ts1.add(new Worker("wwwabc06"));
                ts1.add(new Worker("wwwabc08"));
                ts1.add(new Worker("wwwabc09"));

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

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

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

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

class Person
{
        private String name;
        Person(String name)
        {
                this.name =name;
        }
        public String getName()
        {
                return name;
        }

}

class Comp implements Comparator<Person>
{
        //这里只能使用父类的方法
        public int compare(Person p1,Person p2)
        {
                return p2.getName().compareTo(p1.getName());
        }
}

二话不说，强力插入

java基础视频第15天，泛型限定
里面讲到了
<? extends E> 接受E类型或者E 的子类类型
<? super E>    接收E类型或者E 的 父类类型

自己设定的时候是照着这个格式写吧？
问题，
为什么老师举例的代码里面，也没教咱只写个<父类名称>就可以而不用写这个<? extends xxx>呢
不是应该照着这个格式限定一下吗，咋不限定也能使呢

泛型限定确实是要照着那个格式写。我已经找到你出问题的代码，虽然你没有写出来。

1. public static void PrintColl(ArrayList<? extends Person> al)//泛型限定。
   
2.         {
   
3.                 Iterator<? extends Person> it = al.iterator();
   
4.                 while(it.hasNext())
   
5.                 {
   
6.                         System.out.println(it.next().getName());
   
7.                 }
   
8.         }

复制代码

这个就是泛型上限。

大概你疑惑的是下面这段代码：

1. 
   
2. class Student implements Comparable<Person>
   
3. {
   
4.         public int compareTo(Person s)
   
5.         {
   
6.                 this.getName();
   
7.         }
   
8. }
   
9. class Comp implements Comparator<Person>//这里传Student或者Person类型都可以
   
10. {
    
11.         public int compare(Person s1,Person s2)
    
12.         {
    
13.                 //Person s1 = new Student("abc1");
    
14.                 return s1.getName().compareTo(s2.getName());
    
15.         }
    
16. }

复制代码

这里传的泛型是父类Person，所以根据多态的原理，传入Person和Student都是可以的，效果就和泛型上限一样。是不是这个疑惑了你啊？

1. public static void PrintColl(ArrayList<? extends Person> al)//泛型限定。
   
2.         {
   
3.                 Iterator<? extends Person> it = al.iterator();
   
4.                 while(it.hasNext())
   
5.                 {
   
6.                         System.out.println(it.next().getName());
   
7.                 }
   
8.         }

复制代码

你这个代码，我真没有写，但是也没报错，一样用撒。
我也认为。多态是要和你这样写个声明。 Iterator<? extends Person> it = al.iterator();
视频里没有，我也没有写。但是却没出问题。这个就是我的疑惑
但是我没有写，也能传Person不写<？extends XXX >,没有任何问题。
（以下是第二遍编辑的内容）
我知道了，你说的意思是： 根据多态原理，我传入 Person。因为Person是Student,Worker的父类
所以。 意义等于：<？ extends Person> 你是这个意思吗？

air 发表于 2013-12-9 21:39
你这个代码，我真没有写，但是也没报错，一样用撒。
我也认为。多态是要和你这样写个声明。 Iterator ...

是的咯。看样子你已经明白自己问题出在哪了嘛。现在懂了没有

Forevery 发表于 2013-12-9 21:59
是的咯。看样子你已经明白自己问题出在哪了嘛。现在懂了没有

3Q，那么，同理，是正儿八经写格式常用呢，还是多态简写常用呢？