java（泛型）

 

1.例子

/**
 * 泛型的使用
 * 在集合中使用泛型
 * 注意點：
 * 1.泛型的類型必須是類，不能是基本數據類型，需要用到基本數據類型的位置，需要使用其包裝類
 * 2.如果實例化時，沒有指明泛型的類型，默認類型爲java.lang.Object類型
 */
public class GenericTest {

    @Test
    public void test1() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(11);
        list.add(22);
        list.add(33);
        for(Integer s : list) {
            int scope = s;
            System.out.println(scope);
        }
    }

    @Test
    public void test2() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(11);
        list.add(22);
        list.add(33);
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            int scope = iterator.next();
            System.out.println(scope);
        }
    }

    @Test
    public void test3() {
        Map<String,Integer> map = new HashMap<String, Integer>();
        map.put("jack",22);
        map.put("lilei",33);
        map.put("zhangsan",44);
        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            int value = e.getValue();
            System.out.println(key+" ---- " +value);
        }
    }
}

 

2. Order例子

public class Order<T> {
    String orderName;
    int orderId;
    T orderT;

    public Order() {
       // T[] t = new T[10]; 編譯不通過
      //  T[] t = (T[])new Object[10]; 編譯通過

    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    /**
     * 泛型方法: 在方法中出現了泛型的結構，泛型參數與類的泛型參數沒有任何關係，
     * 換句話說，泛型方法所屬的類是不是泛型類都沒有關係
     * 泛型方法，也可以聲明爲靜態的，原因：泛型參數是在調用方法時確定的，並非在實例化類時確定
     * @param arrays
     * @param <E>
     * @return
     */
    public <E> List<E> getList(E[] arrays) {
        List<E> list = new ArrayList<E>();
        for(E e : arrays) {
            list.add(e);
        }
        return list;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

public class SubOrder extends Order<Integer>{ } public class SubOrder1<T> extends Order<T> { }

public class GenericTest1 {

    @Test
    public void test1() {
        //如果定義了泛型類，實例化沒有指明類的泛型，則認爲此泛型類型爲Object類型
        //如果定義了類是帶泛型的，建議在實例化時要指明類的泛型
        Order order = new Order();
        order.setOrderT("ss");
        order.setOrderT(11);
    }

    @Test
    public void test2() {
        Order<String> order = new Order<String>();
        order.setOrderT("11");
        //order.setOrderT(2); 編譯不通過，報錯
    }

    @Test
    public void test3() {
        //SubOrder是個普通類，由於子類在繼承帶泛型的父類時，指明瞭泛型類型，則實例化子類對象時，不再需要指明泛型
        SubOrder subOrder = new SubOrder();
        subOrder.setOrderT(11);

        SubOrder1<String> subOrder1 = new SubOrder1<String>();
        subOrder1.setOrderT("ss");
    }

    @Test
    public void test4() {
        Order<String> order = new Order<String>();
        Integer[] integers = new Integer[]{1,2,3,4};
        String[] strings = new String[]{"zhangsan","lisi","wangwu"};
        List<Integer> list = order.getList(integers);
        List<String> list1 = order.getList(strings);
        System.out.println(list);
        System.out.println(list1);

    }

}

 

3.

 

 

 

 

 

 

 

 

 

 

 

 4.通配符的使用

public class GenericTest2 {

    @Test
    public void test1() {

        List<String> list1 = new ArrayList<String>();
        list1.add("st");
        list1.add("tt");
        List<Integer> list2 = new ArrayList<Integer>();
        list2.add(11);
        list2.add(22);
        List<?> list = null;
        list = list1;
        list = list2;
        print(list1);
        print(list2);

    }

    public void print(List<?> list) {

        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object o = iterator.next();
            System.out.println(o);

        }

    }
}