什麼是泛型

什麼是泛型爲何要使用泛型

泛型就是參數化類型

泛型的做用

減小重複代碼

像dao接口中存在樣式雷同的代碼： EmpDao： package com.aaa.gen.dao; import com.aaa.gen.entity.Emp; import java.util.List; /** * 員工管理dao接口 DetpDao： */
public interface EmpDao { /** * 查詢全部的員工信息 * @return
*/
public List<Emp> listAll(); /** * 保存員工信息 * @param emp * @return
*/
public int save(Emp emp); /** * 刪除員工信息 * @param emp * @return
*/
public int delete(Emp emp); /** * 修改員工信息 * @param emp * @return
*/
public int update(Emp emp); /** * 根據主鍵查詢 員工的信息 * @param id * @return
*/
public Emp find(Long id); } package com.aaa.gen.dao; import com.aaa.gen.entity.Dept; import java.util.List; /** * 部門管理dao接口 */
public interface DeptDao { /** 有這麼 多重複代碼，確定是很差的，咱們應該使用一種範式提取出來。咱們能夠定義一個公共的BaseDao接口來 解決這種問題: * 查詢全部的部門信息 * @return
*/
public List<Dept> listAll(); /** * 保存部門信息 * @param dept * @return
*/
public int save(Dept dept); /** * 刪除部門信息 * @param dept * @return
*/
public int delete(Dept dept); /** * 修改部門信息 * @param dept * @return
*/
public int update(Dept dept); /** * 根據主鍵查詢 部門的信息 * @param id * @return
*/
public Dept find(Long id); } package com.aaa.gen.common; import com.aaa.gen.entity.Dept; import java.util.List; public interface BaseDao<T> { /** * 查詢全部的實體信息 * @return
*/
public List<T> listAll(); 而後針對某個特定多的接口好比EmpDao，咱們可讓EmpDao繼承BaseDao接口，同時指定泛型的類型: 幫助咱們提早發現一些程序的錯誤 /** * 保存實體信息 * @param t * @return
*/
public int save(T t); /** * 刪除實體信息 * @param t * @return
*/
public int delete(T t); /** * 修改實體信息 * @param t * @return
*/
public int update(T t); /** * 根據主鍵查詢 實體的信息 * @param id * @return
*/
public T find(Long id); } package com.aaa.gen.dao; import com.aaa.gen.common.BaseDao; import com.aaa.gen.entity.Emp; import java.util.List; /** * 員工管理dao接口 */
public interface EmpDao extends BaseDao<Emp> { }

幫助咱們提早發現一些程序的錯誤 package com.aaa.gen.test; import java.util.ArrayList; import java.util.List;定義泛型接口或者類 定義泛型接口 泛型接口在被實現的時候，若是實現類再也不須要泛型，則須要指定泛型的具體類型： /** * 測試泛型 */
public class Test01 { /** * 打印list中全部的內容 */
public static void printList(List<String> list){ for(int i=0;i<list.size();i++){ String str = list.get(i); System.out.println(str); } } public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("Java"); list.add("C#"); list.add("python"); list.add(123); Test01.printList(list); } } package com.aaa.gen; /** * 定義泛型接口list * 在接口後面使用<>表示，在<>能夠定義泛型的形參，通常形參都使用單獨的一個大寫字母來表示 * 多個髮型的形參用逗號進行間隔 常常用的泛型的標識有T E * */
public interface List<T> { /** * 迭代元素 * @param t */
public void iterator(T t); }若是實現類繼續使用泛型，則能夠不指定泛型的具體類型： 定義泛型類 package com.aaa.gen; /** * 若是實現類中再也不使用泛型，則須要指定泛型的具體類型 */
public class ArrayList implements List<String> { @Override public void iterator(String s) { } } package com.aaa.gen; /** * 實現類中若是繼續使用泛型 ，則沒必要指定泛型的具體類型 * @param <T> */
public class LinkedList<T> implements List<T>{ @Override public void iterator(T t) { } } package com.aaa.gen; /** * 泛型類 */
public class Apple<T> { //聲明泛型變量info
private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; } }在使用的時候： 泛型通配符 需求：定義一個類，類中須要有打印一個字符串集合中的全部元素的方法，還須要有打印一個整數集合中的全部元 素的方法 package com.aaa.gen.test; import com.aaa.gen.Apple; /** * 測試泛型類 */
public class Test02 { public static void main(String[] args) { Apple<String> apple= new Apple<String>()apple.setInfo("紅色"); System.out.println(apple.getInfo()); Apple<Integer> apple2= new Apple<Integer>(); apple2.setInfo(10); System.out.println(apple2.getInfo()); } } package com.aaa.gen.test; import java.util.List; public class Test03 { /** * 打印字符串集合中的全部的元素 * @param list */
public void printStr(List<String> list){ for(String str : list){ System.out.println(str); } } /** * 打印整數集合中的全部的元素 * @param list */
public void printInt(List<Integer> list){ for(Integer num :list){ System.out.println(num); } }咱們發現全部打印的方法的代碼結構上都是相似的，打印每種類型的變量的集合都須要再定義一個方法，這樣作非 常麻煩，有沒有一個通用的方法能夠解決這個問題？ 咱們經過泛型通配符來解決這個問題，java提供一個方案，List 不是全部List<其餘類型>的父類，可是List<?>能夠 理解爲全部List<其餘類型>的父類： /** * 打印小數集合中的全部的元素 * @param list */
public void printDouble(List<Double> list){ for(Double num :list){ System.out.println(num); } } } package com.aaa.gen.test; import java.util.ArrayList; import java.util.List; /** * 使用List<Object>來代替List<String>List<Double> List<Integer> */
public class Test04 { /** * 打印全部的object對象 * @param list */
public void print(List<Object> list){ for(Object obj : list){ System.out.println(obj); } } public static void main(String[] args) { List<String> strList = new ArrayList<String>(); strList.add("java"); strList.add("c#"); //String 是Object的子類，可是List<String> 仍是不是List<Object>的子類了？不是了 //咱們仍是但願List<Object>是List<String>或者是List<其餘類型>的父類
new Test04().print(strList); } }泛型通配符上限 需求：聲明一個方法，打印全部數字類型的集合中的元素 package com.aaa.gen.test; import java.util.ArrayList; import java.util.List; /** * 使用List<?>來代替List<Object> */
public class Test05 { /** * 打印全部的object對象 * @param list */
public static void print(List<?> list){ for(Object obj : list){ System.out.println(obj); } } public static void main(String[] args) { List<String> strList = new ArrayList<String>(); strList.add("java"); strList.add("c#"); //能夠理解爲List<?>是全部List<其餘類型>的父類
new Test05().print(strList); List<Integer> intList = new ArrayList<Integer>(); intList.add(1); intList.add(2); //能夠理解爲List<?>是全部List<其餘類型>的父類
new Test05().print(intList); } } package com.aaa.gen.test; import java.util.ArrayList; import java.util.List; /** * 泛型通配符上限 */
public class Test06 { /** * 打印全部的數字類型集合中的元泛型方法 原先在使用泛型的時候，只把泛型定義在了類上或者接口上。泛型也能夠只在一個方法上來使用。 舉例：聲明一個泛型方法 合併兩個list集合中的元素 * @param list */
public void printNum(List<? extends Number> list){ for(Number n : list){ System.out.println(n); } } public static void main(String[] args) { List<Integer> inStrs = new ArrayList<Integer>(); inStrs.add(1); inStrs.add(2); //同List<Object>不是List<其餘類型>的父類同樣，List<Number>也不是List<Number的子類>的父類 //若是要解決這種問題，就須要用到泛型通配符上限
new Test06().printNum(inStrs); List<Double> doStrs = new ArrayList<Double>(); doStrs.add(1D); doStrs.add(2D); new Test06().printNum(doStrs); List<String> strs = new ArrayList<String>(); strs.add("abc"); strs.add("def"); new Test06().printNum(strs); } } package com.aaa.gen.test; import java.util.ArrayList; import java.util.List; /** * 泛型方法 */
public class Test07 { /** * 合併兩個list集合 * @param a * @param b */
/* public static void join(List<String> a , List<String> b){ for(String item :a){ b.add(item); } }*/問題，若是b中的泛型類型聲明成Object會報錯： public static <T> void join(List<T> a , List<T> b){ for(T item :a){ b.add(item); } System.out.println(b); } public static void main(String[] args) { List<String> a = new ArrayList<String>(); a.add("1"); a.add("2"); List<String> b = new ArrayList<String>(); b.add("3"); Test07.join(a,b); List<Integer> a1 = new ArrayList<Integer>(); a1.add(1); a1.add(2); List<Integer> b1 = new ArrayList<Integer>(); b1.add(3); Test07.join(a1,b1); } }怎麼在不把Object改爲String的前提下解決這種問題？泛型通配符下限 需求：要返回最後一個添加的元素 怎麼樣修改方法才能讓返回值變成添加元素時的類型？ package com.aaa.gen.test; import java.util.ArrayList; import java.util.List; /** * 泛型方法 髮型通配符下限 */
public class Test08 { /** * 合併兩個list集合 返回最後一個添加的元* @param a * @param b */
/* public static void join(List<String> a , List<String> b){ for(String item :a){ b.add(item); } }*/
public static <T> T join(List<? extends T> a , List<T> b){ T last = null; for(T item :a){ last = item; b.add(item); } System.out.println(b); return last; } public static void main(String[] args) { List<String> a = new ArrayList<String>(); a.add("1"); a.add("2"); a.add("3"); List<Object> b = new ArrayList<Object>()//返回值是什麼類型，原先放置的時候類型是String類型，如今還能不能用String類型來接收返回值了？
Object last = Test08.join(a,b); } } package com.aaa.gen.test;擦除 把一個具備泛型信息的變量賦值給一個沒有泛型信息的變量，泛型的信息會消失，這就叫作擦除。 import java.util.ArrayList; import java.util.List; /** * 泛型方法 髮型通配符下限 */
public class Test08 { /** * 合併兩個list集合 返回最後一個添加的元* @param a * @param b */
/* public static void join(List<String> a , List<String> b){ for(String item :a){ b.add(item); } }*/
public static <T> T join(List<T> a , List<? super T> b){ T last = null; for(T item :a){ last = item; b.add(item); } System.out.println(b); return last; } public static void main(String[] args) { List<String> a = new ArrayList<String>(); a.add("1"); a.add("2"); a.add("3"); List<Object> b = new ArrayList<Object>()//返回值是什麼類型，原先放置的時候類型是String類型，如今還能不能用String類型來接收返回值了？ // Object last = Test08.join(a,b); //怎麼樣修改方法才能讓返回值變成添加元素時的類型
String last = Test08.join(a,b); } } package com.aaa.gen; /** * 泛型類 */
public class Apple<T> {測試： //聲明泛型變量info
private T info; public T getInfo() { return info; } public void setInfo(T info) { this.info = info; } } package com.aaa.gen.test; import com.aaa.gen.Apple; /** * 擦除 */
public class Test09 { public static void main(String[] args) { Apple<String> a1 = new Apple<String>(); a1.setInfo("紅色"); String info = a1.getInfo(); //把一個具備泛型信息的變量賦值給一個沒有泛型信息的變量
Apple a2=a1; //泛型類型信息會消失
Object info1 = a2.getInfo(); } }