JAVA异常

最新推荐文章于 2024-10-06 20:16:20 发布

夜僚鹰

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量147

点赞数

分类专栏： JAVA笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_45814179/article/details/127192826

版权

JAVA笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

异常

编译时异常和运行时异常

粉红色的是受检查的异常(checked exceptions),其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.受检查的异常必须在编译时被捕捉处理,命名为 Checked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守；Throwable、Exception、IOException、ClassNotFoundException、CloneNotSupportedException、EOFException、 FileNotFoundException、MalformedURLException、UnknownHostException
绿色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如空指针,被0除…；RuntimeException、ArithmeticException、ClassCastException、IllegalArgumentException、IllegalStateException、IndexOutOfBoundsException、NoSuchElementException、NullPointerException
而声明为Error的，则属于严重错误，如系统崩溃、虚拟机错误、动态链接失败等，这些错误无法恢复或者不可能捕捉，将导致应用程序中断，Error不需要捕捉。

含义

Throwable：(在Java.lang包下) 有两个重要的子类：Exception(异常)和 Error(错误) ；二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error(错误)：是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM出现的问题。

Exception(异常)：是程序本身可以处理的异常。

ClassNotFoundException：找不到指定的class

CloneNotSupportedException：不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。

IOException：读写异常，一般在读写数据的时候会出现这种问题。

EOFException：END OF FILE的缩写；当输入过程中意外到达文件或流的末尾，抛出此异常；
FileNotFoundException：这个异常抛出俩种情况：一是“拒绝访问”，二是“系统找不到指定路径”。在构造一个File对象时，指定的文件路径是什么都可以，就算不存在也能够构造File对象，但是，现在你要对文件进行输入输出操作，也就是InputStream和OutputStream操作时，如果填写的路径不存在，那么就会报系统找不到指定路径，如果指定的是目录时，就会报拒绝访问异常。
MalformedURLException：抛出以表示发生格式不正确的网址。在规范字符串中找不到任何合法协议，或者无法解析字符串。
UnknownHostException：如果在创建与远程主机的远程方法调用的 java.net.UnknownHostException时发生 UnknownHostException则抛出 java.net.UnknownHostException 。

RuntimeException：是在Java虚拟机的正常操作期间可以抛出的那些异常的超类。

ArithmeticException：算术运算异常，一个整数除以0时，抛出该异常。
ClassCastException：类型转化异常。
IllegAlargumentException：非法参数异常，当传入的参数违反了一个方法要求的某些特性时，抛出该异常。
IllegalStateException：表示在非法或不适当的时间调用了一种方法。换句话说，Java环境或Java应用程序对于请求的操作并不处于适当的状态。
IndexOutOfBoundsException：抛出以表示某种索引（例如数组，字符串或向量）的索引超出范围
NoSuchElementException：被各种访问器方法抛出，表示被请求的元素不存在
NullPointerException：要访问的变量没有引用任何对象时，抛出该异常。

异常处理语句

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。

catch 块：用于处理try捕获到的异常。

finally 块：finally块不管异常是否发生，只要对应的try执行了，则它一定也执行。只有一种方法让finally块不执行：System.exit()。因此finally块通常用来做资源释放操作：关闭文件，关闭数据库连接等等。

throw：throw 是用在某个方法的方法体内的，当我们认定某种情况不合理时，就可以创建异常对象，封装好异常信息，然后通过 throw 来抛出异常并终止该方法。

public class CustomerLevel {
    // 性别
    private String level;

    public String getLevel() {
        return level;
    }
    
    public void setLevel(String level) {
        if 会员".equals(level) || "普通用户".equals(level))) {
            //throw用在setLevel(String level)方法的方法体内
            throw new IllegalArgumentException("非法用户：" + level);
        }
        this.level = level;
    }

}

throws：throws 是用在某个方法的方法声明上的，表示当前方法如果抛出了某些异常，将由调用者来进行异常处理。这种方式也可以让调用者知晓该对哪些异常进行处理。throws 声明的异常不一定会出现，只是一种可能。

public class FileInputStream extends InputStream {
    //throws用在FileInputStream(String namwe)方法的方法声明上的
    public FileInputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null);
    }
}

注意

1、try块中的局部变量和catch块中的局部变量（包括异常变量），以及finally中的局部变量，他们之间不可共享使用。

2、每一个catch块用于处理一个异常。异常匹配是按照catch块的顺序从上往下寻找的，只有第一个匹配的catch会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配，因此，如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。

3、finally块没有处理异常的能力。处理异常的只能是catch块。

4、在同一try…catch…finally块中，如果try中抛出异常，且有匹配的catch块，则先执行catch块，再执行finally块。如果没有catch块匹配，则先执行finally，然后去外面的调用者中寻找合适的catch块。

5、在同一try…catch…finally块中，try发生异常，且匹配的catch块中处理异常时也抛出异常，那么后面的finally也会执行：首先执行finally块，然后去外围调用者中寻找合适的catch块。

6、java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。
有的编程语言当异常被处理后，控制流会恢复到异常抛出点接着执行，这种策略叫做：resumption model of exception handling（恢复式异常处理模式）
而Java则是让执行流恢复到处理了异常的catch块后接着执行，这种策略叫做：termination model of exception handling（终结式异常处理模式）

7、当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

throw和throws的区别

throw 在方法体内使用，throws 在方法声明上使用；

throw 后面接的是异常对象，只能接一个。throws 后面接的是异常类型，可以接多个，多个异常类型用逗号隔开；

throw 是在方法中出现不正确情况时，手动来抛出异常，结束方法的，执行了throw 语句一定会出现异常。而 throws 是用来声明当前方法有可能会出现某种异常的，如果出现了相应的异常，将由调用者来处理，声明了异常不一定会出现异常。

finally块和return

在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行。

public class Demo03 {
    public static void main(String[] args)
    {
        int re = bar();
        System.out.println(re);
    }
    private static int bar()
    {
        try{
            return 5;
        } finally{
            System.out.println("finally");
        }
    }
}

finally
5

Process finished with exit code 0

也就是说：try…catch…finally中的return 只要能执行，就都执行了，他们共同向同一个内存地址（假设地址是0×80）写入返回值，后执行的将覆盖先执行的数据，而真正被调用者取的返回值就是最后一次写入的。那么，按照这个思想，下面的这个例子也就不难理解了。

finally中的return 会覆盖 try 或者catch中的返回值

public class Demo03 {
    public static void main(String[] args) {
        int result;

        result = foo();
        System.out.println(result);

        result = bar();
        System.out.println(result);
    }
    @SuppressWarnings("finally")
    public static int foo() {
        try {
            int a = 5 / 0;
        } catch (Exception e) {
            return 1;
        } finally {
            return 2;
        }
    }
    @SuppressWarnings("finally")
    public static int bar() {
        try {
            return 1;
        } finally {
            return 2;
        }
    }
}

2
2

Process finished with exit code 0

finally中的return会抑制（消灭）前面try或者catch块中的异常

public class Demo03 {
    public static void main(String[] args) {
        int result;
        try {
            result = foo();
            System.out.println(result);           //输出100
        } catch (Exception e) {
            System.out.println(e.getMessage());    //没有捕获到异常
        }

        try {
            result = bar();
            System.out.println(result);           //输出100
        } catch (Exception e) {
            System.out.println(e.getMessage());    //没有捕获到异常
        }
    }

    //catch中的异常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception {
        try {
            int a = 5 / 0;
            return 1;
        } catch (ArithmeticException amExp) {
            throw new Exception("我将被忽略，因为下面的finally中使用了return");
        } finally {
            return 100;
        }
    }

    //try中的异常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception {
        try {
            int a = 5 / 0;
            return 1;
        } finally {
            return 100;
        }
    }
}

100
100

Process finished with exit code 0

finally中的异常会覆盖（消灭）前面try或者catch中的异常

public class Demo03 {
    public static void main(String[] args)
    {
        int result;
        try{
            result = foo();
        } catch (Exception e){
            System.out.println(e.getMessage());    //输出：我是finaly中的Exception
        }

        try{
            result  = bar();
        } catch (Exception e){
            System.out.println(e.getMessage());    //输出：我是finaly中的Exception
        }
    }

    //catch中的异常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我将被忽略，因为下面的finally中抛出了新的异常");
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
    }

    //try中的异常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }finally {
            throw new Exception("我是finaly中的Exception");
        }

    }
}