15泛型_15.8擦除的補償

阿新 • • 發佈：2019-02-19

15.8 擦除的補償

正如我們看到的，擦除丟失了在泛型程式碼中執行某些操作的能力。任何在執行時需要知道確切型別資訊的操作都將無法工作:

//: generics/Erased.java
// {CompileTimeError} (Won't compile)

public class Erased<T> {
  private final int SIZE = 100;
  public static void f(Object arg) {
    if(arg instanceof T) {}          // Error
    T var = new T();                 // Error 

    T[] array = new T[SIZE];         // Error
    T[] array = (T)new Object[SIZE]; // Unchecked warning
  }
} ///:~

偶爾可以繞過這些問題來程式設計，但是有時必須通過引入型別標籤來對擦除進行補償。這意味著你需要顯式地傳遞你的型別的Class物件，以便你可以在型別表示式中使用它。

例如，在前面示例中對使用instanceof的嘗試最終失敗了，因為其型別資訊已經被擦除了。如果引入型別標籤，就可以轉而使用動態的isInstance()：

//: generics/ClassTypeCapture.java 


class Building {}
class House extends Building {}

public class ClassTypeCapture<T> {
  Class<T> kind;
  public ClassTypeCapture(Class<T> kind) {
    this.kind = kind;
  }
  public boolean f(Object arg) {
    return kind.isInstance(arg);
  } 
  public static void main(String[] args) {
    ClassTypeCapture<Building> ctt1 =
      new 
 ClassTypeCapture<Building>(Building.class);
    System.out.println(ctt1.f(new Building()));
    System.out.println(ctt1.f(new House()));
    ClassTypeCapture<House> ctt2 =
      new ClassTypeCapture<House>(House.class);
    System.out.println(ctt2.f(new Building()));
    System.out.println(ctt2.f(new House()));
  }
} /* Output:
true
true
false
true
*///:~

編譯器將確保型別標籤可以匹配泛型引數。

15.8.1 建立型別例項

在Erased.java中對建立一個new T()的嘗試將無法實現，部分原因是因為擦除，而另一部分原因是因為編譯器不能驗證T具有預設(無參)構造器。但是在C++中，這種操作很自然、很直觀，並且很安全(它是在編譯期受到檢查的)：

//: generics/InstantiateGenericType.cpp
// C++, not Java!

template<class T> class Foo {
  T x; // Create a field of type T
  T* y; // Pointer to T
public:
  // Initialize the pointer:
  Foo() { y = new T(); }
};

class Bar {};

int main() {
  Foo<Bar> fb;
  Foo<int> fi; // ... and it works with primitives
} ///:~

Jaya中的解決方案是傳遞一個工廠物件，並使用它來建立新的例項。最便利的工廠物件就是Class物件，因此如果使用型別標籤，那麼你就可以使用newInstance來建立這個型別的新物件：

//: generics/InstantiateGenericType.java
import static net.mindview.util.Print.*;

class ClassAsFactory<T> {
  T x;
  public ClassAsFactory(Class<T> kind) {
    try {
      x = kind.newInstance();
    } catch(Exception e) {
      throw new RuntimeException(e);
    }
  }
}

class Employee {}   

public class InstantiateGenericType {
  public static void main(String[] args) {
    ClassAsFactory<Employee> fe =
      new ClassAsFactory<Employee>(Employee.class);
    print("ClassAsFactory<Employee> succeeded");
    try {
      ClassAsFactory<Integer> fi =
        new ClassAsFactory<Integer>(Integer.class);
    } catch(Exception e) {
      print("ClassAsFactory<Integer> failed");
    }
  }
} /* Output:
ClassAsFactory<Employee> succeeded
ClassAsFactory<Integer> failed
*///:~

這可以編譯，但是會因ClassAsFactory<Integer>而失敗，因為Integer沒有任何預設的構造器。因為這個錯誤不是在編譯期捕獲的，所以Sun的夥計們對這種方式井不贊成，他們建議使用顯式的工廠，井將限制其型別，使得只能接受實現了這個工廠的類：

//: generics/FactoryConstraint.java

interface FactoryI<T> {
  T create();
}

class Foo2<T> {
  private T x;
  public <F extends FactoryI<T>> Foo2(F factory) {
    x = factory.create();
  }
  // ...
}

class IntegerFactory implements FactoryI<Integer> {
  public Integer create() {
    return new Integer(0);
  }
}   

class Widget {
  public static class Factory implements FactoryI<Widget> {
    public Widget create() {
      return new Widget();
    }
  }
}

public class FactoryConstraint {
  public static void main(String[] args) {
    new Foo2<Integer>(new IntegerFactory());
    new Foo2<Widget>(new Widget.Factory());
  }
} ///:~

注意，這確實只是傳遞Class<T>的一種變體。兩種方式都傳遞了工廠物件，Class<T>碰巧是內建的工廠物件，而上面的方式建立了一個顯式的工廠物件，但是你卻獲得了編譯期檢查。

另一種方式是模板方法設計模式。在下面的示例中，get()是模板方法，而create()是在子類中定義的、用來產生子類型別的物件:

//: generics/CreatorGeneric.java

abstract class GenericWithCreate<T> {
  final T element;
  GenericWithCreate() { element = create(); }
  abstract T create();
}

class X {}

class Creator extends GenericWithCreate<X> {
  X create() { return new X(); }
  void f() {
    System.out.println(element.getClass().getSimpleName());
  }
}   

public class CreatorGeneric {
  public static void main(String[] args) {
    Creator c = new Creator();
    c.f();
  }
} /* Output:
X
*///:~

15.8.2泛型陣列

正如你在Erased.java中所見，不能建立泛型陣列。一般的解決方案是在任何想要建立泛型陣列的地方都使用ArrayList:

//: generics/ListOfGenerics.java
import java.util.*;

public class ListOfGenerics<T> {
  private List<T> array = new ArrayList<T>();
  public void add(T item) { array.add(item); }
  public T get(int index) { return array.get(index); }
} ///:~

這裡你將獲得陣列的行為，以及由泛型提供的編譯期的型別安全。

有時，你仍舊希璧建立泛型型別的陣列(例如，ArrayList內部使用的是陣列)。有趣的是可以按照編譯器喜歡的方式來定義一個引用，例如:

//: generics/ArrayOfGenericReference.java

class Generic<T> {}

public class ArrayOfGenericReference {
  static Generic<Integer>[] gia;
} ///:~

編譯器將接受這個程式，而不會產生任何警告。但是，永遠都不能建立這個確切型別的陣列(包括型別引數)，因此這有一點令人困惑。既然所有陣列無論它們持有的型別如何，都具有相同的結構(每個陣列槽位的尺寸和陣列的佈局)，那麼看起來你應該能夠建立一個Object陣列，並將其轉型為所希望的陣列型別。事實上這可以編譯，但是不能執行，它將產生ClassCaseException:

//: generics/ArrayOfGeneric.java

public class ArrayOfGeneric {
  static final int SIZE = 100;
  static Generic<Integer>[] gia;
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    // Compiles; produces ClassCastException:
    //! gia = (Generic<Integer>[])new Object[SIZE];
    // Runtime type is the raw (erased) type:
    gia = (Generic<Integer>[])new Generic[SIZE];
    System.out.println(gia.getClass().getSimpleName());
    gia[0] = new Generic<Integer>();
    //! gia[1] = new Object(); // Compile-time error
    // Discovers type mismatch at compile time:
    //! gia[2] = new Generic<Double>();
  }
} /* Output:
Generic[]
*///:~

問題在於陣列將跟蹤它們的實際型別，而這個型別是在陣列被建立時確定的，因此，即使gia已經被轉型為Generic<Integer>[]，但是這個資訊只存在幹編譯期（如果沒有@Suppress Warnings註解，你將得到有關這個轉型的警告)。在執行時，它仍將引發問題。成功建立泛型陣列的唯一方式就是建立一個被擦除型別的新陣列，然後對其轉型。

讓我們看一個更復雜的示例。考慮一個簡單的泛型陣列包裝器：

//: generics/GenericArray.java

public class GenericArray<T> {
  private T[] array;
  @SuppressWarnings("unchecked")
  public GenericArray(int sz) {
    array = (T[])new Object[sz];
  }
  public void put(int index, T item) {
    array[index] = item;
  }
  public T get(int index) { return array[index]; }
  // Method that exposes the underlying representation:
  public T[] rep() { return array; }    
  public static void main(String[] args) {
    GenericArray<Integer> gai =
      new GenericArray<Integer>(10);
    // This causes a ClassCastException:
    //! Integer[] ia = gai.rep();
    // This is OK:
    Object[] oa = gai.rep();
  }
} ///:~

與前面相同，我們井不能宣告T[] array=new T[sz]，因此我們建立了一個物件陣列，然後將其轉型。
rep()方法將返回T[]，它在main()中將用於gai，因此應該是Integer[]，但是如果呼叫它，並嘗試著將結果作為Integer[]引用來捕獲，就會得到ClassCastException，這還是因為實際的執行時型別是Objet[]。

如果在註釋掉@Suppresswarniugs註解之後再編譯GenericArray.java ,編譯器就會產生警告:

Note: GenericArray.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

在這種情況下，我們將只獲得單個的警告，並且相信這事關轉型。但是如果真的想要確定是否是這麼回事，就應該用.Xlint:unchecked來編譯：

GenerieArray.java:7: warning:[unchecked] unchecked cast
found : java.lang.Object[]
required: T[]
array = (T[])new Object[sz];
                  ^                      
1 warning

這確實是對轉型的抱怨。因為警告會變得令人迷惑，所以一旦我們驗證某個特定警告是可預期的，那麼我們的上策就是用@SuppressWarnings關閉它。通過這種方式，當警告確實出現時，我們就可以真正地展開對它的調查了。

因為有了擦除，陣列的執行時型別就只能是Object[]。如果我們立即將其轉型為T[]，那麼在編譯期該陣列的實際型別就將丟失，而編譯器可能會錯過某些潛在的錯誤檢查。正因為這樣，最好是在集合內部使用Object[]，然後當你使用陣列元素時，新增一個對T的轉型。讓我們看著這是如何作用於GenericArray.java示例的：

//: generics/GenericArray2.java

public class GenericArray2<T> {
  private Object[] array;
  public GenericArray2(int sz) {
    array = new Object[sz];
  }
  public void put(int index, T item) {
    array[index] = item;
  }
  @SuppressWarnings("unchecked")
  public T get(int index) { return (T)array[index]; }
  @SuppressWarnings("unchecked")
  public T[] rep() {
    return (T[])array; // Warning: unchecked cast
  } 
  public static void main(String[] args) {
    GenericArray2<Integer> gai =
      new GenericArray2<Integer>(10);
    for(int i = 0; i < 10; i ++)
      gai.put(i, i);
    for(int i = 0; i < 10; i ++)
      System.out.print(gai.get(i) + " ");
    System.out.println();
    try {
      Integer[] ia = gai.rep();
    } catch(Exception e) { System.out.println(e); }
  }
} /* Output: (Sample)
0 1 2 3 4 5 6 7 8 9
java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;
*///:~

初看起來，這好像沒多大變化，只是轉型挪了地方。如果沒有@Suppresswarnings註解，你仍舊會得到unchecked告。但是，現在的內部表示是Object[]而不是T[]。當get()被呼叫時，它將物件轉型為T，這實際上是正確的型別，因此這是安全的。然而，如果你呼叫rep() ,它還是嘗試著將Object[]轉型為T[]，這仍舊是不正確的，將在編譯期產生警告，在執行時產生異常。因此，沒有任何方式可以推翻底層的陣列型別，它只能是Object[]。在內部將array當作Object[]而不是T[]處理的優勢是：我們不太可能忘記這個陣列的執行時型別，從而意外地引入缺陷(儘管大多數也可能是所有這類缺陷都可以在執行時快速地探測到)。

對於新程式碼，應該傳遞一個型別標記。在這種情況下，GenericArray看起來會像下面這樣：

//: generics/GenericArrayWithTypeToken.java
import java.lang.reflect.*;

public class GenericArrayWithTypeToken<T> {
  private T[] array;
  @SuppressWarnings("unchecked")
  public GenericArrayWithTypeToken(Class<T> type, int sz) {
    array = (T[])Array.newInstance(type, sz);
  }
  public void put(int index, T item) {
    array[index] = item;
  }
  public T get(int index) { return array[index]; }
  // Expose the underlying representation:
  public T[] rep() { return array; }    
  public static void main(String[] args) {
    GenericArrayWithTypeToken<Integer> gai =
      new GenericArrayWithTypeToken<Integer>(
        Integer.class, 10);
    // This now works:
    Integer[] ia = gai.rep();
  }
} ///:~

型別標記Class<T>被傳遞到構造器中，以便從擦除中恢復，使得我們可以建立需要的實際型別的陣列，儘管從轉型中產生的警告必須用@Suppresswarnings壓制住。一旦我們獲得了實際型別。就可以返回它，並獲得想要的結果，就像在main()中看到的那樣。該陣列的執行時型別是確切型別T[]。

遺憾的是，如果檢視java SE5標準類庫中的原始碼，你就會看到從Object陣列到引數化型別的轉型遍及各處。例如，下面是經過整理和簡化之後的從Collection中複製ArrayList的構造器：

public ArrayList(Collection c) {
    size = c.size();
    elementData = (E[])new Object[size];
    c.toArray(elementData);
}

如果你通讀ArrayList.java，就會發現它充滿了這種轉型。如果我們編譯它，又會發生什麼呢？

Note: ArrayList.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

可以十分肯定，標準類庫會產生大量的警告。如果你曾經用過C++，特別是ANSI C之前的版本，你就會記得警告的特殊效果：當你發現可以忽略它們時，你就可以忽略。正是因為這個原因，最好是從編譯器中不要發出任何訊息，除非程式設計師必須對其進行響應。

Neal Gafter (Java SE5的領導開發者之一)在他的部落格中指出，在重寫Java庫時，他十分懶散，而我們不應該像他那樣。Neal還指出，在不破壞現有介面的情況下，他將無法修改某些Java類庫程式碼。因此，即使在Java類庫原始碼中出現了某些慣用法，也不能表示這就是正確的解決之道。當檢視類庫程式碼時，你不能認為它就是應該在自己的程式碼中遵循的示例。

15泛型_15.8擦除的補償

15.8 擦除的補償

15.8.1 建立型別例項

15.8.2泛型陣列

15泛型_15.8擦除的補償

java 泛型的型別擦除和橋方法

Java泛型與型別擦除

JAVA 泛型之型別擦除

Java泛型之型別擦除

java基礎(28)--泛型與型別擦除、泛型與繼承

Java泛型--編譯器型別擦除

Java泛型－型別擦除

28-泛型--概述+擦除&補償+在集合中的應用+泛型類+泛型方法+泛型介面

C++值多型：傳統多型與型別擦除之間

28-泛型--概述+擦除&補償+在集合中的應用+泛型類+泛型方法+泛型介面

Java泛型擦除

泛型深入--java泛型的繼承和實現、泛型擦除

泛型 Generic 類型擦除引起的問題及解決方法

java泛型泛型的內部原理：類型擦除以及類型擦除帶來的問題

關於泛型擦除的知識（來源於csdn地址：https://blog.csdn.net/briblue/article/details/76736356）

java通過反射獲取私有的構造方法,及反射擦除泛型數據類型約束

聊一聊Java泛型的擦除

揭開Java 泛型類型擦除神秘面紗

泛型的內部原理：型別擦除以及型別擦除帶來的問題

15泛型_15.8擦除的補償

15.8 擦除的補償

15.8.1 建立型別例項

15.8.2泛型陣列

相關推薦