1、什么是泛型？
泛型（Generics）是把類型參數化，運用于類、接口、方法中，在調用時傳入具體的類型。

泛型就是參數化類型

適用于多種數據類型執行相同的代碼

泛型的類型在使用時指定

泛型歸根到底就是“模板”

優點：使用泛型時，在實際使用之前類型就已經確定了，不需要強制類型轉換。

操作的數據類型被指定為一個參數，這種參數類型可以用在類、接口和方法中，分別被稱為泛型類、泛型接口、泛型方法。
?

2、泛型的使用場景

2.1 用于集合

/*** 運用于集合中*/ public class Demo01 {//不使用泛型，直接存取數據public static void test01() {List list = new ArrayList();list.add("001");list.add(100);Object o1 = list.get(1);if(o1 instanceof Integer) {//如果不判斷類型，直接強轉Integer，則運行時可能直接拋出異常o1 = (Integer)o1;}System.out.println(o1);}public static void test02() {List<Integer> list = new ArrayList<Integer>();//list.add("001"); 放數據時進行安全檢查，"001"不是Integer類型，編譯不通過list.add(100);System.out.println(list.get(0));}public static void main(String[] args) {test01();test02();} }

2.2 自定義泛型

泛型字母

形式類型參數（formal type parameters）即泛型字母

命名泛型字母可以隨意指定，盡量使用大寫字母（多個參數時，在字母后加數字，例T1，T2）

常見字母：T(Type)，K V (Key Value)，E(Element)

?泛型類

• 只能用在成員變量上，只能使用引用類型

泛型接口

• 只能用在抽象方法上

泛型方法

• 返回值前加<T>

?

自定義泛型類

/*** 自定義泛型類* @param <T>*/ class Student<T> {private T prop;public T getProp() {return prop;}public void setProp(T prop) {this.prop = prop;}@Overridepublic String toString() {return "Student [prop=" + prop + "]";} }public class Demo02 {public static void main(String[] args) {//Student<int> s = new Student<int>(); 不能為基本類型，會編譯報錯Student<Integer> student = new Student<Integer>();student.setProp(18);//輸出：Student [prop=18]System.out.println(student);} }

自定義泛型接口

/*** 自定義泛型接口* 接口中泛型字母只能使用在方法中，不能使用在全局常量中* @param <T>*/ public interface Comparator<T1, T2> {//public static T1 param; 靜態類型不能引用非靜態的參數，會編譯報錯void compare(T1 t1);T2 compare();public abstract T1 compare2(T2 t2); }

?非泛型類里定義泛型方法

/*** 非泛型類里定義泛型方法*/ public class Demo03 {public static<T> void test01(T t) {System.out.println(t);}public static<T extends List> void test02(T t) {t.add("sdfs");System.out.println(t);}public static <T extends Object> void test03(T ...l) {for(T t:l) {System.out.println(t);}}public static void main(String[] args) {//泛型參數test01("01");//泛型的繼承test02(new ArrayList<Integer>());//可變參數test03(new ArrayList<Integer>(), new ArrayList<String>());}}

泛型類的繼承

abstract class Father<T1, T2> {T1 age;public abstract void makeFriend(T2 t); }/*** 父類泛型完全保留*/ class Child1<T1, T2> extends Father<T1, T2> {@Overridepublic void makeFriend(T2 t) {System.out.println("My attr: "+age+" &T2="+t);System.out.println("I am "+getClass().getName()+", let`s be friend.");} }/*** 父類泛型部分保留*/ class Child2<T1> extends Father<T1, Integer> {@Overridepublic void makeFriend(Integer t) {System.out.println("My attr: "+age+" &T2="+t);System.out.println("I am "+getClass().getName()+", let`s be friend.");} }/*** 父類泛型不保留，子類按需實現*/ class Child3 extends Father<Integer, String> {@Overridepublic void makeFriend(String t) {System.out.println("My attr: "+age+" &T2="+t);System.out.println("I am "+getClass().getName()+", let`s be friend.");} }/*** 沒有具體類型* 泛型擦除，繼承父類的子類，沒有指定類型，默認為Object*/ @SuppressWarnings("rawtypes") class Child4 extends Father {@Overridepublic void makeFriend(Object t) {System.out.println("My attr: "+age+" &T2="+t);System.out.println("I am "+getClass().getName()+", let`s be friend.");} }public class Demo03 {public static void main(String[] args) {new Child1().makeFriend("1");new Child2().makeFriend(1);new Child3().makeFriend("1");new Child4().makeFriend("1");} } /*** 類型擦除*/ public class Demo03 {public static void test01(Student<Integer> student) {student.setProp(18);System.out.println(student);}public static void main(String[] args) {Student student = new Student();//輸出：Student [prop=18]test01(student);Student<String> s2 = new Student<String>();//編譯報錯，參數不匹配//test01(s2);} }

通配符

通配符（Wildcards）

T、K、V、E 等泛型字母為有類型，類型參數賦予具體的值

？未知類型 類型參數賦予不確定值，任意類型

只能用在聲明類型、方法參數上，不能用在定義泛型類上

/*** 泛型的通配符，類型不確定，用于變量聲明或者形參上面* 不能用在類上或者對象創建上*/ public class Demo03 {public static<T> void test01(Student<T> student) {//編譯報錯：不能轉換 Student<Integer> 為 Student<T>//student = new Student<Integer>();//student = new Student<String>();//student = new Student<BigDecimal>();System.out.println(student);}public static void test02(Student<?> student) {//?號代表類型參數不確定，下面代碼可以執行student = new Student<Integer>();student = new Student<String>();student = new Student<BigDecimal>();System.out.println(student);}public static void main(String[] args) {Student student = new Student();//輸出：Student [prop=null]test02(student);} }

extends/super

上限（extends）
指定的類必須是繼承某個類，或者實現了某個接口（不是implements），即<=

• ? extends List

下限（super）

即父類或本身

• ？ super List

/*** extends:泛型的上限 <= 一般用于限制操作 不能使用在添加數據上，一般都是用于數據的讀取* supper:泛型的上限 >= 即父類或自身。一般用于下限操作*/ public class Demo03<T extends Fruit> {public static void test01() {Demo03<Fruit> t1 = new Demo03<Fruit>();Demo03<Apple> t2 = new Demo03<Apple>();//編譯報錯：類型轉換失敗//Demo03<Fruit> t3 = new Demo03<Apple>();}public static void test02(List<? extends Fruit> list) {//編譯報錯//list.add(new Fruit());//list.add(new Object());}public static void test03(List<? super Apple> list) {//可以編譯通過list.add(new Apple());list.add(new RedApple());//編譯報錯//list.add(new Fruit());}}

泛型嵌套

/*** 泛型嵌套**/ public class Demo05 {public static void main(String[] args) {Student2<String> student = new Student2<String>();student.setScore("優秀");System.out.println(student.getScore());//泛型嵌套School<Student2<String>> school = new School<Student2<String>>();school.setStu(student);String s = school.getStu().getScore(); //從外向里取System.out.println(s);// hashmap 使用了泛型的嵌套Map<String, String> map = new HashMap<String,String>();map.put("a", "張三");map.put("b", "李四");Set<Entry<String, String>> set = map.entrySet();for (Entry<String, String> entry : set) {System.out.println(entry.getKey()+":"+entry.getValue());}} }public class School<T> {private T stu;public T getStu() {return stu;}public void setStu(T stu) {this.stu = stu;}}public class Student2<T> {T score;public T getScore() {return score;}public void setScore(T score) {this.score = score;} }

其他（數組）

import java.util.ArrayList; import java.util.List;/*** 泛型沒有多態* 泛型沒有數組* JDK1.7對泛型的簡化* @author Administrator**/ public class Demo06 {public static void main(String[] args) {Fruit fruit = new Apple(); // 多態，父類的引用指向子類的對象//List<Fruit> list = new ArrayList<Apple>(); //泛型沒有多態 List<? extends Fruit> list = new ArrayList<Apple>();//泛型沒有數組//Fruit<String>[] fruits = new Fruit<String>[10];//ArrayList底層是一個Object[],它放數據的時候直接放，取數據的時候強制類型轉化為泛型類型/*public boolean add(E e) {ensureCapacityInternal(size + 1); // Increments modCount!!elementData[size++] = e;return true;}*//*E elementData(int index) {return (E) elementData[index];}*///JDK1.7泛型的簡化,1.6編譯通不過List<Fruit> list2 = new ArrayList<>();} }

參考：

https://segmentfault.com/a/1190000014824002?utm_source=tag-newest

http://www.importnew.com/tag/%E6%B3%9B%E5%9E%8B

?

總結

以上是生活随笔為你收集整理的Java -- 泛型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。