程序比较简单，很容易看懂，主要是对泛型的限定：   <? extends E > ，  < ? super E  > 的理解和体会。
不知之处还请学友多多提点。
                               

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Car{
        private String name ;
        private int price ;
       
        Car(String name , int price ){
                this.name = name ;
                this.price = price ;
        }
       
        public String getName(){
                return name ;
        }
        public int getPrice(){
                return price ;
        }
}

class Baoma extends Car{
        Baoma(String name , int price ){
                super( name , price );
        }
}


public class WildcardDemo {

       
        /* 通过  printCollection 方法来演示  ? extends T */
       
        public static void printCollection( Collection<? extends Car> c){ // ? extends Car -----> Car c = (Car) ?类对象  ,向上转型
                for( Iterator<? extends Car> it =  c.iterator() ; it.hasNext() ; ){
                        System.out.println( ( it.next()).getName() );
                       
                        /*   ? 是最终父类(car)子类--则继承或 复写Car中的方法，
                                  当  ?类的对象 在调用该方法时，   被上转型为它的最高父类 Car的对象 ，
                                  所以调用Car类中的方法，就可以实现各自不同的表现形式，既多态的特性。
                                  这也就是  E extends ?  不限上限的原因。
                        */
                }
        }
       
        public static void main(String[] args) {


                ArrayList<Car> al = new ArrayList<Car>();
                al.add(new Car("car1" , 2222));
                al.add(new Car("car2" , 2333));
                al.add(new Car("car3" , 4222));
                printCollection(al);
               
                ArrayList<Baoma> all = new ArrayList<Baoma>( );
                all.add(new Baoma("baoma----1" , 2222));
                all.add(new Baoma("baoma----2" , 1333));
                all.add(new Baoma("baoma----3" , 4222));
                printCollection(all);
               
               
               
                /*下面通过 new TreeSet<E>((Comparator comparator) ) 来说明  ? super E  */
               
                TreeSet<Car> ts = new TreeSet<Car>( new CarPriceComparator() );
                ts.add(new Car("car1" , 2222));
                ts.add(new Car("car2" , 1333));
                ts.add(new Car("car3" , 4222));
               
               
                TreeSet< Baoma> tst = new TreeSet< Baoma>(new CarPriceComparator() );  //不用 （自己E）的比较器用 （父类？）的比较器
                tst.add(new Baoma("car1-------" , 2222));                                                          //  E(Baoma) 表示自己所属的类 ， ?(Car) 表示父类 ，
                tst.add(new Baoma("car2-------" , 1333));                                                 
                tst.add(new Baoma("car3-------" , 4222));
               
                /*
                 为什么子类可以用父类的比较器？
                        子类掉用父类的比较器是，被上转型成父类对象
                        但对父类没有没有限制，所以你用的是它的父类都行，
                        父类比较器实现compare方法所调用的父类成员，子类都有（继承或复写）既可以通过编译
                        这也就是  ? super E 不限上限的原因。
                 */
               
        }       
}


/*车类的价格比较器*/
class CarPriceComparator implements Comparator< Car>{   

       
        public int compare(Car o1, Car o2) {
                int num = new Integer(o1.getPrice() ).compareTo(new Integer(o2.getPrice()) );
                if(num == 0)
                        return o1.getName().compareTo(o2.getName());
                return num ;
        }
}

/*宝马类的价格比较器*/
class BaomaPriceComparator implements Comparator< Baoma>{       

        public int compare(Baoma o1, Baoma o2) {
                int num = new Integer(o1.getPrice() ).compareTo(new Integer(o2.getPrice()) );
                if(num == 0)
                        return o1.getName().compareTo(o2.getName());
                return num ;
        }
       
}

果然新人贴都没人回，好吧，下次我也发语言性的帖子好了，

写的不错，赞一个{:2_36:}

是啊，新人贴大神看不上，黑马币!

再帮你顶一个

不错很好，感谢分享

挺好的,很有营养,正好看了你的贴子补补盲点