集合中使用泛型&&自定义泛型_泛型方法

泛型的使用
1. 在集合中使用泛型
2.在定义泛型类，泛型接口，泛型方法
3.泛型于继承的关系
4.通配符

TestGeneric

package com.aff.Gen;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

/*
 泛型的使用
        1. 在集合中使用泛型
        2.在定义泛型类，泛型接口，泛型方法
        3.泛型于继承的关系
        4.通配符
 */
public class TestGeneric {

    // 集合中没有使用泛型的情况下
    @Test
    public void test1() {
        List list = new ArrayList();
        list.add(23);
        list.add(35);
        list.add(56);
        list.add(new String("aa"));

        for (int i = 0; i < list.size(); i++) {
            int score = (Integer) list.get(i);
            System.out.println(score);
        }
    }

    // 1在集合中使用泛型
    @Test
    public void test2() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(23);
        list.add(35);
        // list.add(new String("aa"));//添加不进去会报错的
        // for (int i = 0; i < list.size(); i++) {
        // System.out.println(list.get(i));
        // }
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    // 泛型的使用
    @Test
    public void test3() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("aa", 23);
        map.put("bb", 33);
        map.put("cc", 6543);
        map.put("dd", 276);

        Set<Map.Entry<String, Integer>> set = map.entrySet();
        for (Map.Entry<String, Integer> o : set) {
            System.out.println(o.getKey() + "----->" + o.getValue());
        }
    }

    // 自定义泛型类的使用
    @Test
    public void test4() {
        /*
         * 1.实例化泛型类的对象时，指明泛型的类型 指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
         * 2.如果我们自定义了泛型类，但是实例化时没有使用，那么默认类型是Object类的
         */
        Order<Boolean> order = new Order<Boolean>();
        // order.getT();
        order.setT(true);
        System.out.println(order.getT());

        order.add();
        List<Boolean> list = order.list;
        System.out.println(list);

        SubOrder o = new SubOrder();
        List<Integer> list1 = o.list;
        System.out.println(list1);

        // 通过对象调用泛型方法时，指明泛型方法的类型
        Integer i = order.getE(23);
        double d = order.getE(3.8);

        Integer[] in = new Integer[] { 1, 12, 3, 3 };
        List<Integer> list2 = new ArrayList<Integer>();
        List<Integer> list3 = order.fromArrayToList(in, list2);
        System.out.println(list3);
    }
}

Order<T>

package com.aff.Gen;

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

public class Order<T> {
    private String orderName;
    private int orderId;
    private T t;
    List<T> list = new ArrayList<T>();

    public void add() {
        list.add(t);
    }

    // 实现数组到集合的复制
    public <E> List<E> fromArrayToList(E[] e, List<E> list) {
        for (E e1 : e) {// 数组
            list.add(e1);// 数组到集合
        }
        return list;
    }

    // 声明泛型方法
    public <E> E getE(E e) {
        return e;
    }

    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 getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Order [orderName=" + orderName + ", orderId=" + orderId + ", t=" + t + ", list=" + list + "]";
    }
}

// 在继承泛型类或者泛型接口时，可以指明泛型的类型
class SubOrder extends Order<Integer> {

}