118_容器_自定義泛型_深入2_無多態_通配符_無泛型數組_jdk7泛型使用

通配符

• 通配符的測試-TestWildcard

package genericity_wildcard;

import java.util.ArrayList;
import java.util.List;

/**
 * ? -->通配符，類型不確定，用於聲明變量|形參上
 * 不能用在
 * 1、創建對象
 * 2、創建泛型類 泛型方法 泛型接口上
 */

public class TestWildcard {
    public static void main(String[] args) {
        //聲明
        List<?> list =new ArrayList<Integer>();
        list =new ArrayList<String>();
        list =new ArrayList<Object>();  
        /**list =new ArrayList<?>();
          *編譯錯誤 不能創建對象 */

        test(list);
    }
    //可用於泛型方法聲明
    public static void test(List<?> list){

    }

    /**不能用於泛型方法聲明的返回值
            public static <?> void test2(List<?> list){

            }
     */

    class Test<T>{

    }
    /**不能用在創建泛型類
          class Test2<?>{

          }
    */
}

• 定義一個水果類-Fruit

package genericity_wildcard;
/**
 *  繼承鏈
 *   Object
 *     | 
 *   Fruit
 *    /  \
 * Apple Pear
 *   |
 * FujiApple
 */
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}

• extends泛型的上限-Wildcard_Extends

package genericity_wildcard;

import java.util.ArrayList;
import java.util.List;

/**
 * extends : 泛型的上限  <= 即子類或自身
 * 1、一般用於上限操作
 * 2、不能使用在添加數據上面，一般都是讀取操作
 * 3、規則
 *  List<Fruit> -->List<? extends Fruit>
 *  List<Apple> -->List<? extends Fruit>
 *  List<? extends Apple> -->List<? extends Fruit>
 *  不能存放
 *  List<?>
 *  List<? extends Object>
*/
public class Wildcard_Extends {
    //泛型類
    static class Test<T extends Fruit>{
    }
    //? extends Fruit
    public static void test(List<? extends Fruit> list){
       /*
        *不能用於添加數據
        list.add(new Apple());
        list.add(new FujiApple());
        list.add(new Pear());
        list.add(new Fruit());
        */
        list.add(null);
    }

    public static void main(String[] args) {
        //extends 爲上限
        @SuppressWarnings("unused")
        Test<Fruit> t1 =new Test<Fruit>();

        @SuppressWarnings("unused")
        Test<Apple> t2 =new Test<Apple>();

        @SuppressWarnings("unused")
        Test<Pear> t3 =new Test<Pear>();


        //規則 
        List<? extends Fruit> list1 =new ArrayList<Fruit>();
        test(list1);

        List<Fruit> list2 =new ArrayList<Fruit>();
        test(list2);

        List<Apple> list3 =new ArrayList<Apple>();
        test(list3);

        // ? extends Apple 
        List<? extends Apple> list4 =new ArrayList<FujiApple>();
        test(list4);

        //? -->爲什麼錯誤 ,因爲 ? 等同於 ? extends Object
        @SuppressWarnings({ "unused", "rawtypes" })
        List<?> list5=new ArrayList();
        //test(list5);

        @SuppressWarnings("unused")
        List<? extends Object> list6=new ArrayList<Object>();
        //test(list6);

        List<FujiApple> app =new ArrayList<FujiApple>();        
        test(app);
    }
}

• super,泛型的下限-Wildcard_Super

package genericity_wildcard;



import java.util.ArrayList;
import java.util.List;

/**
 * super : 泛型的下限  >= 即父類或自身
 * 1、一般用於下限操作
 * 2、能夠添加數據上面，不能添加父對象
 * 3、規則
 *  List<Fruit> -->List<? super Apple>
 *  List<Apple> -->List<? super Apple>
 *  List<? super Fruit> -->List<? super Apple>
 *  不能存放
 *  List<? super FujiApple> -->List<?super Apple>
 */

public class Wildcard_Super {
    public static void test(List<? super Apple> list){
        list.add(new Apple());
        list.add(new FujiApple());
        /**list.add(new Fruit());
         * 不能添加 父類對象*/

    }
    public static void main(String[] args) {
        // >= 即父類或自身
        List<Apple> list1 =new ArrayList<Apple>();
        test(list1);

        List<Fruit> list2 =new ArrayList<Fruit>();
        test(list2);

        List<Object> list3 =new ArrayList<Object>();
        test(list3);

        //規則
        List<? super Apple> list4 =new ArrayList<Apple>();
        test(list4);

        List<? super Fruit> list5 =new ArrayList<Object>();
        test(list5);

        @SuppressWarnings("unused")
        List<? super FujiApple> list6 =new ArrayList<Object>();
        //test(list6);

        @SuppressWarnings("unused")
        List<?> list7 =new ArrayList<Object>();
        //test(list7);
    }
}

泛型的嵌套

• 學生類-Student

package genericity_nest;

public class Student<T> {
    private T score;
    public T getScore() {
        return score;
    }
    public void setScore(T score) {
        this.score = score;
    }
}

• 尚學堂學生類-BjsxtStudent

package genericity_nest;

public class BjsxtStudent<T> {
    private T stu;
    public T getStu() {
        return stu;
    }
    public void setStu(T stu) {
        this.stu = stu;
    }
}

• 嵌套測試類-TestNest

package genericity_nest;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class TestNest {
    /** 泛型嵌套 -->由外到內拆分*/
    public static void main(String[] args) {
        Student<String> stu =new Student<String>();     
        stu.setScore("優秀");
        System.out.println(stu.getScore());

        //泛型嵌套
        BjsxtStudent<Student<String>> bjsxtstu =new BjsxtStudent<Student<String>>();
        bjsxtstu.setStu(stu);

        stu=bjsxtstu.getStu();
        String score =stu.getScore();
        System.out.println(score);


        //HashMap -->使用泛型嵌套
        Map<String,String> map =new HashMap<String,String>();
        map.put("a", "java300");
        map.put("b", "馬士兵javase");

        Set<Entry<String,String>> entrySet= map.entrySet();
        for(Entry<String,String> entry:entrySet){
            String key =entry.getKey();
            String value =entry.getValue();
            System.out.println(key+"-->"+value);
        }
    }
}

泛型沒有數組，沒有多態

• 水果類-Fruit

package genericity_supplement;
/**
 *  繼承鏈
 *   Object
 *     | 
 *   Fruit
 *    /  \
 * Apple Pear
 *   |
 * FujiApple
 */
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}

• 測試類-TestOthers

package genericity_supplement;

import java.util.ArrayList;
import java.util.List;

/**
 * 1、泛型沒有多態
 * 2、泛型沒有數組
 */

public class TestOthers {
    public static void main(String[] args) {
        //多態
        @SuppressWarnings("unused")
        Fruit f =new Apple();
        /** List<Fruit> list =new ArrayList<Apple>();
          * 泛型沒有多態  
          */

        //使用通配符完成類似多態 
        @SuppressWarnings("unused")
        List<? extends Fruit> list =new ArrayList<Apple>();

        /**Fruit<String>[] arr =new Fruit<String>[10];
         * 泛型沒有數組
         */

        //jdk1.7泛型簡化
        @SuppressWarnings("unused")
        List<Fruit> list2 =new ArrayList<>();
    }
}