• 初识Java 18-2 泛型

    目录

    构建复杂模型

    类型擦除

    C++中的泛型

    迁移的兼容性

    类型擦除存在的问题

    边界的行为

    对类型擦除的补偿

    创建类型实例

    泛型数组

    本笔记参考自： 《On Java 中文版》

    构建复杂模型

            泛型的一个优点就是，能够简单且安全地创建复杂模型。

    【例子：生成更复杂的数据结构】

    1. import onjava.Tuple4;
    2.  
    3. import java.util.ArrayList;
    4.  
    5. public class TupleList
    6.         extends ArrayList> {
    7.     public static void main(String[] args) {
    8.         TupleList tl =
    9.                 new TupleList<>();
    10.         tl.add(TupleTest2.h());
    11.         tl.add(TupleTest2.h());
    12.         tl.forEach(System.out::println);
    13.     }
    14. }

            程序执行的结果是：

            除此之外，我们也可以利用泛型组合各种各样的“块”，使其最终能够实现强大的功能。下面的例子表示的是一个商店（Store），这个商店中有通道（Aisle）、货架（Shelf）和商品（Product）：

    【例子：通过泛型构建一个商店模型】

    1. import onjava.Suppliers;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Random;
    5. import java.util.function.Supplier;
    6.  
    7. // 构建商品模型
    8. class Product {
    9.     private final int id;
    10.     private String description;
    11.     private double price;
    12.  
    13.     Product(int idNumber, String descr, double price) {
    14.         id = idNumber;
    15.         description = descr;
    16.         this.price = price;
    17.         System.out.println(toString());
    18.     }
    19.  
    20.     @Override
    21.     public String toString() {
    22.         return id + "：" + description +
    23.                 ", 价格：" + price + "元";
    24.     }
    25.  
    26.     public void priceChange(double change) {
    27.         price += change;
    28.     }
    29.  
    30.     public static Supplier generator =
    31.             new Supplier() {
    32.                 private Random rand = new Random(47);
    33.  
    34.                 @Override
    35.                 public Product get() {
    36.                     return new Product(rand.nextInt(1000),
    37.                             "某件商品", Math.round(
    38.                             rand.nextDouble() * 1000.0) + 0.99);
    39.                 }
    40.             };
    41. }
    42.  
    43. // 构建货架模型
    44. class Shelf extends ArrayList {
    45.     Shelf(int nProducts) {
    46.         // Suppliers需要由自己进行实现
    47.         Suppliers.fill(this, Product.generator, nProducts);
    48.     }
    49. }
    50.  
    51. // 构建通道模型
    52. class Aisle extends ArrayList {
    53.     Aisle(int nShelves, int nProducts) {
    54.         for (int i = 0; i < nShelves; i++)
    55.             add(new Shelf(nProducts));
    56.     }
    57. }
    58.  
    59. class CheckOutStand {
    60. }
    61.  
    62. class Office {
    63. }
    64.  
    65. // 最终组合成了一个商店的模型
    66. public class Store extends ArrayList {
    67.     private ArrayList checkouts =
    68.             new ArrayList<>();
    69.     private Office office = new Office();
    70.  
    71.     public Store(
    72.             int nAisles, int nShelves, int nProducts) {
    73.         for (int i = 0; i < nAisles; i++)
    74.             add(new Aisle(nShelves, nProducts));
    75.     }
    76.  
    77.     @Override
    78.     public String toString() {
    79.         StringBuffer result = new StringBuffer();
    80.         for (Aisle a : this)
    81.             for (Shelf s : a)
    82.                 for (Product p : s) {
    83.                     result.append(p);
    84.                     result.append("\n");
    85.                 }
    86.         return result.toString();
    87.     }
    88.  
    89.     public static void main(String[] args) {
    90.         System.out.println(new Store(3, 2, 2));
    91.     }
    92. }

            程序执行的结果是：

            从Store.toString()方法中可以看出：尽管经过了层层封装，但我们依旧可以方便、安全地管理这些模块。

            这里还需要注意自定义的Suppliers.fill()方法，这个方法的实现会在之后提到。此处的fill()方法可以等价于：

    1. Stream.generate(Product.generator)
    2.     .limit(nProducts)
    3.     .forEach(this::add);

    类型擦除

            Java的泛型同样存在着不合理之处。例如，尽管我们可以声明ArrayList.class，但却无法使用ArrayList.class。

    【例子：发现泛型的不合理】

    1. import java.util.ArrayList;
    2.  
    3. public class ErasedTypeEquivalence {
    4.     public static void main(String[] args) {
    5.         Class c1 = new ArrayList().getClass();
    6.         Class c2 = new ArrayList().getClass();
    7.         System.out.println(c1 == c2);
    8.     }
    9. }

            程序执行，会返回true。

            输出告诉我们，ArrayList和ArrayList是相同的类型。但这是有问题的：因为它们的行为并不相同。我们无法将Integer对象放入到ArrayList，却可以把Integer对象放入到ArrayList中。

            除此之外，Java的泛型还有一个更麻烦的特性：

    【例子：泛型代码内部的信息】

    1. import java.util.*;
    2.  
    3. class Frob {
    4. }
    5.  
    6. class Fnorkle {
    7. }
    8.  
    9. class Quark {
    10. }
    11.  
    12. class Particle {
    13. }
    14.  
    15. public class LostInformation {
    16.     public static void main(String[] args) {
    17.         List list = new ArrayList<>();
    18.         System.out.println(Arrays.toString(
    19.                 list.getClass().getTypeParameters()));
    20.  
    21.         Map map = new HashMap<>();
    22.         System.out.println(Arrays.toString(
    23.                 map.getClass().getTypeParameters()));
    24.  
    25.         Quark quark = new Quark<>();
    26.         System.out.println(Arrays.toString(
    27.                 quark.getClass().getTypeParameters()));
    28.  
    29.         Particle particle = new Particle<>();
    30.         System.out.println(Arrays.toString(
    31.                 particle.getClass().getTypeParameters()));
    32.     }
    33. }

            程序执行的结果是：

            Class.getTypeParameters()方法会返回一个由类型变量的对象组成的数组，表示泛型对象声明（所声明）的类型变量。这似乎表示着我们可以获取与泛型参数有关的类型信息。但结果是，我们只能发现作为参数占位符的标识符。

            这就说明：在Java的泛型代码内部，并不存在有关泛型参数类型的可用信息。

        而C++等语言是可以在泛型内部获取类型信息的。

            Java的泛型是通过类型擦除实现的。因此在使用泛型时，任何具体的类型信息都会被擦除。在泛型内部，唯一能够知道的事情就是我们在使用这个对象。因此，ArrayList和ArrayList在运行时都被“擦除”成了它们的原始类型（raw type）：ArrayList。

    C++中的泛型

            Java的设计中有许多参考了C++的元素。因此，二者在参数化类型的语法部分也十分相似：

    【例子：C++中的泛型（即模板）】

    1. #include 
    2. using namespace std;
    3.  
    4. template <class T>
    5. class Manipulator {
    6.     T obj;
    7.  
    8. public:
    9.     Manipulator(T x) {
    10.         obj = x;
    11.     }
    12.  
    13.     void manipulate() {
    14.         obj.f();
    15.     }
    16. };
    17.  
    18. class HasF {
    19. public:
    20.     void f() {
    21.         cout << "HasF::f()" << endl;
    22.     }
    23. };
    24.  
    25. int main() {
    26.     HasF hf;
    27.     Manipulator manipulator(hf);
    28.     manipulator.manipulate();
    29. }

            编译并执行程序，可得：

            C++编译器会在实例化模板时进行检测。因此，在实例化Manipulator时，编译器会发现HasF中存在着方法f()。

            接下来再尝试通过Java实现同样的效果：

    【例子：在Java中进行尝试】

            首先编写一个HasF类：

    1. public class HasF {
    2.     public void f(){
    3.         System.out.println("HasF.f()");
    4.     }
    5. }

            但接下来的部分却没办法如C++一样书写。若我们尝试调用方法obj.f()，编译器就会提示我们：

    因为类型擦除的缘故，编译器不会知道Manipulator的类型参数是HasF，因此会认为这种调用是不安全的。若想要调用f()，我们就必须人为规定泛型类的边界，帮助编译器确定符合边界的类型：

    1. public class Manipulator2extends HasF> {
    2.     private T obj;
    3.  
    4.     Manipulator2(T x) {
    5.         obj = x;
    6.     }
    7.  
    8.     public void manipulator() {
    9.         obj.f();
    10.     }
    11. }

            告诉编译器，T的类型必须是HasF及其的子类。

            在这里，泛型的类型参数被擦除为了其的第一个边界HasF（与之相对的，也存在拥有多重边界的泛型）。编译器会将类型参数替换为擦除后的类型，因此可以说，在这个例子中T被替换成了HasF。

        并且，该例子实际上并不需要使用到泛型——可以直接使用更加具体的类型HasF。

            注意：当我们希望代码能够跨越多个类型运行时，泛型才会发挥作用（因此，在具有实际价值的泛型代码中，类型参数及其应用往往会比简单的类替换更加复杂）。

    （基于以上论点，可以认为这种用法存在缺陷。）

            下面的例子展示了更好的一种泛型应用：通过让方法返回类型参数T，可以使泛型返回精确的类型。

    【例子：更好的泛型使用】

    1. public class ReturnGenericTypeextends HasF> {
    2.     private T obj;
    3.  
    4.     ReturnGenericType(T x) {
    5.         obj = x;
    6.     }
    7.  
    8.     public T get() {
    9.         return obj;
    10.     }
    11. }

    迁移的兼容性

            注意：类型擦除并不是一项语言特性。它是Java在实现泛型时使用的一种必要的折中，因为泛型并不是这门语言与生俱来的一部分。

        因此，Java中的泛型并没有将类型参数具体化成第一类实体的能力。

            因为类型擦除，泛型类型被视同第二类类型处理，这使得其无法在一些重要的上下文中得到使用：泛型类型只会在静态类型检查时存在，之后，程序会将泛型类型擦除成它们的非泛型上界。

            在Java 5之前，存在许多编写完毕的非泛型的库。库是一门语言重要的组成部分，无法被轻易抛弃。因此，Java的泛型设计必然需要保证向后兼容性和迁移兼容性。前者保证原有的数据依旧合法，后者则需要协调泛化的程序与非泛化的库（反之亦然）。

    ||| 至于类型擦除是否是一种好的手段，就只能靠时间来验证了。

    类型擦除存在的问题

            类型擦除在非泛化代码和泛化代码之间构建起了一座桥梁，泛型得以在不破坏现有库的情况下加入Java。

            然而这种做法是有代价的。泛型代码无法用于需要显式引用运行时类型的操作，例如类型转换、instanceof操作以及new表达式。在编写泛型代码时，我们只是看起来掌握了参数的类型信息。就比如，现在有一个泛型类：

    1. class Foo {
    2.     T var;
    3. }

    若为它创建一个实例：

    Foo f = new Foo<>();

    尽管不论是直观的理解或是语法本身带来的暗示，都在说明T已经被替换成了Cat。遗憾的是，泛型内部的T已经只是一个Object。

        泛型擦除像是一个边界，在边界里面的成员会被擦除成原始的类型。只有在进出边界时，它们才会被转换成对应的类型。

            另外，因为类型擦除和迁移兼容性，Java中泛型的使用并非是强制性的。

    【例子：不强制的泛型使用】

    1. class GenericBase {
    2.     private T element;
    3.  
    4.     public void set(T arg) {
    5.         element = arg;
    6.     }
    7.  
    8.     public T get() {
    9.         return element;
    10.     }
    11. }
    12.  
    13. // 使用泛型：
    14. class Derived1 extends GenericBase {}
    15.  
    16. // 使用原始类型，但未发出警告：
    17. class Derived2 extends GenericBase {}
    18.  
    19. // 引发错误：
    20. //class Derived3 extends GenericBase {}
    21.  
    22. public class ErasureAndInheritance {
    23.     @SuppressWarnings("unchecked")
    24.     public static void main(String[] args) {
    25.         Derived2 d2 = new Derived2();
    26.         Object obj = d2.get();
    27.         d2.set(obj); // d2.set()会引发警告，使用@SuppressWarnings()进行关闭
    28.     }
    29. }

            Derived2继承了GenericBase，而未使用泛型参数。编译器没有在这里给出警告，直到进行编译时，在d2.get()才显现出来。若要关闭警告，可以使用Java提供的注解：

    @SuppressWarnings("unchecked")

    这一注解应该被放置于触发警告的类上。

            Derived3会引发错误：

    编译器需要的是一个原始的基类，而我们却提供了一个带有的泛型。

        在Java中，使用类型参数就意味着我们需要管理边界。这使得Java泛型并没有完全发挥其应有的灵活性。

    边界的行为

            类型擦除使得泛型会表现出一些无意义的行为：

    【例子：无意义的泛型行为】

    1. import java.lang.reflect.Array;
    2. import java.util.Arrays;
    3.  
    4. public class ArrayMaker {
    5.     private Class kind;
    6.  
    7.     public ArrayMaker(Class kind) {
    8.         this.kind = kind;
    9.     }
    10.  
    11.     @SuppressWarnings("unchecked")
    12.     T[] create(int size) { // 需要使用类型转换
    13.         return (T[]) Array.newInstance(kind, size);
    14.     }
    15.  
    16.     public static void main(String[] args) {
    17.         ArrayMaker stringMaker =
    18.                 new ArrayMaker<>(String.class);
    19.         String[] stringArray = stringMaker.create(9);
    20.         System.out.println(Arrays.toString(stringArray));
    21.     }
    22. }

            程序执行的结果是：

            在这个例子中，尽管kind看起来会获得一个具体的Class，但当进入类型擦除的边界时，就会消失。换言之，kind中存储的只是一个无意义的Class，它无法生成一个具体的结果，因此我们还需要使用到类型转换（并且会产生警告）。

        在create()方法中使用到的Array.newInstance()，是在泛型中创建数组的推荐方法。

            我们也可以使用泛型创建集合（而不是数组）：

    【例子：无意义的集合】

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. public class ListMaker {
    5.     List create() {
    6.         return new ArrayList<>();
    7.     }
    8.  
    9.     public static void main(String[] args) {
    10.         ListMaker stringMaker = new ListMaker<>();
    11.         List stringList = stringMaker.create();
    12.     }
    13. }

            在create()内部的new ArrayList<>()方法中没有使用，并且在运行时也会被移除。这使得这个集合似乎并没有具体意义，但若使用new ArrayList()，依旧会引发警告。

    ---

            但我们依旧可以通过一些方式进行有意义的调用：

    【例子：有意义的泛型集合】

    1. import onjava.Suppliers;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5. import java.util.function.Supplier;
    6.  
    7. public class FilledList extends ArrayList {
    8.     FilledList(Supplier gen, int size) {
    9.         // 等价于使用Stream.generate(gen)生成size个元素，并装入该类中
    10.         Suppliers.fill(this, gen, size);
    11.     }
    12.  
    13.     public FilledList(T t, int size) {
    14.         for (int i = 0; i < size; i++)
    15.             this.add(t);
    16.     }
    17.  
    18.     public static void main(String[] args) {
    19.         List list = new FilledList<>("Hello", 4);
    20.         System.out.println(list);
    21.  
    22.         // 也可以借由Supplier接口进行实现
    23.         List ilist = new FilledList<>(() -> 47, 4);
    24.         System.out.println(ilist);
    25.     }
    26. }

            程序执行的结果是：

            虽然在this.add()方法中，编译器无法知道任何关于T的信息，但我们依旧可以在编译时确保放入FilledList中的是类型T。因此，尽管存在类型擦除，编译器依旧可以确保类型在使用方法内部的一致性。

            现在，泛型运行时的关键就指向的边界——对象进入和离开方法体的临界点。编译器在这里执行类型检查，插入类型转换。可以观察下面两个类之间的区别：

            这两个类之间唯一的区别就是它们是否使用了泛型。现在可以通过反编译指令（javap -c）来观察它们的字节码：

            可以发现，非泛型类和泛型类在这里得到的字节码完全相同。在main()中调用set()方法时，编译器自动插入了类型转换，并且get()的类型转换仍然存在。从这里可以得出一个结论：泛型所有的行为都发生在边界，包括输入值的检查、类型转换等。

    对类型擦除的补偿

            类型擦除会使得我们在一些操作上受掣肘：

            尽管我们有时可以绕过这些问题，但有些问题总是需要泛型来解决。此时可以使用类型标签来补偿类型擦除带来的损失：我们可以在类型表达式中显示地为所使用的类型传入一个Class对象。

            类型标签与instanceof的不同之于，instanceof是静态的检查，若类型被擦除，那么instanceof就会失效。而类型标签可以通过isInstance()提供动态的检查，这使得它可以在泛型中进行使用：

    【例子：使用类型标签】

    1. class Building {
    2. }
    3.  
    4. class House extends Building {
    5. }
    6.  
    7. public class ClassTypeCapture {
    8.     Class kind;
    9.  
    10.     public ClassTypeCapture(Class kind) {
    11.         this.kind = kind;
    12.     }
    13.  
    14.     public boolean f(Object arg) {
    15.         return kind.isInstance(arg);
    16.     }
    17.  
    18.     public static void main(String[] args) {
    19.         ClassTypeCapture ctt1 =
    20.                 new ClassTypeCapture<>(Building.class);
    21.         System.out.println(ctt1.f(new Building()));
    22.         System.out.println(ctt1.f(new House()));
    23.  
    24.         ClassTypeCapture ctt2 =
    25.                 new ClassTypeCapture<>(House.class);
    26.         System.out.println(ctt2.f(new Building()));
    27.         System.out.println(ctt2.f(new House()));
    28.     }
    29. }

            程序执行的结果是：

            编译器会确保类型标签能够与泛型参数相匹配。

    创建类型实例

            在Erased.java中执行new T()操作是无法成功的，这有两个原因：①类型擦除和②编译器无法验证T中是否存在无参构造器。但C++却支持这种操作：

    【例子：C++允许创建泛型的类型实例】

    1. template<class T> class Foo {
    2.     T x; // 字段x
    3.     T* y; // 指向T类的指针
    4. public:
    5.     Foo() {
    6.         // 初始化指针
    7.         y = new T();
    8.     }
    9. };
    10.  
    11. class Bar {};
    12.  
    13. int main()
    14. {
    15.     Foo fb;
    16.     Foo<int> fi; // 甚至可以使用基本类型
    17.     return 0;
    18. }

    ---

            而Java则需要使用工厂设计方法来创建新的实例。Class就是一个方便的工厂对象，将其作为类型标签，我们能够在Java中实现类似上例的功能：

    【例子：通过newInstance()创建泛型对象】

    1. import java.util.function.Supplier;
    2.  
    3. class ClassAsFactory implements Supplier {
    4.     Class kind;
    5.  
    6.     ClassAsFactory(Class kind) {
    7.         this.kind = kind;
    8.     }
    9.  
    10.     @Override
    11.     public T get() {
    12.         try {
    13.             return kind.getConstructor().newInstance();
    14.         } catch (Exception e) {
    15.             throw new RuntimeException(e);
    16.         }
    17.     }
    18. }
    19.  
    20. class Employee {
    21.     public Employee() {
    22.     }
    23.  
    24.     @Override
    25.     public String toString() {
    26.         return "Employee";
    27.     }
    28. }
    29.  
    30. public class InstantiateGenericType {
    31.     public static void main(String[] args) {
    32.         ClassAsFactory fe =
    33.                 new ClassAsFactory<>(Employee.class);
    34.         System.out.println(fe.get());
    35.  
    36.         ClassAsFactory fi =
    37.                 new ClassAsFactory<>(Integer.class);
    38.         try {
    39.             System.out.println(fi.get());
    40.         } catch (Exception e) {
    41.             System.out.println(e.getMessage());
    42.         }
    43.     }
    44. }

            程序执行的结果是：

            在该例中，我们尝试创建Integer的实例，结果却失败了。这是因为Integer中不存在无参构造器。这个错误不会在编译时被发现，也因此上例的方式并不被推荐。更好的方式是使用显式工厂，同时限制能够传入的类型：

    【例子：创建工厂，生成泛型实例】

    1. import onjava.Suppliers;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5. import java.util.function.Supplier;
    6.  
    7. class IntegerFactory implements Supplier {
    8.     private int i = 0;
    9.  
    10.     @Override
    11.     public Integer get() {
    12.         return ++i;
    13.     }
    14. }
    15.  
    16. class Widget {
    17.     private int id;
    18.  
    19.     Widget(int n) {
    20.         id = n;
    21.     }
    22.  
    23.     @Override
    24.     public String toString() {
    25.         return "Widget " + id;
    26.     }
    27.  
    28.     public static
    29.     class Factory implements Supplier {
    30.         private int i = 0;
    31.  
    32.         @Override
    33.         public Widget get() {
    34.             return new Widget(++i);
    35.         }
    36.     }
    37. }
    38.  
    39. class Fudge {
    40.     private static int count = 1;
    41.     private int n = count++;
    42.  
    43.     @Override
    44.     public String toString() {
    45.         return "Fudge " + n;
    46.     }
    47. }
    48.  
    49. class Foo2 {
    50.     private List x = new ArrayList<>();
    51.  
    52.     Foo2(Supplier factory) {
    53.         // 等价于使用Stream.generate(factory)生成5个元素，并装入该类中
    54.         Suppliers.fill(x, factory, 5);
    55.     }
    56.  
    57.     @Override
    58.     public String toString() {
    59.         return x.toString();
    60.     }
    61. }
    62.  
    63. public class FactoryConstraint {
    64.     public static void main(String[] args) {
    65.         System.out.println(
    66.                 new Foo2<>(new IntegerFactory()));
    67.         System.out.println(
    68.                 new Foo2<>(new Widget.Factory()));
    69.         System.out.println(
    70.                 new Foo2<>(Fudge::new));
    71.     }
    72. }

            程序执行的结果是：

            Foo2类用于调用各种工厂方法，生成实例。这里展示了三种创建工厂的方式：

    1. IntegerFactory：本身就是一个实现了Supplier的工厂；
    2. Widget：包含了一个作为工厂的内部类；
    3. Fudge：不执行任何类似工厂的操作，但编译器会自动将Fudge::new转变成对get的调用。

            除此之外，还有另一种设计模式：模板方法。将方法在子类中进行重写，用来生成对应类型的对象：

    【例子：使用模板方法生成泛型实例】

    1. abstract class GenericWithCreate {
    2.     final T element;
    3.  
    4.     GenericWithCreate() {
    5.         element = create();
    6.     }
    7.  
    8.     // 会在子类中重写的模板方法：
    9.     abstract T create();
    10. }
    11.  
    12. class X {
    13. }
    14.  
    15. class XCreator extends GenericWithCreate {
    16.     @Override
    17.     X create() {
    18.         return new X();
    19.     }
    20.  
    21.     void f() {
    22.         System.out.println(
    23.                 element.getClass().getSimpleName());
    24.     }
    25. }
    26.  
    27. public class CreatorGeneric {
    28.     public static void main(String[] args) {
    29.         XCreator xc = new XCreator();
    30.         xc.f();
    31.     }
    32. }

            程序执行的结果是：

            GenericWithCreate有唯一的无参构造器，这样就可以要求任何所有这个类的程序员，必须通过我们规定的方式初始化这个类。另一边，create()方法将类的创建逻辑交付给了子类实现，这使得该方法的返回值可以在子类中得到更具体的定义。

    泛型数组

            正如之前所看到的，我们无法直接在泛型中创建泛型数组：

    一个直接的方法是使用集合来代替数组：

    【例子：使用集合替代数组】

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. public class ListOfGenerics {
    5.     private List array = new ArrayList<>();
    6.  
    7.     public void add(T item) {
    8.         array.add(item);
    9.     }
    10.  
    11.     public T get(int index) {
    12.         return array.get(index);
    13.     }
    14. }

            这样我们就获得了数组的行为，并且得到了泛型提供的编译时类型检查。

            但如果确实有使用泛型数组的必要，那么可以尝试使用一个泛型引用，通过将这个引用指向一个数组，可以变相满足编译器的规定：

    【例子：将引用指向数组】

    1. class Generic {
    2. }
    3.  
    4. public class ArrayOfGenericReference {
    5.     static Generic[] gia;
    6. }

            因为类型擦除，这个数组实际上没有具体的类型，无论指定的泛型参数是什么，数组都会具有相同的结构和大小。这看上去有点像Object，那么我们是否可以将一个Object类型的数组转换成目标数组？

            答案依旧是否定的：

    【例子：无法对Object数组进行转型】

    1. public class ArrayOfGeneric {
    2.     static final int SIZE = 100;
    3.     static Generic[] gia;
    4.  
    5.     @SuppressWarnings("unchecked")
    6.     public static void main(String[] args) {
    7.         try {
    8.             gia = (Generic[]) new Object[SIZE];
    9.         } catch (ClassCastException e) {
    10.             System.out.println(e.getMessage());
    11.         }
    12.  
    13.         // 运行时会发生类型擦除，得到的是原始类型Generic[]
    14.         gia = (Generic[]) new Generic[SIZE];
    15.         System.out.println(gia.getClass().getSimpleName());
    16.         gia[0] = new Generic<>();
    17.         // 发生编译时错误（类型不匹配）：
    18.         // gia[1] = new Object();
    19.         // gia[2] = new Generic();
    20.     }
    21. }

            程序执行的结果是（输出已经过折叠）：

            数组的类型在它们被创建的时候才会确定下来，因此转型信息Generic[]也只会存在于编译时。语句：

    gia = (Generic[]) new Object[SIZE];

    能得到的只会是Object数组，这就会导致问题。

            而另一条创建语句：

    gia = (Generic[]) new Generic[SIZE];

    对一个被擦除类型的数组进行强制类型转换得到了成功。这也是唯一可以成功创建泛型数组的方式。

            以此类推，下面是一个更加复杂的例子：

    【例子：更复杂的泛型数组尝试】

    1. public class GenericArray {
    2.     private T[] array;
    3.  
    4.     @SuppressWarnings("unchecked")
    5.     public GenericArray(int sz) {
    6.         array = (T[]) new Object[sz];
    7.     }
    8.  
    9.     public void put(int index, T item) {
    10.         array[index] = item;
    11.     }
    12.  
    13.     public T get(int index) {
    14.         return array[index];
    15.     }
    16.  
    17.     // 通过返回T[]，可以发现其的潜在表现形式：
    18.     public T[] rep() {
    19.         return array;
    20.     }
    21.  
    22.     public static void main(String[] args) {
    23.         GenericArray gai = new GenericArray<>(10);
    24.         try {
    25.             Integer[] ia = gai.rep();
    26.         } catch (ClassCastException e) {
    27.             System.out.println(e.getMessage());
    28.         }
    29.  
    30.         // 可以使用Object数组接受：
    31.         Object[] oa = gai.rep();
    32.     }
    33. }

            程序执行的结果是（输出已经过折叠）：

            显然，这里的gai也被类型擦除影响，其在运行时的实际类型也变成了Object。

            之前也提到过，通过@SuppressWarnings("unchecked")可以抑制编译器发出警告，否则会出现这样的警告：

            为了获取更加详细的信息，可以在编译时添加-Xlint:unchecked选项。而如果这么做，就会得到如下的信息：

        若认为报出的警告并不影响程序运行，就可以使用注解关闭警告，因为警告在一些时候也会成为不必要的噪声。

            因为类型擦除，在上例中我们只能得到Object[]。若此时立刻将其转变为T[]，就会丢失数组的实际类型，这可能会让一些潜在错误有机可乘。

            一个可能的替代方法是在泛型类内部使用Object数组，而在边界处执行类型转换：

    【例子：在边界上执行类型转换】

    1. public class GenericArray2 {
    2.     private Object[] array;
    3.  
    4.     public GenericArray2(int sz) {
    5.         array = new Object[sz];
    6.     }
    7.  
    8.     public void put(int index, T item) {
    9.         array[index] = item;
    10.     }
    11.  
    12.     @SuppressWarnings("unchecked")
    13.     public T get(int index) {
    14.         return (T) array[index];
    15.     }
    16.  
    17.     // 该方法依旧存在问题：为检测的类型转换
    18.     @SuppressWarnings("unchecked")
    19.     public T[] rep() {
    20.         return (T[]) array;
    21.     }
    22.  
    23.     public static void main(String[] args) {
    24.         GenericArray2 gai =
    25.                 new GenericArray2<>(10);
    26.  
    27.         for (int i = 0; i < 10; i++)
    28.             gai.put(i, i);
    29.         for (int i = 0; i < 10; i++)
    30.             System.out.print(gai.get(i) + " ");
    31.         System.out.println();
    32.  
    33.         try {
    34.             Integer[] ia = gai.rep();
    35.         } catch (Exception e) {
    36.             System.out.println(e);
    37.         }
    38.     }
    39. }

            程序执行的结果是：

            这么做依旧需要抑制警告。但比上一个例子更好的一点在于，现在get()方法能够正确地进行类型转换了。而不好的一点在于，rep()方法依旧无法将Object[]转型为T[]。这里就可以得出一个结论：底层的数组类型是无法更改的，这个类型只能是Object[]。

        在泛型类内部使用Object[]的另一个好处是，让程序员花费更少的精力来处理数组的运行时类型。

    ---

            既然底层的数组无法更改，那么我们还可以换一个思路。通过类型标记，我们可以直接创建一个目标数组的实例：

    【例子：使用类型标记创建数组实例】

    1. import java.lang.reflect.Array;
    2.  
    3. public class GenericArrayWithTypeToken {
    4.     private T[] array;
    5.  
    6.     @SuppressWarnings("unchecked")
    7.     public GenericArrayWithTypeToken(Class type, int sz) {
    8.         array = (T[]) Array.newInstance(type, sz);
    9.     }
    10.  
    11.     public void put(int index, T item) {
    12.         array[index] = item;
    13.     }
    14.  
    15.     public T get(int index) {
    16.         return array[index];
    17.     }
    18.  
    19.     // 依旧会暴露潜在的表达方式：
    20.     public T[] rep() {
    21.         return array;
    22.     }
    23.  
    24.     public static void main(String[] args) {
    25.         GenericArrayWithTypeToken gai =
    26.                 new GenericArrayWithTypeToken<>(
    27.                         Integer.class, 10);
    28.  
    29.         // 现在可以正常运行：
    30.         Integer[] ia = gai.rep();
    31.     }
    32. }

            尽管还是需要抑制警告，但在这个例子中，数组在运行时是精确的T[]类型了。

        然而，在Java的源代码中，也存在着许都使用Object数组转型为参数化类型的操作，对其编译甚至会产生警告……（因此，Java的库代码难以作为我们自己编写代码时的范例）

  • 相关阅读:
    ansible常用模块的用法和ansible基于模块方式实现LNMP
    图像识别与处理学习笔记（二）图像增强之频率域处理
    Istio数据面新模式：Ambient Mesh技术解析
    Git指令
    GITEE 基于OAuth2的API V5版本
    python绘制立体玫瑰花
    vue使用pdf-dist实现pdf预览以及水印
    【VMware vCenter】VMware vCenter Server(VCSA) 5.5 版本证书过期问题处理过程。
    kali的安装与配置
    记一次 Sedona（GeoSpark） 空间计算优化
  • 原文地址：https://blog.csdn.net/w_pab/article/details/134443383