Java基础总结三（泛型、异常）

最新推荐文章于 2022-08-02 14:44:00 发布

<天各一方>

最新推荐文章于 2022-08-02 14:44:00 发布

阅读量290

点赞数 2

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

本文链接：https://blog.csdn.net/RuntimeExecption/article/details/119104777

版权

Java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

Java基础总结三（泛型、异常）

Java基础总结三（泛型、异常）

泛型

泛型的创建

泛型类

我们最常用泛型的地方就是集合，因此，我们编写自己的List来体会泛型：

public class TestList<T> {

    private Object[] instances = new Object[0];

    public T get(int index) {
        return (T) instances[index];
    }

    public void set(int index,T newInstance) {
        instances[index] = newInstance;
    }

    public void add(T newInstance) {
        instances = Arrays.copyOf(instances,instances.length + 1);
        instances[instances.length - 1] = newInstance;
    }
}

看一下使用方法：

TestList<String> testList = new TestList<>();
testList.add("wlk");
String str = testList.get(0);
System.out.println(str); // wlk

泛型接口

我们除了创建泛型类，泛型接口与其很类似：

public interface Shop <T>{
    T buy();
    float refund(T item);
}

// 实现
public class RealShop<E> implements Shop<E>{
    @Override
    public E buy() {
        return null;
    }

    @Override
    public float refund(E item) {
        return 0;
    }
}

再比如，我们想要实现一个水果商店：

public class Fruit {
}

public class Apple extends Fruit{
}

public class FruitShop<E> implements Shop<E>{
    @Override
    public E buy() {
        return null;
    }

    @Override
    public float refund(E item) {
        return 0;
    }
}

FruitShop<Apple> fruitShop = new FruitShop<>(); // 这个商店卖苹果
FruitShop<Phone> stringShop = new FruitShop<>(); // 这个水果商店卖手机??? 当然不和逻辑

由于我们的商店泛型 E 没有加以限制，会导致错误，我们来给他加上限制：

public class FruitShop<E extends Fruit> implements Shop<E>{
    @Override
    public E buy() {
        return null;
    }

    @Override
    public float refund(E item) {
        return 0;
    }
}

现在这个水果商店只可以卖 Fruit 或者 Fruit 的子类，如Apple，而不能卖手机。

泛型方法

自己声明了泛型的方法

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

我们给我们的苹果商店创建一个方法，它支持用其他水果换取苹果：

public class FruitShop<E extends Fruit> implements Shop<E>{
    @Override
    public E buy() {
        return null;
    }

    @Override
    public float refund(E item) {
        return 0;
    }

    public <T extends Fruit> E exchange(T item){
        return null;
    }
}

// 使用
FruitShop<Apple> appleShop = new FruitShop<>();
Apple apple = appleShop.<Banana>exchange(new Banana());
//类型推导，<Banana>可省略
Apple apple = appleShop.exchange(new Banana());

类型擦除

泛型的好处是在编译期进行类型检查和类型转换，且泛型只在编译期有效。泛型是在 JDK 1.5 里引入的，如果不做泛型擦除，那么 JVM 需要对应使得能正确的的读取和校验泛型信息；另外为了兼容老程序，需为原本不支持泛型的 API 平行添加一套泛型 API。

在运行期，声明时的泛型参数会被擦除，在使用处的泛型会被泛型的父类替换，如<E extends Fruit>，此时使用E的地方会被Fruit替换。

泛型的协变与逆变

定义：如果A、B表示类型，f()表示一个类型的构造函数，Type1≤Type2表示Type1是Type2的子类型，Type1≥Type2表示Type1是Type2的超类型；

f()是协变（covariant）的，当A≤B时有f(A)≤f(B)成立；

f()是逆变（contravariant）的：当A≤B时有f(B)≤f(A)成立；
f()是不变（invariant）的，当A≤B时上述两个式子均不成立，即f(A)与f(B)相互之间没有继承关系。

对于任意两个不同的类型 Type1 和 Type2，不论它们之间具有什么关系，给定泛型类 G<T>，G<Type1> 和 G<Type2> 都是没有关系的，即 Java 中泛型是不变的，而数组是协变的，可以验证以下：

ArrayList<Number> list = new ArrayList<Integer>(); // 编译器报错

// 可以顺利通过编译，正常使用。
Number[] arr = new Integer[5];
arr[0] = 1;
// 但也有一定的问题，这个数组接受Number其他子类也不会在编译期报错，而在运行期报错。泛型从根源杜绝了这种错误

在Java的泛型中，是可以支持协变与逆变的，但会有很大的限制：

? extends T(上边界通配符)实现协变关系，表示?是继承自T的任意子类型。也表示一种约束关系，只能提供数据，不能接收数据。
? super T(下边界通配符)实现逆变关系，表示?是T的任意父类型。也表示一种约束关系，只能接收数据，不能提供数据。

协变所谓只能提供数据，不能接收数据，是指在实例化出泛型类后，仅可以调用该类中返回值为泛型的方法，而不可以调用参数为该泛型的方法。

逆变则恰好相反。

那么如此限制，?在我们实际开发中应该如何应用呢？

List<? extends Number> list = new ArrayList<Integer>();

这样的用法在我们平时是用不到的，只有一些场景化的需要，才会使用到泛型通配符。就拿我们的水果商店举例，我们现在有这样一个需求，需要计算集合中水果的总重量，所以编写了如下方法：

public int totalWeight(List<? extends Fruit> list) {
    int total = 0;
    for(Fruit fruit : list) {
        total += fruit.weight;
    }
    return total;
}

// 使用起来，就可以向这个方法中传入任意Fruit子类的集合了
List<Apple> appleList = new ArrayList<>();
totalWeight(appleList);
List<Banana> bananaList = new ArrayList<>();
totalWeight(bananaList);

再举一个逆变的用法：

List<Apple> appleList = new ArrayList<Fruit>();

当然这种用法是极其少有的，不做讨论。我们给苹果类添加一个方法，这个方法的作用就是给苹果装入集合：

public class Apple extends Fruit{

    public void addToList(List<? super Apple> list) {
        list.add(this);
    }

}

这样，当我们传来Apple集合的时候，就会把Apple装入这个集合，同时，我们也可以传入Fruit的集合：

List<Apple> appleList = new ArrayList<>();
List<Fruit> fruitList = new ArrayList<>();
List<Banana> bananaList = new ArrayList<>();

Apple apple = new Apple();
apple.addToList(appleList); // 编译通过
apple.addToList(fruitList); // 编译通过
apple.addToList(bananaList); // 报错

异常

异常体系

Java中异常的体系是树形结构，所有异常的超类是Throwale，它有俩个子类：Error和Exception，分别表示错误和异常，其中异常类Exception又分为运行时异常(RuntimeException)和非运行时异常，这两种异常有很大的区别，也称之为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。

Error与Exception
- Error是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
- Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常，程序中应当尽可能去处理这些异常。
运行时异常和非运行时异常
- 运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，程序中可以选择捕获处理，也可以不处理。
- 非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类，从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过，如IOException、SQLException等以及用户自定义的Exception异常。

异常处理

在try中return后，依旧会执行finally。
finally语句在return语句执行之后return返回之前执行的。
finally块中的return语句会覆盖try块中的return返回。
如果finally语句中没有return语句覆盖返回值，那么原来的返回值可能因为finally里的修改而改变也可能不变(具体区分值和引用)。
当发生异常后，catch中的return执行情况与未发生异常时try中return的执行情况完全一样。
在Java中如果不发生异常的话，try/catch不会造成任何性能损失。在 Java 类编译后，正常流程与异常处理部分是分开的，类会跟随一张异常表，每一个try-catch都会在这个表里添加行记录。当执行抛出了异常时，首先去异常表中查找是否可以被catch，如果可以则跳到异常处理的起始位置开始处理，如果没有则原地return，并且copy异常的引用给父调用方，接着看父调用的异常表，以此类推。

我们来看一个例子：

public int test(){
    int i = 1;
    try {
        i++;
        return i;
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        System.out.println("finally");
        i++;
    }
    return 0;
}

System.out.println(test()); 

// out ->
finally
2

我们看到，finally执行了，那么i++应该也是执行了，为什么返回2，我们通过查看字节码可知

Code:
      stack=2, locals=4, args_size=1
         0: iconst_1
         1: istore_1
         2: iinc          1, 1
         5: iload_1
         6: istore_2
         7: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: ldc           #12                 // String finally
        12: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        15: iinc          1, 1
        18: iload_2
        19: ireturn
        20: astore_2
        21: aload_2
        22: invokevirtual #15                 // Method java/lang/Exception.printStackTrace:()V
        25: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        28: ldc           #12                 // String finally
        30: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        33: iinc          1, 1
        36: goto          53
        39: astore_3
        40: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        43: ldc           #12                 // String finally
        45: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        48: iinc          1, 1
        51: aload_3
        52: athrow
        53: iconst_0
        54: ireturn

总结一下，总体的意思就是，当执行完try块的时候，会计算return表达式的值，然后把这个返回值存在另一个临时变量里面，最后返回的时候会重新读取存放的变量，因此在finally后面无论如何修改，都不会影响返回值。那么，如果finally中加了return后，结果就会覆盖原有的返回值了。

<天各一方>

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java基础总结三（泛型、异常）

文章目录Java基础总结三（泛型、异常）泛型泛型的创建泛型类泛型接口泛型方法类型擦除泛型的协变与逆变异常异常体系异常处理Java基础总结三（泛型、异常）泛型泛型的创建泛型类我们最常用泛型的地方就是集合，因此，我们编写自己的List来体会泛型：public class TestList<T> { private Object[] instances = new Object[0]; public T get(int index) { return (
复制链接

扫一扫

专栏目录