java泛型---通配符,泛型嵌套

package generic;

import java.util.ArrayList;
import java.util.List;
/**
 * ? -->通配符，類型不肯定，用於聲明 變量|形參 上
 * 不能用在：
 * 1，建立對象
 * 2，建立泛型類 、泛型方法、泛型接口上
 *
 */
public class WildcardTest {

    public static void main(String[] args) {
        //聲明
        List<?> list = new ArrayList<Integer>();
        list = new ArrayList<String>();
        list = new ArrayList<Object>();
        
        test(list);
        //編譯錯誤，不能建立對象
//        list = new ArrayList<?>();
    }
    
    public static void test    (List<?> list){
        
    }
    //？不能用在泛型方法上
    /*public static <?> void test2(List<?> list){
        
    }*/
    //？不能建立泛型類
    /*class Test<?>{
        
    }*/
}

固然這樣用是沒有什麼意義的，它和用Object同樣

 泛型上限 extends:

 

幾個有繼承關係的類：

package generic;
/**
 * 繼承鏈：
 *       Object
 *        /  \
 *     Apple  Pear
 *     /
 *  FujiApple 
 *          
 * @author Administrator
 *
 */
public class Fruit {

}
class Apple extends Fruit{
    
}
class Pear extends Fruit{
    
}
class FujiApple extends Apple{
    
}

例子程序：

package generic;

import java.util.ArrayList;
import java.util.List;
/**
 * extends:泛型的上限 表示 <= ,即 子類
 * 1，通常用於 限制操做
 * 2，不能用在添加數據上，通常都是讀取操做
 * 3，規則：
 *    遇到  List<? extends Fruit> 什麼樣的數據能夠往上放：
 *    List<Fruit>
 *    List<Apple>
 *    List<? extends Apple>
 *    不能存放：
 *    List<?>
 *    List<? extends Object>
 * @author Administrator
 *
 */
public class ExtendsTest {

    public static void main(String[] args) {
        //extends 爲上限，List的類型上限是Fruit
        Test<Fruit> t1 = new Test<Fruit>();
        Test<Apple> t2 = new Test<Apple>();
        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);
        List<FujiApple> list4 = new ArrayList<FujiApple>();
        test(list4);
        List<? extends Apple> list7 = new ArrayList<FujiApple>();
        test(list7);
        //報錯：由於 ? 至關於 ? extends Object，範圍超過了Fruit
        List<?> list5 = new ArrayList<Object>();
//        test(list5);
        List<? extends Object> list6 = new ArrayList<Object>();
//        test(list6);
    }
    
    //? extends Fruit
    public static void test(List<? extends Fruit> list){
        
    }
    
    //內部類
    static class Test<T extends Fruit>{
        
    }
    
}

 泛型的下限：Super

 

package generic;

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

/**
 * super: 泛型的下限 >= 父類或者自身
     1，通常用於 下限制操做
 * 2，可以添加數據上，不能添加父對象
 * 3，規則：
 */
public class SuperTest {

    public static void main(String[] args) {
        //傳入的List類型必須   >=Apple，便是 Apple類的父類或自身
        List<Apple> list1 = new ArrayList<Apple>();
        test(list1);
        List<Fruit> list2 = new ArrayList<Fruit>();
        test(list2);
        List<Object> list3 = new ArrayList<Object>();
        test(list3);
        
        //規則 Object > Fruit 正確
        List<? super Fruit> list4 = new ArrayList<Object>();
        test(list4);
        //Apple = Apple 正確
        List<? super Apple> list5 = new ArrayList<Apple>();
        test(list5);
        //FujiApple < Apple,編譯報錯
        List<? super FujiApple> list6 = new ArrayList<Object>();
        //test(list6);
        //? --> ? extends Object ，可能意思是左邊聲明是Object的子類，右邊是Object，不行？
        List<?> list7 = new ArrayList<Object>();
        //test(list7);
        
    }
    
    public static void test(List<? super Apple> list){
        //不能添加父類對象，子類能添加，這裏不是很明白！
        list.add(new Apple());
        list.add(new FujiApple());
        //list.add(new Fruit());//父類不能添加
        
    }
}

 泛型嵌套：

學生類：

package generic;

public class Stu<T> {

    private T score;

    public T getScore() {
        return score;
    }

    public void setScore(T score) {
        this.score = score;
    }
    
}

學校類：

package generic;

/**
 * @author Administrator
 *
 * @param <T>
 */
public class School<T> {
    private T stu;

    public T getStu() {
        return stu;
    }

    public void setStu(T stu) {
        this.stu = stu;
    }
    
}

測試類：

package generic;

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

/**
 * 泛型嵌套
 * @author Administrator
 *
 */
public class StuApp {

    public static void main(String[] args) {
        
        Stu<String> stu = new Stu<String>();
        stu.setScore("優秀");
        System.out.println(stu.getScore());
        
        //泛型嵌套：
        School<Stu<String>> sch = new School<Stu<String>>();
        sch.setStu(stu);
        stu = sch.getStu();
        String score = stu.getScore();
        System.out.println(score);
        
        //HashMap
        Map<String,String> map = new HashMap<String,String>();
        map.put("a", "老大");
        map.put("b", "老二");
        
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() +"--->"+ entry.getValue());
        }
    }
}

 泛型沒有多態：

package generic;

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

public class Other {

    public static void main(String[] args) {
        //多態
        Fruit f = new Apple();
        //泛型沒有多態：
//        List<Fruit> list = new ArrayList<Apple>();//錯誤
        List<? extends Fruit> list = new ArrayList<Apple>();
        
        //泛型沒有數組
//        Fruit<String>[] arr = new Fruit<String>(); //報錯
        
        //JDK1.7泛型簡化
        List<String> list2 = new ArrayList<>();
        
    }
}