Java_泛型部分

最新推荐文章于 2024-05-09 08:02:57 发布
最新推荐文章于 2024-05-09 08:02:57 发布
阅读量156 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43720262/article/details/123851735
版权

ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

public class ArrayList {
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

需要强制转型，不便易错：

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);、
list.add(new Integer(123));  // ERROR: ClassCastException:

我们可以为String单独编写一种ArrayList：

public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}	//这样一来，存入的必须是String，取出的也一定是String，不需要强制转型

如果要存储Integer，还需要为Integer单独编写一种ArrayList：

public class IntegerArrayList {
    private Integer[] array;
    private int size;
    public void add(Integer e) {...}
    public void remove(int index) {...}
    public Integer get(int index) {...}
}

还需要为其他所有class单独编写一种ArrayList：

  • LongArrayList
  • DoubleArrayList
  • PersonArrayList
  • …

为了解决新的问题，我们必须把ArrayList变成一种模板：ArrayList<T>，代码如下：

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

泛型就是定义一种模板，例如ArrayList<T>，然后在代码中为用到的类创建对应的ArrayList<类型>：

ArrayList<String> strList = new ArrayList<String>();

strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!

既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

向上转型

类型ArrayList<T>可以向上转型为List<T>。

public class ArrayList<T> implements List<T> {
    ...
}
List<String> list = new ArrayList<String>();

特别注意：不能把ArrayList<Integer>向上转型为ArrayList<Number>或List<Number>

// 创建ArrayList<Integer>类型：
ArrayList<Integer> integerList = new ArrayList<Integer>();
// 添加一个Integer：
integerList.add(new Integer(123));
// “向上转型”为ArrayList<Number>：
ArrayList<Number> numberList = integerList;
// 添加一个Float，因为Float也是Number：
numberList.add(new Float(12.34));
// 从ArrayList<Integer>获取索引为1的元素（即添加的Float）：
Integer n = integerList.get(1); // ClassCastException!
// ArrayList<Integer>和ArrayList<Number>两者完全没有继承关系。

小结：

  • 泛型就是编写模板代码来适应任意类型；
  • 泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；
  • 注意泛型的继承关系：可以把ArrayList<Integer>向上转型为List<Integer>（T不能变！），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）。

使用泛型

使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object：

// 编译器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);

此时，只能把<T>当作Object使用，没有发挥泛型的优势。当我们定义泛型类型<String>后，List<T>的泛型接口变为强类型List<String>：

// 无编译器警告:
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
// 无强制转型:
String first = list.get(0);
String second = list.get(1);

当我们定义泛型类型<Number>后，List<T>的泛型接口变为强类型List<Number>：

List<Number> list = new ArrayList<Number>();
list.add(new Integer(123));
list.add(new Double(12.34));
Number first = list.get(0);
Number second = list.get(1);

编译器如果能自动推断出泛型类型，就可以省略后面的泛型类型。例如，对于下面的代码：List list = new ArrayList();编译器看到泛型类型List<Number>就可以自动推断出后面的ArrayList<T>的泛型类型必须是ArrayList<Number>，因此，可以把代码简写为：List list = new ArrayList<>()

泛型接口

例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}

可以直接对String进行排序，因为String本身已经实现了Comparable<String>接口：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
            String[] ss = new String[] { "Orange", "Apple", "Pear" };
        	Arrays.sort(ss);
        	System.out.println(Arrays.toString(ss));
    }
}

自定义的类型要进行排序，则：

// sort
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Person[] ps = new Person[] {
            new Person("Bob", 61),
            new Person("Alice", 88),
            new Person("Lily", 75),
        };
        Arrays.sort(ps);
        System.out.println(Arrays.toString(ps));
    }
}

class Person implements Comparable<Person> {
    String name;
    int score;
    Person(String name, int score) {
        this.name = name;
        this.score = score;
    }
    // 若是缺乏compareTo方法将无法正确排序
    public int compareTo(Person other) {
        return this.name.compareTo(other.name);
    }// 可以正确实现按name进行排序。
    public String toString() {
        return this.name + "," + this.score;
    }
}

小结

  • 用泛型时，把泛型参数<T>替换为需要的class类型，例如：ArrayList<String>，ArrayList<Number>等；
  • 可以省略编译器能自动推断出的类型，例如：List<String> list = new ArrayList<>();；
  • 不指定泛型参数类型时，编译器会给出警告，且只能将<T>视为Object类型；
  • 可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

编写泛型

编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中，例如ArrayList<T>，我们很少需要编写泛型类。需要编写时按照以下步骤：

首先按照某类型，例如：String来编写类：

public class Pair {
    private String first;
    private String last;
    public Pair(String first, String last) {
        this.first = first;
        this.last = last;
    }
    public String getFirst() {
        return first;
    }
    public String getLast() {
        return last;
    }
}

然后，标记所有的特定类型，这里是String替换成T，并申明<T>：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}
静态方法

编写泛型类时，要特别注意，泛型类型<T>不能用于静态方法。例如：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // 对静态方法使用<T>:
    public static Pair<T> create(T first, T last) {
        return new Pair<T>(first, last);
    }
}

我们无法在静态方法create()的方法参数和返回类型上使用泛型类型T。

对于静态方法，我们可以单独改写为“泛型”方法，只需要使用另一个类型即可。对于上面的create()静态方法，我们应该把它改为另一种泛型类型，例如，<K>：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // 静态泛型方法应该使用其他类型区分，此处为K:
    public static <K> Pair<K> create(K first, K last) {
        return new Pair<K>(first, last);
    }
}
多泛型类型

泛型还可以定义多种类型。例如，我们希望Pair不总是存储两个类型一样的对象，就可以使用类型<T, K>：

public class Pair<T, K> {
    private T first;
    private K last;
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

使用时也需要指定两种类型：Pair<String, Integer> p = new Pair<>("test", 123);

小结：

  • 编写泛型时，需要定义泛型类型<T>；
  • 静态方法不能引用泛型类型<T>，必须定义其他类型（例如<K>）来实现静态泛型方法；
  • 泛型可以同时定义多种类型，例如Map<K, V>。

擦拭法

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。JAVA语言的实现方法是擦拭法。所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如：

// 编译器看到的代码
public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}
// 这是虚拟机执行的代码：
public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

在使用时：

// 编译器看到：
Pair<String> p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();
// 虚拟机执行：
Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

局限：

  1. <T>不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：
Pair<int> p = new Pair<>(1, 2); // compile error!

  1. 无法取得带泛型的Class。因为T是Object，我们对Pair<String>和Pair<Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。 所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>。

  2. 无法判断带泛型的类型

  3. 不能实例化T类型。要实例化T类型，我们必须借助额外的Class<T>参数：

    public class Pair<T> {
    private T first;
    private T last;
    public Pair(Class<T> clazz) {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }
}

    上述代码借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>。例如：Pair pair = new Pair<>(String.class);

不恰当的覆写方法

有些时候，一个看似正确定义的方法会无法通过编译。例如：

public class Pair<T> {
    public boolean equals(T t) {
        return this == t;
    }
}

定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object的，编译器会阻止一个实际上会变成覆写的泛型方法定义。

换个方法名，避开与Object.equals(Object)的冲突就可以成功编译：

public class Pair<T> {
    public boolean same(T t) {
        return this == t;
    }
}
泛式继承

一个类可以继承自一个泛型类。例如：父类的类型是Pair<Integer>，子类的类型是IntPair，可以这么继承：

public class IntPair extends Pair<Integer> {
}

使用的时候，因为子类IntPair并没有泛型类型，所以，正常使用即可：

IntPair ip = new IntPair(1, 2);

前面讲了，我们无法获取Pair<T>的T类型，即给定一个变量Pair<Integer> p，无法从p中获取到Integer类型。

在父类是泛型类型的情况下，编译器就必须把类型T（对IntPair来说，也就是Integer类型）保存到子类的class文件中，不然编译器就不知道IntPair只能存取Integer这种类型。在继承了泛型类型的情况下，子类可以获取父类的泛型类型。

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Main {
    public static void main(String[] args) {
        Class<IntPair> clazz = IntPair.class;
        Type t = clazz.getGenericSuperclass();
        if (t instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) t;
            Type[] types = pt.getActualTypeArguments(); // 可能有多个泛型类型
            Type firstType = types[0]; // 取第一个泛型类型
            Class<?> typeClass = (Class<?>) firstType;
            System.out.println(typeClass); // Integer
        }
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

class IntPair extends Pair<Integer> {
    public IntPair(Integer first, Integer last) {
        super(first, last);
    }
}

因为Java引入了泛型，所以，只用Class来标识类型已经不够了。实际上，Java的类型系统结构如下：
在这里插入图片描述小结：

  • Java的泛型是采用擦拭法实现的；
  • 擦拭法决定了泛型<T>：
    • 不能是基本类型，例如：int；
    • 不能获取带泛型类型的Class，例如：Pair<String>.class；
    • 不能判断带泛型类型的类型，例如：x instanceof Pair<String>；
    • 不能实例化T类型，例如：new T()。
  • 泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；
  • 子类可以获取父类的泛型类型<T>。

extends通配符

假设我们定义了Pair<T>：public class Pair<T> { ... }

然后，我们又针对Pair<Number>类型写了一个静态方法，它接收的参数类型是Pair<Number>：

public class PairHelper {
    static int add(Pair<Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

上述代码是可以正常编译的。使用的时候，我们传入：

int sum = PairHelper.add(new Pair<Number>(1, 2));

注意：传入的类型是Pair<Number>，实际参数类型是(Integer, Integer)。既然实际参数是Integer类型，试试传入Pair<Integer>：

public class Main {
        public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);// 报错，因为Pair<Integer>不是Pair<Number>的子类，add(Pair<Number>)不接受参数类型Pair<Integer>。
        System.out.println(n);
    }

    static int add(Pair<Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

实际类型是Integer，引用类型是Number，没有问题。问题在于方法参数类型定死了只能传入Pair<Number>。使用Pair<? extends Number>（上界通配符）使得方法接收所有泛型类型为Number或Number子类（包括Integer、Double、BigDecimal等）的Pair类型。

改写为：

public class Main {
        public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);
        System.out.println(n);
    }
    static int add(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

如果我们考察对Pair<? extends Number>类型调用getFirst()方法，实际的方法签名变成了：<? extends Number> getFirst();

再来考察一下Pair<T>的set方法

public class Main {
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);
        System.out.println(n);
    }
    static int add(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        p.setFirst(new Integer(first.intValue() + 100));// set方法报错
        p.setLast(new Integer(last.intValue() + 100));
        return p.getFirst().intValue() + p.getFirst().intValue();
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public void setLast(T last) {
        this.last = last;
    }
}

原因在于擦拭法。如果我们传入的p是Pair<Double>，显然它满足参数定义Pair<? extends Number>，然而，Pair<Double>的setFirst()显然无法接受Integer类型。

这就是<? extends Number>通配符的一个重要限制：方法参数签名setFirst(? extends Number)无法传递任何Number子类型给setFirst(? extends Number)。

这里唯一的例外是可以给方法参数传入null：

p.setFirst(null); // ok, 但是后面会抛出NullPointerException
p.getFirst().intValue(); // NullPointerException
extends作用

如果我们考察Java标准库的java.util.List<T>接口，它实现的是一个类似“可变数组”的列表，主要功能包括：

public interface List<T> {
    int size(); // 获取个数
    T get(int index); // 根据索引获取指定元素
    void add(T t); // 添加一个新元素
    void remove(T t); // 删除一个已有元素
}

定义一个方法处理列表每个元素：

int sumOfList(List<? extends Integer> list) {// 进行只读的方法
    int sum = 0;
    for (int i=0; i<list.size(); i++) {
        Integer n = list.get(i);
        sum = sum + n;
    }
    return sum;
}

为什么我们定义的方法参数类型是List<? extends Integer>而不是List<Integer>？ 从方法内部代码看，传入List<? extends Integer>或者List<Integer>是完全一样的，但是，注意到List<? extends Integer>的限制：

  • 允许调用get()方法获取Integer的引用；
  • 不允许调用set(? extends Integer)方法并传入任何Integer的引用（null除外）。

因此，方法参数类型List<? extends Integer>表明了该方法内部只会读取List的元素，不会修改List的元素（因为无法调用add(? extends Integer)、remove(? extends Integer)这些方法。换句话说，这是一个对参数List<? extends Integer>进行只读的方法（恶意调用set(null)除外）。

使用extends限定T类型

在定义泛型类型Pair<T>的时候，也可以使用extends通配符来限定T的类型：

public class Pair<T extends Number> { ... }

现在，我们只能定义：

Pair<Number> p1 = null;
Pair<Integer> p2 = new Pair<>(1, 2);
Pair<Double> p3 = null;

因为Number、Integer和Double都符合<T extends Number>。

非Number类型将无法通过编译：

Pair<String> p1 = null; // compile error!
Pair<Object> p2 = null; // compile error!

因为String、Object都不符合<T extends Number>，因为它们不是Number类型或Number的子类。

小结

  • 使用类似<? extends Number>通配符作为方法参数时表示：
    • 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；
    • 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。
  • 即一句话总结：使用extends通配符表示可以读，不能写。
  • 使用类似<T extends Number>定义泛型类时表示：
    • 泛型类型限定为Number以及Number的子类。

super通配符

我们前面已经讲到了泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。

考察下面的set方法：

void set(Pair<Integer> p, Integer first, Integer last) {
    p.setFirst(first);
    p.setLast(last);
}

传入Pair<Integer>是允许的，但是传入Pair<Number>是不允许的。和extends通配符相反，这次，我们希望接受Pair<Integer>类型，以及Pair<Number>、Pair<Object>，因为Number和Object是Integer的父类，setFirst(Number)和setFirst(Object)实际上允许接受Integer类型。使用super通配符来改写这个方法：

void set(Pair<? super Integer> p, Integer first, Integer last) {
    p.setFirst(first);
    p.setLast(last);
}

方法参数接受所有泛型类型为Integer或Integer父类的Pair类型。

唯一可以接收getFirst()方法返回值的是Object类型：Object obj = p.getFirst();

因此，使用<? super Integer>通配符表示：

  • 允许调用set(? super Integer)方法传入Integer的引用；
  • 不允许调用get()方法获得Integer的引用。

唯一例外是可以获取Object的引用：Object o = p.getFirst()。

换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。

对比

作为方法参数，<? extends T>类型和<? super T>类型的区别在于：

  • <? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）；
  • <? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。

一个是允许读不允许写，另一个是允许写不允许读。Producer Extends Consumer Super

即：如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符。

Java标准库的Collections类定义的copy()方法：

public class Collections {
    // 把src的每个元素复制到dest中:
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++) {
            T t = src.get(i);
            dest.add(t);
        }
    }
}

把一个List的元素依次添加到另一个List中。它的第一个参数是List<? super T>，表示目标List，第二个参数List<? extends T>，表示要复制的List。可以简单地用for循环实现复制。在for循环中，我们可以看到，对于类型<? extends T>的变量src，我们可以安全地获取类型T的引用，而对于类型<? super T>的变量dest，我们可以安全地传入T的引用。

这个copy()方法的定义就完美地展示了extends和super的意图：

  • copy()方法内不会读取dest，因为不能调用dest.get()获取T的引用；
  • copy()方法内也不会修改src，因为不能调用src.add(T)。

意外修改了src，或者意外读取了dest，就会导致一个编译错误：

public class Collections {
    // 把src的每个元素复制到dest中:
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        ...
        T t = dest.get(0); // compile error!
        src.add(t); // compile error!
    }
}

这个copy()方法可以安全地把List<Integer>添加到List<Number>，但无法反添加：

// copy List<Integer> to List<Number> ok:
List<Number> numList = ...;
List<Integer> intList = ...;
Collections.copy(numList, intList);

// ERROR: cannot copy List<Number> to List<Integer>:
Collections.copy(intList, numList);

而这些都是通过super和extends通配符，并由编译器强制检查来实现的。

无限定通配符

Java的泛型还允许使用无限定通配符（Unbounded Wildcard Type），即只定义一个?：void sample(Pair<?> p) {}

因为<?>通配符既没有extends，也没有super，因此：

  • 不允许调用set(T)方法并传入引用（null除外）；
  • 不允许调用T get()方法并获取T引用（只能获取Object引用）。

既不能读，也不能写，那只能做一些null判断。大多数情况下，可以引入泛型参数<T>消除<?>通配符：

static boolean isNull(Pair<?> p) {
    return p.getFirst() == null || p.getLast() == null;
}//不可读不可写

static <T> boolean isNull(Pair<T> p) {
    return p.getFirst() == null || p.getLast() == null;
}

<?>通配符有一个独特的特点，就是：Pair<?>是所有Pair<T>的超类，如Pair<Integer>是Pair<?>的子类，可以安全地向上转型。

小结

  • 使用类似<? super Integer>通配符作为方法参数时表示：
    • 方法内部可以调用传入Integer引用的方法，例如：obj.setFirst(Integer n);；
    • 方法内部无法调用获取Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。
  • 即使用super通配符表示只能写不能读。
  • 使用extends和super通配符要遵循PECS原则。
  • 无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类。

泛型和反射

Java的部分反射API也是泛型。例如：Class<T>就是泛型：

// compile warning:
Class clazz = String.class;
String str = (String) clazz.newInstance();

// no warning:
Class<String> clazz = String.class;
String str = clazz.newInstance();

调用Class的getSuperclass()方法返回的Class类型是Class<? super T>：

Class<? super String> sup = String.class.getSuperclass();

构造方法Constructor<T>也是泛型：

Class<Integer> clazz = Integer.class;
Constructor<Integer> cons = clazz.getConstructor(int.class);
Integer i = cons.newInstance(123);

我们可以声明带泛型的数组，但不能用new操作符创建带泛型的数组：

Pair<String>[] ps = null; // ok
Pair<String>[] ps = new Pair<String>[2]; // compile error!

必须通过强制转型实现带泛型的数组：

@SuppressWarnings("unchecked")
Pair<String>[] ps = (Pair<String>[]) new Pair[2];

使用泛型数组要特别小心，因为数组运行期没有泛型，编译器强制检查变量ps，因为类型是泛型数组。但编译器不会检查变量arr，因为它不是泛型数组。因为这两个变量实际上指向同一个数组，所以，操作arr可能导致从ps获取元素时报错，例如，以下代码演示了不安全地使用带泛型的数组：

Pair[] arr = new Pair[2];
Pair<String>[] ps = (Pair<String>[]) arr;

ps[0] = new Pair<String>("a", "b");
arr[1] = new Pair<Integer>(1, 2);

// ClassCastException:
Pair<String> p = ps[1];
String s = p.getFirst();

要安全地使用泛型数组，必须扔掉arr的引用：

@SuppressWarnings("unchecked")
Pair<String>[] ps = (Pair<String>[]) new Pair[2];

上面代码由于拿不到原始数组的引用，就只能对泛型数组ps进行操作，这种操作就是安全的。带泛型的数组实际上是编译器的类型擦除：

Pair[] arr = new Pair[2];
Pair<String>[] ps = (Pair<String>[]) arr;

System.out.println(ps.getClass() == Pair[].class); // true

String s1 = (String) arr[0].getFirst();
String s2 = ps[0].getFirst();

所以我们不能直接创建泛型数组T[]，因为擦拭后代码变为Object[]：

// compile error:
public class Abc<T> {
    T[] createArray() {
        return new T[5];
    }
}

T[] createArray(Class<T> cls) {
    return (T[]) Array.newInstance(cls, 5);
}	// 必须借助`Class<T>`来创建泛型数组;

还可以利用可变参数创建泛型数组T[]：

public class ArrayHelper {
    @SafeVarargs
    static <T> T[] asArray(T... objs) {
        return objs;
    }
}
String[] ss = ArrayHelper.asArray("a", "b", "c");
Integer[] ns = ArrayHelper.asArray(1, 2, 3);
谨慎使用泛型可变参数

在上例中我们看到，通过：

static <T> T[] asArray(T... objs) {
    return objs;
}

似乎可以安全地创建一个泛型数组。但实际上，这种方法非常危险。

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        String[] arr = asArray("one", "two", "three");
        System.out.println(Arrays.toString(arr));
        // ClassCastException:
        String[] firstTwo = pickTwo("one", "two", "three");
        System.out.println(Arrays.toString(firstTwo));
    }

    static <K> K[] pickTwo(K k1, K k2, K k3) {
        return asArray(k1, k2);
    }

    static <T> T[] asArray(T... objs) {
        return objs;
    }
}

直接调用asArray(T...)似乎没有问题，但是在另一个方法中，我们返回一个泛型数组就会产生ClassCastException，原因还是因为擦拭法，在pickTwo()方法内部，编译器无法检测K[]的正确类型，因此返回了Object[]。

如果仔细观察，可以发现编译器对所有可变泛型参数都会发出警告，除非确认完全没有问题，才可以用@SafeVarargs消除警告。

小结

  • 部分反射API是泛型，例如：Class<T>，Constructor<T>；
  • 可以声明带泛型的数组，但不能直接创建带泛型的数组，必须强制转型；
  • 可以通过Array.newInstance(Class<T>, int)创建T[]数组，需要强制转型；
  • 同时使用泛型和可变参数时需要特别小心。
为什么不问问神奇海螺0.0
关注
Java中泛型总结(全面)
qq_29545781的博客
07-28 1820
参考资料： 书：Java编程思想 博客： https://blog.csdn.net/wang__qin/article/details/81415223 https://blog.csdn.net/harvic880925/article/details/49883589 https://blog.csdn.net/qq_27093465/article/details/73229016 ...
java 泛型 json_Java泛型与Json反序列化
weixin_35733852的博客
02-12 1378
Java的JSON库有很多，本文分析google的Gson和alibaba的fastjson，在Java泛型场景反序列化的一些有意思的行为。考虑下面的json字符串：["2147483648","2147483647"]用fastjson在不指定类型的情况下解析，下面的代码输出啥：JSON.parseArray(s).forEach(o -> { System.out.println(o.g...
搞懂泛型
miracleon的博客
11-23 231
文章目录静态泛型方法擦拭法不恰当的覆写方法泛型继承extends通配符extends通配符的作用super通配符对比extends和super通配符PECS原则无限定通配符泛型和反射总结 静态泛型方法 在 static 后加一个 <K> public static <K> Pair<K> create(K first,K last){ retur...
一文搞懂泛型——泛型简介/优点/上界/通配符
噜噜噜噜鲁
11-06 509
一般的类或者方法，只能运用具体的类型：即基本类型、自定义的类。若要编写可以用于多种类型的代码，这种刻板的限制对编写代码的束缚会很大
Java 泛型，上界（生产者），下界（消费者）总结
Rayman的博客
01-03 2226
Java泛型 1，什么是泛型 Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 2，作用 第一是泛化。可以用T代表任意类型Java语言中引入泛型是一个较大的功能增强不仅语言、类型系统和编译器有了较大的变化，以支持...
java中获取泛型参数详解【全网最详细】
yuge1123的博客
09-16 1610
java中所有的类型都继承自Type其中包括Class类也是继承自它，另外它还有四个重要的子类如果调用Method的getGenericParameterTypes()可获取到带泛型的参数。
jdk5.zip_java 泛型_jdk5 泛型_泛型
09-23
Java泛型在运行时会被擦除，因此泛型不提供运行时的类型检查。所有的泛型类和方法都会有一个没有泛型的等价形式，这个过程称为类型擦除。 4. **通配符的使用**： - 无界通配符：`?`，表示类型参数可以是任何类型...
580.578.JAVA基础教程_泛型与File-File类的课后练习(580).rar
11-09
Java编程语言是软件开发领域广泛使用的工具，尤其在企业级应用...通过这个Java基础教程的泛型与File类部分，你将能够更加自如地应对实际项目中的文件操作和类型安全问题。不断实践和总结，你的编程能力将得到显著提升。
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 第08章_泛型(共22页).rar
09-29
Java SE是Java Standard Edition的缩写，它是Java平台的核心部分，主要面向桌面应用和服务器端应用的开发。在本章“第08章_泛型”中，我们将深入探讨Java编程中的一个重要特性——泛型。泛型是Java 5引入的新特性，...
一篇文章带你搞定 Java 中的泛型方法
南淮北安的博客
01-28 627
前面的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。 泛型方法的定义与其所在的类是否是泛型类是没有任何关系的。 文章目录一、定义泛型方法二、通过泛型方法返回泛型类实例三、使用泛型统一传入的参数类型 一、定义泛型方法 在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型： [访问权限] <泛型标识> 泛型标识 方法名称([泛型标识 参数名称]) c...
Java中泛型如何使用，这篇文章教会你
rotobe的博客
02-21 1655
Java中泛型的使用一、什么是泛型？二、泛型的好处三、泛型的定义与使用1.定义使用含有泛型的类2.定义和使用含有泛型的方法3.定义和使用含有泛型的接口四、泛型通配符1.泛型通配符的使用2.泛型通配符的高级使用----受限泛型 一、什么是泛型？ 1.泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。 2.泛型也可以看作是一个变量，用来接收数据类型（注意接收的是数据类型）。 E e:Element 元素 T t:Type 类型 例如：ArrayList集合在定义的时候，不知道集合中都
java笔试 - 套题(1)
zs1972551648的博客
03-04 8847
单选+多选+sql解答+java解答 ...
java中pair的介绍和基本用法
weixin_55076626的博客
12-25 5894
Pair 类在 org.apache.commons.lang3.tuple 包中，提供了 ImmutablePair 和 MutablePair 两个具体实现，分别表示不可变和可变的有序对。请注意，尽管可以使用 Pair，但在某些情况下，创建自定义类以表示更具有描述性的数据结构可能是更好的选择。在 Apache Commons Lang 库中，Pair.of 方法创建的是 ImmutablePair 对象，这意味着通过这个方法创建的 Pair 对象是不可变的。
【面向初学者】泛型
qq_52362955的博客
11-02 314
重新梳理自己对泛型的理解
[简单粗暴]一文彻底搞懂Java泛型中的PECS原则(在坑里躺了多年终于爬出来了)
最新发布
baidu_16992441的博客
05-09 232
List<?extends Fruit> list 限定通配符泛型(还不确定的泛型,但是有范围),一般用于只获取List<?super Fruit> list 限定通配符泛型(还不确定的泛型,但是有范围), 一般用于只添加(也可以获取,但是获取出来的是Object,没啥意义)List list 明确的泛型,可获取,也可添加,也是我们用的最多的泛型。
Java 泛型详解(超详细的java泛型方法解析)
qq_66912832的博客
06-14 1万+
超详细的java泛型方法解析
Java基础知识——泛型
小夏陌的博客
05-14 5185
简介 泛型就是编写模板代码来适应任意类型。即编写一次，万能匹配，又通过编译器保证了类型安全，这就是泛型。 擦拭法 泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同，Java语言的泛型实现方式是擦拭法（Type Erasure），所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。导致了以下两点特性： 编译器把类型<T>视为Object 编译器根据&l...
【Java】Java中Pair的使用
热门推荐
Evelyn的博客
05-06 1万+
做104. 二叉树的最大深度 这道题的时候用到了Pair，是DFS用栈来实现的时候。 Pair类 Pair类在javafx.util 包中 import javafx.util.Pair; 用法 也是键值对的形式 Pair<Integer, String> pair = new Pair<>(1, "One"); Integer key = pair.getKey(); ...
Java泛型编程详解
"Java泛型编程基础" Java泛型是自JDK 1.5版本引入的一种强大的编程特性，它允许在定义类、接口和方法时指定类型参数，从而提高了代码的类型安全性和重用性。泛型的主要目标是增强类型检查，避免在运行时进行强制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值