一文入門Java之【泛型】

一、什麼是泛型

所謂泛型，就是允許在定義類、接口時通過一個標識表示類中某個屬性的類型或者是某個方法的返回值及參數類型。這個類型參數將在使用時。
例如：繼承或實現這個接口，用這個類型聲明變量、創建對象時確定（即傳入實際的類型參數，也稱爲類型實參）。
Collection< E >，List< E >，ArrayList< E > 這個< E >就是類型參數，即泛型。

二、爲什麼要使用泛型

使用ArrayList保存數據，由於可以存入Object類型的數據，若存入多種類型的數據會，取出數據時容易出現ClassCastException。

ArrayList不指定泛型

@Test
    public void test1(){
        ArrayList list = new ArrayList();
        // 存數據
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        //意外存入其他類型數據,取出數據會出現ClassCastException
//        list.add("aaa");
        // 取數據,需要進行強制類型轉換,有機率出現ClassCastException
        for (Object o : list){
            int num = (Integer)o;
            System.out.println(num);
        }
    }

存入多種類型的數據運行結果

三、怎樣使用泛型

先解決上述問題
爲了解決可以存入Object，使用泛型可以規定存入數據的類型，有效的規避了由於存入各式各樣的數據類型導致取出數據時需要的強制類型轉換，容易出現ClassCastException的問題。

1. 集合使用泛型

ArrayList使用泛型

若指定泛型，則不能存入非泛型指定類型的數據。

    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        // 存數據
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        //意外存入其他類型數據,則編譯報錯
//        list.add("aaa");
        // 取數據無需要進行強制類型轉換
        for (int o : list){
            System.out.println(o);
        }
    }

Map使用泛型

@Test
    public void test3() {
        //jdk7新特性：類型推斷
        Map<String, Integer> map = new HashMap<>();
        //存入數據
        map.put("a", 97);
        map.put("b", 98);
        map.put("c", 99);

        //泛型可嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        //取出數據
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next = iterator.next();
            String key = next.getKey();
            Integer value = next.getValue();
            System.out.println(key + " = " + value);
        }
    }

2. 自定義泛型類、泛型接口、泛型方法

使用泛型可以有效的實際模板

例如SSM框架中的dao層與service層

dao層模板 - 泛型接口

BaseDao<T>

package com.aaa.generic.dao;

import java.util.List;

public interface BaseDao<T>
{
	void add(T entity);
	void upd(T entity);
	void del(T entity);
	T findOne(T entity);
	List<T> find();
	//泛型方法
	<E> E getValue();
}

service層模板 - 泛型類

BaseService<T>

package com.aaa.generic.service;

import com.aaa.generic.dao.BaseDao;

import java.util.List;

/**
 * 模板模式
 * @param <T>
 */
public abstract class BaseService<T>
{
	public abstract BaseDao<T> getDao();
	public void add(T entity)
	{
		getDao().add(entity);
	}
	public void upd(T entity)
	{
		getDao().upd(entity);
	}
	public void del(T entity)
	{
		getDao().del(entity);
	}
	public T findOne(T entity)
	{
		return getDao().findOne(entity);
	}
	public List<T> find()
	{
		return getDao().find();
	}
	public <E> E getValue(){
		return getDao().getValue();
	}
}

dao層實現

ClazzDao

package com.aaa.generic.dao;

import com.aaa.generic.entity.Clazz;
import java.util.List;

public class ClazzDao implements BaseDao<Clazz>
{
	@Override
	public void add(Clazz entity)
	{
		// TODO Auto-generated method stub
	}

	@Override
	public void upd(Clazz entity)
	{
		// TODO Auto-generated method stub
	}

	@Override
	public void del(Clazz entity)
	{
		// TODO Auto-generated method stub
	}

	@Override public Clazz findOne(Clazz entity) {
		return null;
	}

	@Override
	public List<Clazz> find()
	{
		// TODO Auto-generated method stub
		return null;
	}
	@Override public <E> E getValue() {
        return null;
    }
}

service層實現

ClazzService

package com.aaa.generic.service;

import com.aaa.generic.dao.BaseDao;
import com.aaa.generic.dao.ClazzDao;
import com.aaa.generic.entity.Clazz;

public class ClazzService extends BaseService<Clazz>
{
//	@Autowired
	ClazzDao cdao;
	@Override
	public BaseDao<Clazz> getDao()
	{
		return cdao;
	}
}

注意

1. 如果定義了泛型類，實例化沒指明類的泛型，則認爲此泛型類型爲Object類型。
2. 若定義的類是帶泛型的，建議在實例化時要指明類的泛型。
3. 子類在繼承帶泛型的父類時，指明瞭泛型類型。則實例化子類對象時，不再需要指明泛型。
4. 泛型類可能有多個參數，多個參數應一起放在<>中，例：<String,Integer>。
5. 泛型類的構造器：public GenericClass(){} ， 無需指定泛型。
6. jdk1.7 泛型可簡寫：ArrayList<String> list = new ArrayList<>();。
7. 泛型中不能使用基本數據類型(八大數據類型)，使用包裝類進行替換。
8. 靜態方法中不能使用類的泛型。
9. 異常類不能是泛型。
10. 不能使用new E[] 。可以E[] ele = (E[]) new Object[capacity];
11. 父類有泛型時，子類可指定或保留父類的泛型，也可以增加自己的泛型。

四、通配符：?

1.集合使用通配符的基本使用

注意

1. 對於List<?>就不能向其內部添加數據。可添加null;
2. 讀取的數據類型爲Object

@Test public void test1() {
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;

        list = list1;
        list = list2;

        //編譯失敗
//        list1 = list;
//        list2 = list;

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;

        //添加(寫入)：對於List<?>就不能向其內部添加數據。可添加null;
//        list.add("aaa"); 編譯錯誤
        list.add(null);

        //讀取 讀取的數據類型爲Object
        Object o = list.get(0);
        System.out.println(o);

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

2.有限制條件的通配符的使用

? extends A: G<? extends A> 可以作爲G< A >和G< B >的父類，其中B是A的子類
? super A:G<? super A> 可以作爲G< A >和G< B >的父類，其中B是A的父類

List<? extends Number> list1 = null;
List<? super Number> list2 = null;