java中的泛型

爲什麼要有泛型(Generic)?

1. 解決元素存儲的安全性問題

2. 解決獲取數據元素時，需要類型強轉的問題

1.泛型的聲明

  interfaceList<T> 和 class TestGen<K,V>

  其中，T,K,V不代表值，而是表示類型。這裏使

           用任意字母都可以。常用T表示，是Type的縮寫。

 

2.泛型的實例化：

     一定要在類名後面指定類型參數的值（類型）。如：

          List<String>strList = newArrayList<String>();

        Iterator<Customer> iterator = customers.iterator();

T只能是類，不能用基本數據類型填充。

泛型的幾個重要使用：

1.在集合中使用泛型

2.自定義泛型類

3.泛型方法

4.泛型接口

在集合中使用泛型：

List<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(87);
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

Map<String,Integer> map = new HashMap<>();
        map.put("AA", 78);
        map.put("BB", 87);
        map.put("DD", 98);
        
        Set<Map.Entry<String,Integer>> set = map.entrySet();
        for(Map.Entry<String,Integer> o : set){
            System.out.println(o.getKey() + "--->" + o.getValue());
        }

自定義泛型類（仿照着colletion接口編寫）：

public class TestT<T>{} 類名後面加泛型。

然後程序中就可以使用T了。

//1.當實例化泛型類的對象時，指明泛型的類型。
        //指明以後，對應的類中所有使用泛型的位置，都變爲實例化中指定的泛型的類型
        //2.如果我們自定義了泛型類，但是在實例化時沒有使用，那麼默認類型是Object類的

例子：

public class TestT<T> {
    private String id;
    private String name;
    private T t;
    private List<T> list=new ArrayList<>();

}

使用時：

TestT<String> t=new TestT<>();//指明泛型爲String
        t.setT("Aa");
        String t2 = t.getT();
        System.out.println(t2);

//繼承泛型類或泛型接口時，可以指明泛型的類型，則子類中所有的泛型都變成指明的泛型。如果沒有指明泛型，則子類也爲泛型類

class subT extends TestT<Integer>{}；//指明泛型

class subT<T> extends TestT<T>{}//未指明泛型

dao中使用泛型舉例：

//父類

public class TestDaoI<T> {
    public void add(T t){
        
    }
    public void delete(String index){
        
    }
    public T getT(String index){
        return null;
    }
    public List<T> getForList(){
        return null;
    }
}

//具體子類，指明泛型

public class TestPersonDaoI extends TestDaoI<Person> {
    
}

泛型方法：（泛型方法中的泛型不一定要跟該類的泛型一致，該類的泛型是T,泛型方法可以是E）

public  <E> E getE(E e){
        return e;
    }

泛型與繼承的關係:
     * 若類A是類B的子類，那麼List<A>就不是List<B>的子接口，List<A>與List<B>是並列關係。

 * 通配符 ?
     * List<A>、List<B>、。。。。都是List<?>的子類
     *
     * ? extends A :可以存放A及其子類
     * ? super A:可以存放A及其父類
     */
    @Test
    public void test6(){
        List<?> list = null;
        List<Object> list1 = new ArrayList<Object>();
        List<String> list2 = new ArrayList<String>();
        list = list1;
        list = list2;
        //Number是Integer的父類
        List<? extends Number> list3 = null;
        List<Integer> list4 = null;
        list3 = list4;
        List<? super Number> list5 = null;
        list5 = list1;
    }

靜態方法中不能使用類的泛型。（類具有泛型，則在實例化時要指明該類的泛型，靜態方法可以類名直接調用，此時還沒有對象，泛型還未指明。）