一、异常和反射

杨大大...大约 10 分钟

1.异常

1.1Java异常类层次结构?

Throwable是 Java 语言中所有错误与异常的超类。

  • Error 类及其子类：程序中无法处理的错误，表示运行应用程序中出现了严重的错误。
  • Exception 程序本身可以捕获并且可以处理的异常。Exception 这种异常又分为两类：运行时异常和编译时异常。
  • 运行时异常

都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

  • 非运行时异常 （编译异常）

是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

1.2可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）区别？

  • 可查异常（编译器要求必须处置的异常）：

正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

  • 不可查异常(编译器不要求强制处置的异常)

包括运行时异常（RuntimeException与其子类）和错误（Error）。

1.3throw和throws的区别？

  • 异常的申明(throws)

在Java中，当前执行的语句必属于某个方法，Java解释器调用main方法执行开始执行程序。若方法中存在检查异常，如果不对其捕获，那必须在方法头中显式声明该异常，以便于告知方法调用者此方法有异常，需要进行处理。 在方法中声明一个异常，方法头中使用关键字throws，后面接上要声明的异常。若声明多个异常，则使用逗号分割。如下所示：

public static void method() throws IOException, FileNotFoundException{
    //something statements
}
  • 异常的抛出(throw)

如果代码可能会引发某种错误，可以创建一个合适的异常类实例并抛出它，这就是抛出异常。如下所示：

public static double method(int value) {
    if(value == 0) {
        throw new ArithmeticException("参数不能为0"); //抛出一个运行时异常
    }
    return 5.0 / value;
}

1.4Java 7 的 try-with-resource?

如果你的资源实现了 AutoCloseable 接口，你可以使用这个语法。大多数的 Java 标准资源都继承了这个接口。当你在 try 子句中打开资源，资源会在 try 代码块执行后或异常处理后自动关闭。

public void automaticallyCloseResource() {
    File file = new File("./tmp.txt");
    try (FileInputStream inputStream = new FileInputStream(file);) {
        // use the inputStream to read a file
    } catch (FileNotFoundException e) {
        log.error(e);
    } catch (IOException e) {
        log.error(e);
    }
}

看下它的背后：

public static transient void main(String args[])
    {
        BufferedReader br;
        Throwable throwable;
        br = new BufferedReader(new FileReader("d:\\ hollischuang.xml"));
        throwable = null;
        String line;
        try
        {
            while((line = br.readLine()) != null)
                System.out.println(line);
        }
        catch(Throwable throwable2)
        {
            throwable = throwable2;
            throw throwable2;
        }
        if(br != null)
            if(throwable != null)
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
            else
                br.close();
            break MISSING_BLOCK_LABEL_113;
            Exception exception;
            exception;
            if(br != null)
                if(throwable != null)
                    try
                    {
                        br.close();
                    }
                    catch(Throwable throwable3)
                      {
                        throwable.addSuppressed(throwable3);
                    }
                else
                    br.close();
        throw exception;
        IOException ioexception;
        ioexception;
    }
}

其实背后的原理也很简单，那些我们没有做的关闭资源的操作，编译器都帮我们做了。所以，再次印证了，语法糖的作用就是方便程序员的使用，但最终还是要转成编译器认识的语言。

1.5finally和return的执行顺序

try() ⾥⾯有⼀个return语句， 那么后⾯的finally{}⾥⾯的code会不会被执⾏， 什么时候执⾏， 是在return前还是return后?

如果try中有return语句， 那么finally中的代码还是会执⾏。因为return表⽰的是要整个⽅法体返回， 所以，finally中的语句会在return之前执⾏。

但是return前执行的finally块内，对数据的修改效果对于引用类型和值类型会不同：

// 测试 修改值类型
static int f() {
    int ret = 0;
    try {
        return ret;  // 返回 0，finally内的修改效果不起作用
    } finally {
        ret++;
        System.out.println("finally执行");
    }
}

// 测试 修改引用类型
static int[] f2(){
    int[] ret = new int[]{0};
    try {
        return ret;  // 返回 [1]，finally内的修改效果起了作用
    } finally {
        ret[0]++;
        System.out.println("finally执行");
    }
}

1.6异常的底层？

提到JVM处理异常的机制，就需要提及Exception Table，以下称为异常表。我们暂且不急于介绍异常表，先看一个简单的 Java 处理异常的小例子。

public static void simpleTryCatch() {
   try {
       testNPE();
   } catch (Exception e) {
       e.printStackTrace();
   }
}

使用javap来分析这段代码（需要先使用javac编译）：

//javap -c Main
 public static void simpleTryCatch();
    Code:
       0: invokestatic  #3                  // Method testNPE:()V
       3: goto          11
       6: astore_0
       7: aload_0
       8: invokevirtual #5                  // Method java/lang/Exception.printStackTrace:()V
      11: return
    Exception table:
       from    to  target type
           0     3     6   Class java/lang/Exception

看到上面的代码，应该会有会心一笑，因为终于看到了Exception table，也就是我们要研究的异常表。

异常表中包含了一个或多个异常处理者(Exception Handler)的信息，这些信息包含如下

  • from 可能发生异常的起始点
  • to 可能发生异常的结束点
  • target 上述from和to之前发生异常后的异常处理者的位置
  • type 异常处理者处理的异常的类信息

2.反射

2.1什么是反射机制?

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的法的功能称为java语言的反射机制。

直接new对象就叫正射。

如下:

Map<String, String> map = new HashMap<>();
map.put("蔡徐鸡","唱跳rap篮球");

那反射是啥？我先不说反射是啥，概念啥的太虚幻我就不说了，把你绕蒙你这篇文章就白看了，直接举例吧接着看上面的正射，如果哪天你发现用LinkedHashMap效果更好，然后你修改代码：

Map<String, String> map = new LinkedHashMap<>();
map.put("蔡徐鸡","唱跳rap篮球");

改完了编译运行没有bug然而过了两天你发现用LinkedHashMap会有隐患，还是得改回去用HashMap，成年人的崩溃如此简单，但是聪明的你想到可以加个判断，根据传入的条件来决定用HashMap还LinkedHashMap，于是：

public Map<String, String> getMap(String param) {
    Map<String, String> map = null;
    if (param.equals("HashMap")) {
        map = new HashMap<>();
    } else if (param.equals("LinkedHashMap")) {
        map = new LinkedHashMap<>();
     }
   return map;
 }

大功告成，这么难的逻辑都被你实现了，然后你得用TreeMap，你又要改代码。

有没有一种办法可以让你不修改代码呢，这时候反射就派上用场了。

概念：反射是Java的一种机制，让我们可以在运行时获取类的信息;

作用：通过反射，我们可以在程序运行时动态创建对象，还能获取到类的所有信息，比如它的属性、构造器、方法、注解等；

直接举例吧：

public Map<String, String> getMap(String className) {
    Class clazz = Class.forName(className);
    Constructor constructor = clazz.getConstructor();
    return (Map<String, String>) constructor.newInstance();
}

这时候不管你需要什么Map，只要实现了Map接口，你都能通过getMap获得，只需要传入对应Map的全限定名，例如java.util.HashMap / java.util.LinkedHashMap。

java中反射的用法非常非常多，常见的有以下这几个：

一、在运行时获取一个类的 Class 对象
二、在运行时构造一个类的实例化对象
三、在运行时获取一个类的所有信息：变量、方法、构造器、注解

2.2获取class对象

三种方法： 1、类名.class：这种获取方式只有在编译前已经声明了该类的类型才能获取到 Class 对象

Class<HashMap> hashMap= HashMap.class;

2、实例.getClass()：通过实例化对象获取该实例的 Class 对象

Map<String, String> hashMap = new HashMap<>();
Class<? extends Map> hashMapClass = hashMap.getClass();

3、Class.forName(“类的全限定名”)：通过类的全限定名获取该类的 Class 对象

Class<?> hashMap= Class.forName("java.util.HashMap");

拿到 Class对象就可以对它为所欲为了：调用它的方法、获取属性、获取类信息，总之它在你面前就没有隐私了，好羞羞，嘤~。

2.3构造类的实例化对象

通过反射构造一个类的实例方式有2种： 1、Class 对象调用newInstance()方法

Class<?> hashMapClass = Class.forName("java.util.HashMap");
HashMap hashMapInstance = (HashMap) hashMapClass.newInstance();

注意：即使 HashMap已经显式定义了构造方法，通过 newInstance() 创建的实例中，所有属性值都是对应类型的初始值，因为 newInstance() 构造实例会调用默认无参构造器。

2、Constructor 构造器调用newInstance()方法

Class<?> hashMapClass = Class.forName("java.util.HashMap");
Constructor<?> constructor = hashMapClass.getConstructor();
constructor.setAccessible(true);
HashMap newInstance = (HashMap) constructor.newInstance();

通过 getConstructor(Object… paramTypes) 方法指定获取指定参数类型的 Constructor， Constructor 调用 newInstance(Object… paramValues) 时传入构造方法参数的值，同样可以构造一个实例，且内部属性已经被赋值。

通过Class对象调用 newInstance() 会走默认无参构造方法，如果想通过显式构造方法构造实例，需要提前从Class中调用getConstructor()方法获取对应的构造器，通过构造器去实例化对象。

2.4获取类的所有信息

1、获取类中的变量（Field）

  • Field[] getFields()：获取类中所有被public修饰的所有变量
  • Field getField(String name)：根据变量名获取类中的一个变量，该变量必须被public修饰
  • Field[] getDeclaredFields()：获取类中所有的变量，但无法获取继承下来的变量
  • Field getDeclaredField(String name)：根据姓名获取类中的某个变量，无法获取继承下来的变量

2、获取类中的方法（Method）

  • Method[] getMethods()：获取类中被public修饰的所有方法
  • Method getMethod(String name, Class…<?>paramTypes)：根据名字和参数类型获取对应方法，该方法必须被public修饰
  • Method[] getDeclaredMethods()：获取所有方法，但无法获取继承下来的方法
  • Method getDeclaredMethod(String name, Class…<?>paramTypes)：根据名字和参数类型获取对应方法，无法获取继承下来的方法

3、获取类的构造器（Constructor）

  • Constuctor[] getConstructors()：获取类中所有被public修饰的构造器 Constructor
  • getConstructor(Class…<?> paramTypes)：根据参数类型获取类中某个构造器，该构造器必须被public修饰
  • Constructor[] getDeclaredConstructors()：获取类中所有构造器 Constructor
  • getDeclaredConstructor(class…<?> paramTypes)：根据参数类型获取对应的构造器

反射的应用场景

  • Spring 实例化对象：当程序启动时，Spring 会读取配置文件applicationContext.xml并解析出里面所有的标签实例化到IOC容器中。
  • 反射 + 工厂模式：通过反射消除工厂中的多个分支，如果需要生产新的类，无需关注工厂类，工厂类可以应对各种新增的类，反射可以使得程序更加健壮。
  • JDBC连接数据库：使用JDBC连接数据库时，指定连接数据库的驱动类时用到反射加载驱动类

参考：https://blog.csdn.net/qq_33709582/article/details/113550163open in new window

© 2023-present 鲁ICP备19028049号
Copyright © 2024 杨大大