Java泛型及通配符

Java泛型

一直在项目中使用泛型，但对它的概念很模糊，查看了些资料，做个总结，供以后参考。
泛型的核心思想（以下结论以集合为例）：把一个集合的内容限制为一个特定的数据类型，这就是generics背后的核心思想。

泛型类或接口的申明

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

/**
 * =============================================
 * 作    者：Junl
 * 版    本：1.0
 * 创建日期：2017/5/17
 * 描    述：
 * 文艺青年：人生若只如初见，何事秋风悲画扇。
 * =============================================
 */

public class Order<T> {

    private String name;
    private int age;
    private T t;
    ArrayList<T> list = new ArrayList<>();

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public T getT() {
        return t;
    }

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


    /**
     * 泛型方法  泛型方法 类型<E> 跟 泛型类<T> 类型不是同一个类型
     * @return
     */
    public <E> E getE(E e) {
        return e;
    }

    /**
     * 泛型方法  将Array ----> List
     * @param e
     * @param list
     * @param <E>
     * @return
     */
    public <E> List<E> getArray2List(E[] e, List<E> list) {
        for (E e1 : e) {
            list.add(e1);
        }
        return list;
    }

    @Override
    public String toString() {
        return "Order{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", t=" + t +
                ", list=" + list +
                '}';
    }
}

/**
 * 继承泛型类或泛型接口时，可以指明泛型类型
 *
 * DAO:datebase access object:数据库访问对象  即通过java程序访问数据库中的数据，将结果通过对象形式返回。泛型  在实例化的时候需要指明类型
 */
class SubOrder extends Order<Integer> {

}

测试类

import org.junit.Before;
import org.junit.Test;

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



/**
 * =============================================
 * 作    者：Junl
 * 版    本：1.0
 * 创建日期：2017/5/17
 * 描    述：单元测试自动生成类，在该类方法中，写入需要测试的代码，点击类名CalculatorTest 运行 或者直接点击方法名运行，查看控制台输出结果
 * 文艺青年：人生若只如初见，何事秋风悲画扇。
 * @link :http://www.jianshu.com/p/03118c11c199
 * =============================================
 */
public class CalculatorTest {


    @Before
    public void setUp() throws Exception {

    }

    /**
     * Map集合的遍历
     * @throws Exception
     */
    @Test
    public void substract() throws Exception {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "junl");
        map.put(2, "xiaoliang");
        map.put(3, "liangliang");

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

    /**
     * foreach 循环
     * @throws Exception
     */
    @Test
    public void divide() throws Exception {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("junl");
        list.add("!");
        for (String temp : list) {
            System.out.print(temp);
        }

    }


    /**
     * 泛型  在实例化的时候需要指明类型
     * 泛型的核心思想：把一个集合的内容限制为一个特定的数据类型，这就是generics背后的核心思想
     * 1、静态方法/catch中，不能使用类的泛型
     * 2、如泛型类是接口或者抽象类，则不能创建泛型类的对象(接口和抽象类不可实例化)
     * 3、从泛型类派生出子类，泛型类型需具体化
     *
     * @throws Exception
     */
    @Test
    public void multiply() throws Exception {
        Order<Integer> order = new Order<>();
        //调用成员变量方法
        order.setT(123);
        ArrayList<Integer> list = order.list;
        order.add();
        System.out.println(list.toString());

        //调用泛型方法<传递参数是什么类型，输出什么类型的结果>
        String e = order.getE("泛型方法");
        System.out.println(e);

        Boolean[] bo = {true, false, true, false};
        ArrayList<Boolean> li = new ArrayList<>();
        //将数组转换为集合
        List array2List = order.getArray2List(bo, li);
        System.out.println(array2List);
    }

    /**
     * 通配符 ？
     * List<A> 、List<B> ...都是List<?>的子类
     *
     * ? extends E :表示可以存放E及其子类
     * ? super E :表示可以存放E及其父类
     *
     * @throws Exception
     */
    @Test
    public void test1() throws Exception {
        List<?> list = null;

        List<Object> list1 = new ArrayList<>();
        list1.add(true);
        list1.add(123);
        list = list1;
        show(list);//可以读取读取申明为通配符的集合类的对象

        List<String> list2 = new ArrayList<>();
        list2.add("Hello World");
        list = list2;
        show(list);


        //通配符   ? extends E :表示可以存放E及其子类
        List<? extends Number> list3 = null;
        List<Integer> list4 = new ArrayList<>();
        list3 = list4;

        //通配符 ? super E :表示可以存放E及其父类
        List<? super String> list5 = null;
        list5 = list2;
    }

    /**
     * 可以读取读取申明为通配符的集合类的对象  但不允许向申明通配符的集合中写入对象 （null除外）
     * @param collection
     */
    public void show(Collection<?> collection) {
        Iterator<?> iterator = collection.iterator();//Iterator<E> iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

使用泛型需注意

• 静态方法或catch中不能使用泛型
• 如泛型类是接口或者抽象类，则不能创建泛型类的对象(接口和抽象类不可实例化)
• 从泛型类派生出子类，泛型类型需具体化