黑马程序员_java对泛型的限定： <? extends E > ， < ? super E > 的理解和体会。

------- android培训、 java培训、期待与您交流！ ----------

为什么子类可以用父类的比较器？ 
       子类掉用父类的比较器是，被上转型成父类对象
        但对父类没有没有限制，所以你用的是它的父类都行， 
      父类比较器实现compare方法所调用的父类成员，子类都有（继承或复写）既可以通过编译
      这也就是  ? 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 ;
        }
        
}