Java高级知识 — 泛型

最新推荐文章于 2024-03-06 15:18:28 发布

喵王叭

最新推荐文章于 2024-03-06 15:18:28 发布

阅读量212

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_40815218/article/details/106094161

版权

Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章目录

一、概述
- 1.1 定义和作用
- 1.2 特性
二、泛型的使用
三、类型变量的限定
四、泛型代码和虚拟机（类型擦除机制）
- 4.1 翻译泛型表达式
- 4.2 翻译泛型方法
五、泛型中的约束和局限性
五、泛型类型继承规则
六、通配符类型
- 6.1 三种情况
- 6.2 通配符捕获
七、总结

参考书目：《Java核心技术卷 I》第12章
参考文章：
Java泛型详解 (和书中章节比较对应)
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一

一、概述

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

1.1 定义和作用

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型测试","item = " + item);
}

毫无疑问，程序的运行结果会以崩溃结束：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(100); 在编译阶段，编译器就会报错

1.2 特性

泛型只在编译阶段有效。看下面的代码：

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}

输出结果：D/泛型测试: 类型相同。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

二、泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

2.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类的最基本写法（这么看可能会有点晕，会在下面的例子中详解）：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....
  }
}

一个最普通的泛型类：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());

12-27 09:20:04.432 13063-13063/? D/泛型测试: key is 123456
12-27 09:20:04.432 13063-13063/? D/泛型测试: key is key_vlaue

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

看一个例子：

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

Log.d("泛型测试","key is " + generic.getKey());
Log.d("泛型测试","key is " + generic1.getKey());
Log.d("泛型测试","key is " + generic2.getKey());
Log.d("泛型测试","key is " + generic3.getKey());

D/泛型测试: key is 111111
D/泛型测试: key is 4444
D/泛型测试: key is 55.55
D/泛型测试: key is false

注意：
泛型的类型参数只能是类类型，不能是简单类型。
不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

if(ex_num instanceof Generic<Number>){
}

2.2 泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

当实现泛型接口的类，未传入泛型实参时：

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

当实现泛型接口的类，传入泛型实参时：

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

2.3 泛型方法

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。

尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

Object obj = genericMethod(Class.forName(“com.test.test”));

2.3.1 泛型方法的基本用法

光看上面的例子有的同学可能依然会非常迷糊，我们再通过一个例子，把我泛型方法再总结一下。

public class GenericTest {
   //这个类是个泛型类，在上面已经介绍过
   public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

     /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
    public void showkey(T genericObj){

    }
    */

    public static void main(String[] args) {


    }
}

2.3.2 类中的泛型方法

当然这并不是泛型方法的全部，泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

2.3.3 泛型方法与可变参数

再看一个泛型方法和可变参数的例子：

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型测试","t is " + t);
    }
}
...
printMsg("111",222,"aaaa","2323.4",55.55);

2.3.4 静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

2.3.5 泛型方法总结

泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：

无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外，static修饰的方法无法访问泛型类型的参数，所以如果static方法要使用泛型能力，就必须使其成为泛型方法。

三、类型变量的限定

有时，类或方法需要对类型变量加以约束。例如下面代码中getMin需要调用compareTo方法，则需要确保T所属的类有compareTo方法。
解决方案是将T限制为实现了 Comparable接口（只含一个方法compareTo的 标准接口）的类。可以通过对类型变量T设置限定（bound）实现这一点。

1）对类的限定：public class TypeLimitForClass<T extends List & Serializable>{}
2）对方法的限定：public static<T extends Comparable>T getMin(T a, T b) {}

/**
 * Author：Jay On 2019/5/10 16:38
 * <p>
 * Description: 类型变量的限定-方法
 */
public class TypeLimitForMethod {

    /**
     * 计算最小值
     * 如果要实现这样的功能就需要对泛型方法的类型做出限定
     */
//    private static <T> T getMin(T a, T b) {
//        return (a.compareTo(b) > 0) ? a : b;
//    }

    /**
     * 限定类型使用extends关键字指定，尽管Comparable是一个接口，这是出于一个类型变量或通配符可以有多个限定的考虑。
     * 可以使类，接口，类放在前面接口放在后面用&符号分割
     * 例如：<T extends ArrayList & Comparable<T> & Serializable>
     */
    public static <T extends Comparable<T>> T getMin(T a, T b) {
        return (a.compareTo(b) < 0) ? a : b;
    }

    public static void main(String[] args) {
        System.out.println(TypeLimitForMethod.getMin(2, 4));
        System.out.println(TypeLimitForMethod.getMin("a", "r"));
    }
}

四、泛型代码和虚拟机（类型擦除机制）

虚拟机没有泛型类型对象——所有对象都属于普通类。
无论何时定义一个泛型类型，虚拟机都自动提供了一个相应的原始类型（raw type）。原始类型 的名字就是删去类型参数后的泛型类型名。擦除（erased）类型变量，并替换为第一个限定的类型变量（无 限定的变量用Object）。

4.1 翻译泛型表达式

当程序调用泛型方法时，如果擦除返回类型，编译器插入强制类型转换。例如,下面这 个语句序列

Pair<Employee> buddies = ...;
Employee buddy = buddies.getFirst();

擦除getFirst的返回类型后将返回Object类型。编译器自动插入Employee的强制类型转换。 也就是说，编译器把这个方法调用翻译为两条虚拟机指令： 
• 对原始方法Pair.getFirst的调用。 
• 将返回的Object类型强制转换为Employee类型。 
当存取一个泛型域时也要插入强制类型转换。假设Pair类的first域和second域都是公 有的（也许这不是一种好的编程风格，但在Java中是合法的）。
表达式：

 Employee buddy = buddies.first;

也会在结果字节码中插入强制类型。

4.2 翻译泛型方法

类型擦除也会出现在泛型方法中。程序员通常认为下述的泛型方法

public static <T extends Comparable> T min(T[] a)

是一个完整的方法族，而擦除类型之后，只剰下一个方法：

public static Comparable min(Comparable[] a)

注意,类型参数T已经被擦除了，只留下了限定类型Comparable。

同样地，方法的擦除可能导致和多态产生冲突：

public class Pair<T>{
    Object val = null;
    public void setVal(Object obj){
        this.val = obj;
    }
}

public class DateInterval extends Pair<Date>{
    @Override
    public void setVal(Date date){
        super.setVal(date);
    }
}

擦除后，DateInterval类中存在两个参数列表相同的方法：

Date getSecond(); // defined in Dateinterval 
Object getSecond(); // overrides the method defined in Pair to call the first method

没有参数。但是，在虚拟机中，用参数类型和返回类型确定一个方法。因此，编译器可能产 生两个仅返回类型不同的方法字节码，虚拟机能正确地处理这一情况。
注释：桥方法不仅用于泛型类型。第5章已经讲过，在一个方法覆盖另一个方法时可以 指定一个更严格的返回类型。

总之，需要记住有关 Java 泛型转换的事实：

虚拟机中没有泛型，只有普通的类和方法。
所有的类型参数都用它们的限定类型替换。
桥方法被合成来保持多态。
为保持类型安全性，必要时插入强制类型转换。

五、泛型中的约束和局限性

5.1 不能实例化泛型类（类型变量）

不能使用像new T(…)，new T[…]或T.class这样的表达式中的类型变量。
例如，下面的 Pair构造器就是非法的：

public Pair() { first = new T(); second = new T()； } // ERROR

类型擦除将T改变成Object，而且，本意肯定不希望调用new Object( )。但是，可以通过反 射调用Class.newlnstance方法来构造泛型对象。
同样不能调用：

 first = T.class.newInstance()； // ERROR ，表达式T.class是不合法的

想通过反射调用，必须像下面这样设计API以便可以支配Class对象：

public static <T> Pair<T> makePair(Class<T> cl) {
	 try {  return new Pair<>(cl.newInstance(),  cl.newInstance()); } 
	  catch (Exception ex) {  return null;  } 
 }

这个方法可以按照下列方式调用：

 Pair<String> p = Pair.makePair(String.class);

注意,Class类本身是泛型。例如，Stringxlass是一个Class的实例(事实上, 它是唯一的实例)。因此.makePair方法能够推断出pair的类型。

5.2 静态变量或方法不能引用泛型类型变量

在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {
    ...
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){
    }
}

5.3 基本类型无法作为泛型类型

不能用类型参数代替基本类型。因此，没有Pair，只有Pair。
当然，其原因是类型擦除。擦除之后，Pair类含有Object类型的域，而Object不能存储double值。

5.4 运行时类型查询只适用于原始类型

虚拟机中的对象总有一个特定的非泛型类型。因此，所有的类型査询只产生原始类型。 例如：

 if (a instanceof Pair<String>) // ERROR 
  if (a instanceof Pair<T>) // ERROR 
//  实际上仅仅测试a是否是任意类型的一个Pair
 // 或强制类型转换：
   Pair<String> p = (Pair<String>) a; // WARNINC-can only test that a is a Pair

要记住这一风险，无论何时使用 instanceof 或涉及泛型类型的强制类型转换表达式都会 看到一个编译器警告。 
  
  同样的道理，getClass方法总是返回原始类型。例如：

   Pair<String> stringPair = ...;
    Pair<Employee> employeePair =...;
     if (stringPair.getClass() == enployeePair.getClass()) // they are equal

其比较的结果是true,这是因为两次调用getClass都将返回Pair.class
因为     泛型类的原生类型与所传递的泛型无关，无论传递什么类型，原生类是一样的。

5.5 泛型数组可以声明但无法实例化

不能实例化参数化类型的数组，例如：

 Pair<String>[] table = new Pair<String>[10]; //ERROR
//   这有什么问题呢？
//   擦除之后，table的类型是Pair[]。可以把它转换为Object： 
  Object[] objarray = table; 
//   数组会记住它的元素类型，如果试图存储其他类型的元素，就会抛出一个 ArrayStoreException 异常：
   objarray[0] = "Hello"; // ERROR-component type is Pair 
//    不过对于泛型类型，擦除会使这种机制无效。

//    以下赋值    能够通过数组存储检査，不过仍会导致一个类型错误。
    objarray[0] = new Pair<Employee>();

出于这个原因，不允许创建参数 化类型的数组。 需要说明的是，只是不允许创建这些数组，而声明类型为 Pair[] 的变量仍是合法 的。不过不能用new Pair[10]初始化这个变量。

解决方案
可以声明通配类型的数组，然后进行类型转换：

Pair<String>[] table = (Pair<String>[])new Pair<?>[10];

但这样做将无法保证存入的数据一定是符合指定类型的。如果在table[0]中存储一个 Pair ，然后对 table[0]. getFirst() 调用一个 String 方法，会得到一个 ClassCastException 异常。
提示：如果需要收集参数化类型对象，只有一种安全而有效的方法：使用ArrayList，Arra yList<Pair> 。

5.6 可变参数方法传递泛型类型的实例

上一节中已经了解到，Java不支持泛型类型的数组。这一节中我们再来讨论一个相关的问题：
向参数个数可变的方法传递一个泛型类型的实例。

考虑下面这个简单的方法，它的参数个数是可变的：

public static <T> void addAll(Collection<T> coll, T... ts)
{
	for (T t : ts) coll.add(t);
}

应该记得，实际上参数ts是一个数组，包含提供的所有实参。
现在考虑以下调用：

Collection<Pair<String>> table = ...;
Pair<String> pair1 = ...;
Pair<String> pair2 = ...;
addAll(table, pair1, pair2);

为了调用这个方法，Java虚拟机必须建立一个Pair数组，这就违反了前面的规则。不过，对于这种情况，规则有所放松，你只会得到一个警告( Varargs )，而不是错误。
可以采用两种方法来抑制这个警吿。
一种方法是为包含addAll调用的方法增加标注@SuppressWarnings(“unchecked”)；
另一种方法，在 Java SE 7 中，还可以用 @SafeVarargs 直接标注addAll 方法：

@SafeVarargs
public static <T> void addAll(Collection<T> coll, T... ts)

现在就可以提供泛型类型来调用这个方法了。
注意：
使用这个注解时，必须是可变参数方法和构造器；
如果是可变参数的方法，那么必须是static和final的。

5.7 不能抛出或捕获泛型类的实例

泛型类不能继承Exception或者Throwable，
不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出。

public class GenericRestrict2 {

    private class MyException extends Exception {
    }

    /**
     * 泛型类不能继承Exception或者Throwable
     * Generic class may not extend 'java.lang.Throwable'
     */
//    private class MyGenericException<T> extends Exception {
//    }
//
//    private class MyGenericThrowable<T> extends Throwable {
//    }

    /**
     * 不能捕获泛型类型限定的异常
     * Cannot catch type parameters
     */
    public <T extends Exception> void getException(T t) {
//        try {
//
//        } catch (T e) {
//
//        }
    }

    /**
     *可以将泛型限定的异常抛出
     */
    public <T extends Throwable> void getException(T t) throws T {
        try {

        } catch (Exception e) {
            throw t;
        }
    }
}

五、泛型类型继承规则

1）对于泛型参数是继承关系的泛型类之间是没有继承关系的
2）泛型类可以继承其它泛型类，例如: public class ArrayList extends AbstractList
3）泛型类的继承关系在使用中同样会受到泛型类型的影响

//泛型继承规则测试类
public class GenericInherit<T> {
    private T data1;
    private T data2;

    public T getData1() {
        return data1;
    }

    public void setData1(T data1) {
        this.data1 = data1;
    }

    public T getData2() {
        return data2;
    }

    public void setData2(T data2) {
        this.data2 = data2;
    }

    public static <V> void setData2(GenericInherit<Father> data2) {

    }

    public static void main(String[] args) {
//        Son 继承自 Father
        Father father = new Father();
        Son son = new Son();
        GenericInherit<Father> fatherGenericInherit = new GenericInherit<>();
        GenericInherit<Son> sonGenericInherit = new GenericInherit<>();
        SubGenericInherit<Father> fatherSubGenericInherit = new SubGenericInherit<>();
        SubGenericInherit<Son> sonSubGenericInherit = new SubGenericInherit<>();

        /**
         * 对于传递的泛型类型是继承关系的泛型类之间是没有继承关系的
         * GenericInherit<Father> 与GenericInherit<Son> 没有继承关系
         * Incompatible types.
         */
        father = new Son();
//        fatherGenericInherit=new GenericInherit<Son>();

        /**
         * 泛型类可以继承其它泛型类，例如: public class ArrayList<E> extends AbstractList<E>
         */
        fatherGenericInherit=new SubGenericInherit<Father>();

        /**
         *泛型类的继承关系在使用中同样会受到泛型类型的影响
         */
        setData2(fatherGenericInherit);
//        setData2(sonGenericInherit);
        setData2(fatherSubGenericInherit);
//        setData2(sonSubGenericInherit);

    }

    private static class SubGenericInherit<T> extends GenericInherit<T> {

    }

六、通配符类型

6.1 三种情况

参考文章
Java 泛型 <? super T> 中 super 怎么理解？与 extends 有何不同？

1）<? extends Parent> 指定了泛型类型的上界，类似于类型变量的限定
2）<? super Child> 指定了泛型类型的下界（又称超类型限定）
3）<?> 指定了没有限制的泛型类型（无限定通配符）
类型Pair<?>有方法如下所示：

? getFirst();
 void setFirst(?) ;

getFirst的返回值只能赋给一个Object。setFirst方法不能被调用，甚至不能用Object调 用。
 和Pair类型的不同在于：可以用任意Object对象调用原始的Pair类的setObject 方法。 
 注释：可以调用setFirst(null)。

6.2 通配符捕获

编写一个交换一个pair元素的方法:

public static void swap(Pair<?> p)

通配符不是类型变量，因此，不能在编写代码中使用 ? 作为一种类型。也就是说，下述使用 代码是非法的：

? t = p.getFirst(); // ERROR 
p.setFirst(p.getSecond());
p.setSecond(t);

这是一个问题，因为在交换的时候必须临时保存第一个元素。
解决方案
可以写一个辅助方法swapHelper，如下所示：

public static<T> void swapHelper(Pair<T> p) { 
	T t = p.getFirst()；
	 p.setFirst(p.getSecond()); 
	p.setSecond(t);
}

public static void swap(Pair<?> p)  { swapHelper(p); }

注意，swapHelper是一个泛型方法，而swap不是，它具有固定的Pair<?>类型的参数。
可以用swap调用swapHelper：

在这种情况下，swapHelper方法的参数T捕获通配符。它不知道是哪种类型的通配符，但是，这是一个明确的类型，并且swapHelper的定义只有在T指出类型时才有明确的含义。

七、总结

本文中的例子主要是为了阐述泛型中的一些思想而简单举出的，并不一定有着实际的可用性。另外，一提到泛型，相信大家用到最多的就是在集合中，其实，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。

喵王叭

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java高级知识 — 泛型

文章目录一、概述1.1 定义和作用1.2 特性二、泛型的使用2.1 泛型类2.2 泛型接口2.3 泛型方法2.3.1 泛型方法的基本用法2.3.2 类中的泛型方法2.3.3 泛型方法与可变参数2.3.4 静态方法与泛型2.3.5 泛型方法总结三、类型变量的限定四、泛型代码和虚拟机（类型擦除）五、泛型中的约束和局限性5.1 不能实例化泛型类（类型变量）5.2 静态变量或方法不能引用泛型类型变量5.3 基本类型无法作为泛型类型5.4 运行时类型查询只适用于原始类型5.5 泛型数组可以声明但无法实例化5.6 Va
复制链接

扫一扫