|
泛型在java中有很重要的地位，在面向?qū)ο缶幊碳案鞣N設(shè)計模式中有非常廣泛的應(yīng)用。 一句話解釋什么是泛型？泛型是相關(guān)語言特性的集合，它允許 引入泛型之前泛型在Java集合框架中被廣泛使用,我們不使用泛型,那么代碼將會是這樣: List doubleList = new LinkedList(); doubleList.add(3.5D); Double d = (Double) doubleList.iterator().next(); //類型強(qiáng)制轉(zhuǎn)換 doubleList中存儲一個Double類型的值, 但是List并不能阻止我們往里面再添加一個String類型 比如:doubleList.add (“ Hello world ”); 最后一行的(Double)強(qiáng)制轉(zhuǎn)換操作符將導(dǎo)致在遇到非 Double 對象時拋出 ClassCastException 引入泛型之后因為直到運行時才檢測到類型安全性的缺失，所以開發(fā)人員可能不會意識到這個問題，將其留給客戶機(jī)(而不是編譯器)來發(fā)現(xiàn)。泛型允許開發(fā)人員將List標(biāo)記為只包含 Double 對象，從而幫助編譯器提醒開發(fā)人員在列表中存儲非 Double 類型的對象的問題,在編譯和開發(fā)期間,就把問題解決掉 我們可以這樣改造上面的代碼: List<Double> doubleList = new LinkedList<Double>(); doubleList.add(3.5D); Double d = doubleList.iterator().next(); 這時 我們再添加String類型的參數(shù) 會提示需要的類型不符合需求.
深入探索泛型類泛型的概念泛型是通過
一提到參數(shù)，最熟悉的就是定義方法時有形參，然后調(diào)用此方法時傳遞實參。那么參數(shù)化類型怎么理解呢？顧名思義，就是將類型由原來的具體的類型參數(shù)化，類似于方法中的變量參數(shù)，此時類型也定義成參數(shù)形式（可以稱之為類型形參），然后在使用/調(diào)用時傳入具體的類型（類型實參）。 泛型的本質(zhì)是為了參數(shù)化類型（在不創(chuàng)建新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的數(shù)據(jù)類型被指定為一個參數(shù)，這種參數(shù)類型可以用在類、接口和方法中，分別被稱為泛型類、泛型接口、泛型方法。 泛型類型遵循語法泛型類型遵循以下語法: class identifier<formalTypeParameterList>{
}
interface identifier<formalTypeParameterList>{
}
interface Map<K,V> {//多個用逗號分隔
}類型參數(shù)命名原則Java 編程約定要求類型參數(shù)名稱為單個大寫字母，例如 E 表示元素，K 表示鍵，V 表示值，T 表示類型。避免使用像A,B,C這樣沒有意義的名稱。 List < E > 表示一個元素列表，但是 List < B > 的意思是什么呢？ 實際類型參數(shù) 替換 類型參數(shù)泛型的 JAVA支持的實際類型的參數(shù)有哪些
class Container<E> {
Set<E> elements; //E傳給E
}
例: List < Student > ,
例: Set < List < Shape > >,
例: Map < String, String[] >,
例: Class < ? > , ? 傳給T 聲明和使用泛型泛型的聲明涉及到指定形式類型參數(shù)列表，并在整個實現(xiàn)過程中訪問這些類型參數(shù)。使用泛型時需要在實例化泛型時將實際類型參數(shù)傳遞給類型參數(shù) 定義泛型的例子在本例子中,我們實現(xiàn)一個簡易的容器Container,該容器類型存儲相應(yīng)參數(shù)類型的對象,使其能夠存儲各種類型 class Container<E> //也可以使用實際類型的參數(shù)
{
private E[] elements;
private int index;
Container(int size)
{
elements = (E[]) new Object[size];
//本例中我們傳入的是String,將Object[]轉(zhuǎn)化為String[]返回
index = 0;
}
void add(E element)
{
elements[index++] = element;
}
E get(int index)
{
return elements[index];
}
int size()
{
return index;
}
}
public class GenDemo
{
public static void main(String[] args)
{
Container<String> con = new Container<String>(5);//使用String傳給E,指定E為String類型的
con.add("North");
con.add("South");
con.add("East");
con.add("West");
for (int i = 0; i < con.size(); i++)
System.out.println(con.get(i));
}
}指定類型參數(shù)的泛型Container < E > 中的 E 為無界類型參數(shù),通俗的講就是什么類型都可以,可以將任何實際的類型參數(shù)傳遞給 E 通過指定上限來限制傳入的類但是有時你想限制類型,比如你想 < E > 只接受 Employee 及其子類 class Employees<E extends Employee> 此時傳入的E 必須為 Employee子類, new Employees< String > 是無效的. 指定多個類型限制當(dāng)然我們還可以為一個類指定多個類型 使用&分隔 : abstract class Employee
{
private BigDecimal hourlySalary;
private String name;
Employee(String name, BigDecimal hourlySalary)
{
this.name = name;
this.hourlySalary = hourlySalary;
}
public BigDecimal getHourlySalary()
{
return hourlySalary;
}
public String getName()
{
return name;
}
public String toString()
{
return name + ": " + hourlySalary.toString();
}
}
class Accountant extends Employee implements Comparable<Accountant>
/*
Comparable < Accountant > 表明Accountant可以按照自然順序進(jìn)行比較
Comparable 接口聲明為泛型類型，只有一個名為 t 的類型參數(shù)。
這個接口提供了一個 int compareTo (t o)方法，該方法將當(dāng)前對象與參數(shù)(類型為 t)進(jìn)行比較，
當(dāng)該對象小于、等于或大于指定對象時返回負(fù)整數(shù)、零或正整數(shù)。
*/
{
Accountant(String name, BigDecimal hourlySalary)
{
super(name, hourlySalary);
}
public int compareTo(Accountant acct)
{
return getHourlySalary().compareTo(acct.getHourlySalary());
}
}
class SortedEmployees<E extends Employee & Comparable<E>>
//第一個必須為class 之后的必須為interface
{
private E[] employees;
private int index;
@SuppressWarnings("unchecked")
SortedEmployees(int size)
{
employees = (E[]) new Employee[size];
int index = 0;
}
void add(E emp)
{
employees[index++] = emp;
Arrays.sort(employees, 0, index);
}
E get(int index)
{
return employees[index];
}
int size()
{
return index;
}
}
public class GenDemo
{
public static void main(String[] args)
{
SortedEmployees<Accountant> se = new SortedEmployees<Accountant>(10);
se.add(new Accountant("John Doe", new BigDecimal("35.40")));
se.add(new Accountant("George Smith", new BigDecimal("15.20")));
se.add(new Accountant("Jane Jones", new BigDecimal("25.60")));
for (int i = 0; i < se.size(); i++)
System.out.println(se.get(i));
}
}下界和泛型參數(shù)假設(shè)你想要打印出一個對象列表 class Scratch_12{
public static void main(String[] args) {
{
List<String> directions = new ArrayList();
directions.add("north");
directions.add("south");
directions.add("east");
directions.add("west");
printList(directions);
List<Integer> grades = new ArrayList();
grades.add(new Integer(98));
grades.add(new Integer(63));
grades.add(new Integer(87));
printList(grades);
}
}
static void printList(List<Object> list)
{
Iterator<Object> iter = list.iterator();
while (iter.hasNext())
System.out.println(iter.next());
}
}這個例子看似是合乎邏輯的,我們想通過將 List < object > 類型的對象傳遞給 printList ()方法，防止類型安全的這種沖突。然而，這樣做并不是很有用。實際上編譯器已經(jīng)報出錯誤了,它告訴我們不能將字符串列表轉(zhuǎn)換為對象列表
為什么會報這個錯呢? 這和泛型的基本規(guī)則有關(guān):
根據(jù)這個規(guī)則，盡管 String 和 Integer 是 java.lang.Object 的子類,但是List < string > 和 List < integer > 是 List < Object > 的子類就不對了. 為什么我們有這個規(guī)則？因為泛型的設(shè)計是為了在編譯時捕獲類型安全違規(guī)行為。如果沒有泛型,我們可能會發(fā)生線上事故,因為程序拋出了 ClassCastException 并崩潰了！ 作為演示，我們假設(shè) List < string > 是 List < object > 的子類型。如果這是真的，你可能會得到以下代碼: List<String> directions = new ArrayList<String>(); List<Object> objects = directions; objects.add(new Integer()); String s = objects.get(0); 將一個整數(shù)添加到對象列表中，這違反了類型安全。問題發(fā)生在最后一行，該行拋出 ClassCastException，因為無法將存儲的整數(shù)強(qiáng)制轉(zhuǎn)換為字符串。 使用通配符來解決問題class Scratch_13{
public static void main(String[] args) {
List<String> directions = new ArrayList<String>();
directions.add("north");
directions.add("south");
directions.add("east");
directions.add("west");
printList(directions);
List<Integer> grades = new ArrayList<Integer>();
grades.add(Integer.valueOf(98));
grades.add(Integer.valueOf(63));
grades.add(Integer.valueOf(87));
printList(grades);
}
static void printList (List < ? > list)
{
Iterator<?> iter = list.iterator();
while (iter.hasNext())
System.out.println(iter.next());
}
}我使用了一個通配符(?)在參數(shù)列表和 printList ()的方法體中，因為此符號代表任何類型，所以將 List < string > 和 List < integer > 傳遞給此方法是合法的 深入探索泛型方法假如你現(xiàn)在有一個業(yè)務(wù)邏輯需要你將一個List 復(fù)制到另外一個List,要傳遞任意類型的源和目標(biāo)，需要使用通配符作為類型占位符 void copy(List<?> src, List<?> dest, Filter filter)
{
for (int i = 0; i < src.size(); i++)
if (filter.accept(src.get(i)))
dest.add(src.get(i));
}這時編譯器又又又報錯了
< ？ >意味著任何類型的對象都可以是列表的元素類型，并且源元素和目標(biāo)元素類型可能是不兼容的 例:源列表是一個 Shape 的 List，而目標(biāo)列表是一個 String 的 List，并且允許復(fù)制，那么在嘗試檢索目標(biāo)列表的元素時將拋出 ClassCastException 指定類型上下界void copy(List<? extends String> src, List<? super String> dest, Filter filter)
{
for (int i = 0; i < src.size(); i++)
if (filter.accept(src.get(i)))
dest.add(src.get(i));
}通過指定 extends 后跟類型名稱，可以為通配符提供一個上限。類似地，可以通過指定 super 后跟類型名來為通配符提供一個下限。這些邊界限制了可以作為實際類型參數(shù)傳遞的類型。 在這個例子中，因為 String 是 final，這意味著它不能被繼承，所以只能傳遞 String 對象的源列表和 String 或 Object 對象的目標(biāo)列表，這個問題只是解決了一部分,怎么辦呢 使用泛型方法完全解決這個問題泛型方法的語法規(guī)范: <formalTypeParameterList> returnType method(param) 類型參數(shù)可以用作返回類型，也可以出現(xiàn)在參數(shù)列表中 此時我們重寫代碼解決這個問題: public class Demo
{
public static void main(String[] args)
{
List<Integer> grades = new ArrayList<Integer>();
Integer[] gradeValues =
{
Integer.valueOf(96),
Integer.valueOf(95),
Integer.valueOf(27),
Integer.valueOf(100),
Integer.valueOf(43),
Integer.valueOf(68)
};
for (int i = 0; i < gradeValues.length; i++){
grades.add(gradeValues[i]);
}
List<Integer> failedGrades = new ArrayList<Integer>();
copy(grades, failedGrades, grade -> grade <= 50);//函數(shù)式編程,使用lambda表達(dá)式實現(xiàn)Filter<T>此時T為Integer類型
for (int i = 0; i < failedGrades.size(); i++){
System.out.println(failedGrades.get(i));
}
}
static <T> void copy(List<T> src, List<T> dest, Filter<T> filter)
{
for (int i = 0; i < src.size(); i++)
if (filter.accept(src.get(i)))
dest.add(src.get(i));
}
}
interface Filter<T>
{
boolean accept(T o);
}此時我們?yōu)?src、 dest 和 filter 參數(shù)的類型都包含類型參數(shù) T。這意味著在方法調(diào)用期間必須傳遞相同的實際類型參數(shù)，編譯器自動通過調(diào)用來推斷這個參數(shù)的類型是什么 泛型和類型推斷Java 編譯器包含類型推斷算法，用于在實例化泛型類、調(diào)用類的泛型構(gòu)造函數(shù)或調(diào)用泛型方法時識別實際的類型參數(shù)。 泛型類實例化在 Java SE 7之前，在實例化泛型類時，必須為變量的泛型類型和構(gòu)造函數(shù)指定相同的實際類型參數(shù)。例子: Map<String, Set<String>> marbles = new HashMap<String, Set<String>>(); 此時,代碼顯得非?；靵y,為了消除這種混亂,Java SE 7修改了類型推斷算法，以便可以用空列表< >替換構(gòu)造函數(shù)的實際類型參數(shù)，前提是編譯器可以從實例化上下文中推斷類型參數(shù)。示例: Map<String, Set<String>> marbles = new HashMap<>();//使用<>替換<String, Set<String>> 要在泛型類實例化期間利用類型推斷，必須指定<>: Map<String, Set<String>> marbles = new HashMap(); 編譯器生成一個“ unchecked conversion warning” ，因為 HashMap ()構(gòu)造函數(shù)引用了 java.util。指定 HashMap 原始類型，而不是 HashMap<String, Set< String >>。
泛型構(gòu)造函數(shù)泛型類和非泛型類都可以聲明 public class Box<E>
{
public <T> Box(T t)
{
// ...
}
}此聲明使用形式類型參數(shù) E 指定泛型類 Box < E > 。它還指定了一個具有形式類型參數(shù) T 的泛型構(gòu)造函數(shù) 那么在構(gòu)造函數(shù)調(diào)用時是這樣的: new Box<Marble>("Aggies");進(jìn)一步利用菱形運算符來消除構(gòu)造函數(shù)調(diào)用中的 Marble 實際類型參數(shù)，只要編譯器能夠從實例化上下文中推斷出這個類型參數(shù): new Box<>("Aggies");泛型方法調(diào)用我們現(xiàn)在已經(jīng)知道了 編譯器會通過類型推斷算法識別出我們使用的類型 //copy是靜態(tài)方法 我們可以使用class.methodName的方式調(diào)用它 Demo.<Integer>copy(grades, failedGrades, grade -> grade <= 50); 對于實例方法，語法幾乎完全相同。 new Demo().<Integer>copy(grades, failedGrades, grade -> grade <= 50); 類型擦除
舉例說明ArrayList< String > () 和 ArrayList< Integer > () 很容易被認(rèn)為是不同的類型，但是下面的打印結(jié)果卻是 true public class ErasedType {
public static void main(String[] args) {
Class c1 = new ArrayList<String>().getClass();
Class c2 = new ArrayList<Integer>().getClass();
// output：true
System.out.println(c1 == c2);
}
}
System.out.println(Arrays.toString(c1.getTypeParameters()));
// output：[E]
System.out.println(Arrays.toString(c2.getTypeParameters()));
// output：[E]分別打印它們的參數(shù)類型，可以發(fā)現(xiàn)，無論指定的是 Integer 類型還是 String 類型，最后輸出結(jié)果都僅是一個 用作參數(shù)占位符的標(biāo)識符 [E] 而已. 這意味著，在使用泛型時，任何具體的類型信息，比如上例中的 Integer 或 String，在泛型內(nèi)部都是無法獲得的，也就是，被擦除了。唯一知道的，就只是正在使用著的對象。由于 ArrayList< String >() 和 ArrayList< Integer >() 都會被擦除成“原生態(tài)”（即 List） 如果指定了邊界，例如< T extends Integer>，類型參數(shù)會被擦除為邊界（Integer），如果未指定邊界，例如，類型參數(shù)會被擦除為 Object 。 堆污染( heap pollution)在使用泛型時，可能會遇到堆污染，其中參數(shù)化類型的變量引用的對象不是該參數(shù)化類型(例如，如果原始類型與參數(shù)化類型混合)。在這種情況下，編譯器報告“ 堆污染示例 import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class Scratch_15
{
public static void main(String[] args)
{
Set s = new TreeSet<Integer>();
Set<String> ss = s; // unchecked warning Unchecked assignment: 'java.util.Set' to 'java.util.Set<java.lang.String>'
s.add(42); // unchecked warning Unchecked call to 'add(E)' as a member of raw type 'java.util.Set'
Iterator<String> iter = ss.iterator();
while (iter.hasNext())
{
String str = iter.next(); //throw ClassCastException
System.out.println(str);
}
}
}
/*
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at Scratch_15.main(scratch_15.java:17)
*/
@SafeVarargs的用法@SafeVarargs在JDK 7中引入，主要目的是處理可變長參數(shù)中的泛型，此注解告訴編譯器：在可變長參數(shù)中的泛型是類型安全的?？勺冮L參數(shù)是使用數(shù)組存儲的，而數(shù)組和泛型不能很好的混合使用 import java.util.ArrayList;
public class SafeVarargsTest {
public static void main(String[] args) {
ArrayList<Integer> a1 = new ArrayList<>();
a1.add(new Integer(1));
a1.add(2);
showArgs(a1, 12);
}
//@SafeVarargs
public static <T> void showArgs(T... array) {
for (T arg : array) {
System.out.println(arg.getClass().getName() + ":" + arg);
}
}
}如果使用IDE進(jìn)行編譯，需要修改編譯參數(shù)，增加-Xlint:unchecked編譯選項。 $ javac -Xlint:unchecked SafeVarargsTest.java
SafeVarargsTest.java:18: 警告: [unchecked] 參數(shù)化 vararg 類型T的堆可能已受污染
public static < T> void showArgs(T… array) {
^其中, T是類型變量: 但是顯然在這個示例中，可變參數(shù)的泛型是安全的，因此可以啟用@SafeVarargs注解消除這個警告信息。 @SafeVarargs注解只能用在參數(shù)長度可變的方法或構(gòu)造方法上，且方法必須聲明為static或final，否則會出現(xiàn)編譯錯誤。一個方法使用@SafeVarargs注解的前提是，開發(fā)人員必須確保這個方法的實現(xiàn)中對泛型類型參數(shù)的處理不會引發(fā)類型安全問題，否則可能導(dǎo)致運行時的類型轉(zhuǎn)換異常。下面給出一個“堆污染”的實例 import java.util.Arrays;
import java.util.List;
public class UnsafeMethodTest {
public static void main(String[] args) {
List<String> list1 = Arrays.asList("one", "two");
List<String> list2 = Arrays.asList("three","four");
unsafeMethod(list1, list2);
}
@SafeVarargs //并不安全
static void unsafeMethod(List<String>... stringLists) {
Object[] array = stringLists;
List<Integer> tmpList = Arrays.asList(42, 56);
array[0] = tmpList; // tmpList是一個List對象（類型已經(jīng)擦除），賦值給Object類型的對象是允許的（向上塑型），能夠編譯通過
String s = stringLists[0].get(0); // 運行時拋出ClassCastException！
}
}運行UnsafeMethodTest的結(jié)果如下： Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String 數(shù)組array和stringLists同時指向了參數(shù)數(shù)組，tmpList是一個包含兩個Integer對象的list對象。
完 |
|
|
