黑馬程序員_java對泛型的限定：

------- 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 ;
        }
        
}