免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

打開APP
userphoto
未登錄

開通VIP,暢享免費電子書等14項超值服

開通VIP
如何使用 Java 泛型來避免 ClassCastException

泛型在java中有很重要的地位,在面向?qū)ο缶幊碳案鞣N設(shè)計模式中有非常廣泛的應(yīng)用。

一句話解釋什么是泛型?

泛型是相關(guān)語言特性的集合,它允許方法對各種類型的對象進(jì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ù)引入一組類型的類或接口.

類型參數(shù):是一對尖括號之間以逗號分隔的類型參數(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ù)

泛型的類型參數(shù)可以被替換為實際的類型參數(shù)(類型名稱)。例如,List < String > 是一個參數(shù)化類型,其中 String 是替換類型參數(shù) E 的實際類型參數(shù)。

JAVA支持的實際類型的參數(shù)有哪些

  • 類型參數(shù): 類型參數(shù) 傳遞給 類型參數(shù)

class Container<E> { Set<E> elements; //E傳給E}
  • 具體類:傳遞具體的類

例: List < Student > , Student為具體類 傳給E

  • 參數(shù)化類:傳遞具體的參數(shù)化類

例: Set < List < Shape > >, List< Shape > 為具體的參數(shù)化類 傳給E

  • 數(shù)組類型: 傳遞數(shù)組

例: Map < String, String[] >, String傳給K String[]傳給V

  • 通配符: 使用問號(?)傳遞

例: 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
. 例如,可以指定 Container < Student > 、 Container < Employee > 或 Container < Person >

通過指定上限來限制傳入的類

但是有時你想限制類型,比如你想 < 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):

For a given subtype x of type y, and given G as a raw type declaration, G< x > is not a subtype of G < y >.
給定一個x類, x是y的子類, G作為原始類型聲明,G(x)不是G(y)的子類

根據(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ù)

泛型類和非泛型類都可以聲明泛型構(gòu)造函數(shù),其中構(gòu)造函數(shù)具有形式類型參數(shù)列表。例如,你可以用泛型構(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)知道了 編譯器會通過類型推斷算法識別出我們使用的類型
那么對于我們之前,將一個list拷貝到另外一個List的例子,我們還可以繼續(xù)改造一下

//copy是靜態(tài)方法 我們可以使用class.methodName的方式調(diào)用它Demo.<Integer>copy(grades, failedGrades, grade -> grade <= 50);

對于實例方法,語法幾乎完全相同。

new Demo().<Integer>copy(grades, failedGrades, grade -> grade <= 50);

類型擦除

在泛型代碼內(nèi)部,無法獲得任何有關(guān)泛型參數(shù)類型的信息 —《Java 編程思想》

舉例說明

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ù)化類型混合)。在這種情況下,編譯器報告“unchecked warning” ,因為無法驗證涉及參數(shù)化類型的操作(如強(qiáng)制轉(zhuǎn)換或方法調(diào)用)的正確性

堆污染示例

  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) */
  • 第一個未檢查的警告:變量 ss 具有參數(shù)化類型 Set < string > 。當(dāng) s 引用的 Set 被分配給 ss 時,編譯器會生成一個未檢查的警告。它因為編譯器不能確定 s 引用 Set < string > 類型。結(jié)果就是堆污染

  • 第二個未檢查的警告:由于泛型擦除,編譯器也不能確定變量 s 是指 Set < string > 還是 Set < integer > 類型,這時就會產(chǎn)生 unchecked warning ,自然就會發(fā)生 堆污染了

@SafeVarargs的用法

@SafeVarargs在JDK 7中引入,主要目的是處理可變長參數(shù)中的泛型,此注解告訴編譯器:在可變長參數(shù)中的泛型是類型安全的??勺冮L參數(shù)是使用數(shù)組存儲的,而數(shù)組和泛型不能很好的混合使用
簡單的說,數(shù)組元素的數(shù)據(jù)類型在編譯和運行時都是確定的,而泛型的數(shù)據(jù)類型只有在運行時才能確定下來,因此當(dāng)把一個泛型存儲到數(shù)組中時,編譯器在編譯階段無法檢查數(shù)據(jù)類型是否匹配,因此會給出警告信息:存在可能的“堆污染”(heap pollution),即如果泛型的真實數(shù)據(jù)類型無法和參數(shù)數(shù)組的類型匹配,會導(dǎo)致ClassCastException異常。

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.javaSafeVarargsTest.java:18: 警告: [unchecked] 參數(shù)化 vararg 類型T的堆可能已受污染public static < T> void showArgs(T… array) {^

其中, T是類型變量:
T擴(kuò)展已在方法 < T>showArgs(T…)中聲明的Object

但是顯然在這個示例中,可變參數(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對象。

本站僅提供存儲服務(wù),所有內(nèi)容均由用戶發(fā)布,如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容,請點擊舉報
打開APP,閱讀全文并永久保存 查看更多類似文章
猜你喜歡
類似文章
Java語言基礎(chǔ)特性—第一部分(中)
淺談Java泛型編程
Java中的泛型 第一部分
Java中的泛型
Java泛型編程最全總結(jié)
Java泛型詳解
更多類似文章 >>
生活服務(wù)
分享 收藏 導(dǎo)長圖 關(guān)注 下載文章
綁定賬號成功
后續(xù)可登錄賬號暢享VIP特權(quán)!
如果VIP功能使用有故障,
可點擊這里聯(lián)系客服!

聯(lián)系客服