精华内容
下载资源
问答
  • Java异常处理代码编写

    千次阅读 2019-08-19 10:12:38
    Java异常处理代码编写 java中异常 计算机程序运行的过程,总是会出现各种各样的错误。 有一些错误是用户造成的,比如,希望用户输入一个int类型的年龄,但是用户的输入是abc: // 假设用户输入了abc: ...

    Java异常处理代码编写

    java中的异常

    在计算机程序运行的过程中,总是会出现各种各样的错误。

    有一些错误是用户造成的,比如,希望用户输入一个int类型的年龄,但是用户的输入是abc

    // 假设用户输入了abc:
    String s = "abc";
    int n = Integer.parseInt(s); // NumberFormatException!
    

    程序想要读写某个文件的内容,但是用户已经把它删除了:

    // 用户删除了该文件:
    String t = readFile("C:\\abc.txt"); // FileNotFoundException!
    

    还有一些错误是随机出现,并且永远不可能避免的。比如:

    • 网络突然断了,连接不到远程服务器;
    • 内存耗尽,程序崩溃了;
    • 用户点“打印”,但根本没有打印机;
    • ……

    所以,一个健壮的程序必须处理各种各样的错误。

    所谓错误,就是程序调用某个函数的时候,如果失败了,就表示出错。

    调用方如何获知调用失败的信息?有两种方法:

    方法一:约定返回错误码。

    例如,处理一个文件,如果返回0,表示成功,返回其他整数,表示约定的错误码:

    int code = processFile("C:\\test.txt");
    if (code == 0) {
        // ok:
    } else {
        // error:
        switch (code) {
        case 1:
            // file not found:
        case 2:
            // no read permission:
        default:
            // unknown error:
        }
    }
    

    因为使用int类型的错误码,想要处理就非常麻烦。这种方式常见于底层C函数。

    方法二:在语言层面上提供一个异常处理机制。

    Java内置了一套异常处理机制,总是使用异常来表示错误。

    异常是一种class,因此它本身带有类型信息。异常可以在任何地方抛出,但只需要在上层捕获,这样就和方法调用分离了:

    try {
        String s = processFile(“C:\\test.txt”);
        // ok:
    } catch (FileNotFoundException e) {
        // file not found:
    } catch (SecurityException e) {
        // no read permission:
    } catch (IOException e) {
        // io error:
    } catch (Exception e) {
        // other error:
    }
    

    因为Java的异常是class,它的继承关系如下:

                         ┌───────────┐
                         │  Object   │
                         └───────────┘
                               ▲
                               │
                         ┌───────────┐
                         │ Throwable │
                         └───────────┘
                               ▲
                     ┌─────────┴─────────┐
                     │                   │
               ┌───────────┐       ┌───────────┐
               │   Error   │       │ Exception │
               └───────────┘       └───────────┘
                     ▲                   ▲
             ┌───────┘              ┌────┴──────────┐
             │                      │               │
    ┌─────────────────┐    ┌─────────────────┐┌───────────┐
    │OutOfMemoryError │... │RuntimeException ││IOException│...
    └─────────────────┘    └─────────────────┘└───────────┘
                                    ▲
                        ┌───────────┴─────────────┐
                        │                         │
             ┌─────────────────────┐ ┌─────────────────────────┐
             │NullPointerException │ │IllegalArgumentException │...
             └─────────────────────┘ └─────────────────────────┘
    

    从继承关系可知:Throwable是异常体系的根,它继承自ObjectThrowable有两个体系:ErrorExceptionError表示严重的错误,程序对此一般无能为力,例如:

    • OutOfMemoryError:内存耗尽
    • NoClassDefFoundError:无法加载某个Class
    • StackOverflowError:栈溢出

    Exception则是运行时的错误,它可以被捕获并处理。

    某些异常是应用程序逻辑处理的一部分,应该捕获并处理。例如:

    • NumberFormatException:数值类型的格式错误
    • FileNotFoundException:未找到文件
    • SocketException:读取网络失败

    还有一些异常是程序逻辑编写不对造成的,应该修复程序本身。例如:

    • NullPointerException:对某个null的对象调用方法或字段
    • IndexOutOfBoundsException:数组索引越界

    Exception又分为两大类:

    1. RuntimeException以及它的子类;
    2. RuntimeException(包括IOExceptionReflectiveOperationException等等)

    Java规定:

    • 必须捕获的异常,包括Exception及其子类,但不包括RuntimeException及其子类,这种类型的异常称为Checked Exception。

    • 不需要捕获的异常,包括Error及其子类,RuntimeException及其子类。

    捕获异常

    捕获异常使用try...catch语句,把可能发生异常的代码放到try {...}中,然后使用catch捕获对应的Exception及其子类:

    // try...catch
    import java.io.UnsupportedEncodingException;
    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            byte[] bs = toGBK("中文");
            System.out.println(Arrays.toString(bs));
        }
    
        static byte[] toGBK(String s) {
            try {
                // 用指定编码转换String为byte[]:
                return s.getBytes("GBK");
            } catch (UnsupportedEncodingException e) {
                // 如果系统不支持GBK编码,会捕获到UnsupportedEncodingException:
                System.out.println(e); // 打印异常信息
                return s.getBytes(); // 尝试使用用默认编码
            }
        }
    }

    如果我们不捕获UnsupportedEncodingException,会出现编译失败的问题:

    编译器会报错,错误信息类似:unreported exception UnsupportedEncodingException; must be caught or declared to be thrown,并且准确地指出需要捕获的语句是return s.getBytes("GBK");。意思是说,像UnsupportedEncodingException这样的Checked Exception,必须被捕获。

    这是因为String.getBytes(String)方法定义是:

    public byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
        ...
    }
    

    在方法定义的时候,使用throws Xxx表示该方法可能抛出的异常类型。调用方在调用的时候,必须强制捕获这些异常,否则编译器会报错。

    toGBK()方法中,因为调用了String.getBytes(String)方法,就必须捕获UnsupportedEncodingException。我们也可以不捕获它,而是在方法定义处用throws表示toGBK()方法可能会抛出UnsupportedEncodingException,就可以让toGBK()方法通过编译器检查:

    // try...catch
    import java.io.UnsupportedEncodingException;
    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            byte[] bs = toGBK("中文");
            System.out.println(Arrays.toString(bs));
        }
    
        static byte[] toGBK(String s) throws UnsupportedEncodingException {
            return s.getBytes("GBK");
        }
    }
    

    上述代码仍然会得到编译错误,但这一次,编译器提示的不是调用return s.getBytes("GBK");的问题,而是byte[] bs = toGBK("中文");。因为在main()方法中,调用toGBK(),没有捕获它声明的可能抛出的UnsupportedEncodingException

    修复方法是在main()方法中捕获异常并处理:

    // try...catch
    import java.io.UnsupportedEncodingException;
    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            try {
                byte[] bs = toGBK("中文");
                System.out.println(Arrays.toString(bs));
            } catch (UnsupportedEncodingException e) {
                System.out.println(e);
            }
        }
    
        static byte[] toGBK(String s) throws UnsupportedEncodingException {
            // 用指定编码转换String为byte[]:
            return s.getBytes("GBK");
        }
    }

    可见,只要是方法声明的Checked Exception,不在调用层捕获,也必须在更高的调用层捕获。所有未捕获的异常,最终也必须在main()方法中捕获,不会出现漏写try的情况。这是由编译器保证的。main()方法也是最后捕获Exception的机会。

    如果是测试代码,上面的写法就略显麻烦。如果不想写任何try代码,可以直接把main()方法定义为throws Exception

    public class Main {
        public static void main(String[] args) throws Exception {
            byte[] bs = toGBK("中文");
            System.out.println(Arrays.toString(bs));
        }
    
        static byte[] toGBK(String s) throws UnsupportedEncodingException {
            // 用指定编码转换String为byte[]:
            return s.getBytes("GBK");
        }
    }
    

    因为main()方法声明了可能抛出Exception,也就声明了可能抛出所有的Exception,因此在内部就无需捕获了。代价就是一旦发生异常,程序会立刻退出。

    还有一些童鞋喜欢在toGBK()内部“消化”异常:

    static byte[] toGBK(String s) {
        try {
            return s.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            // 什么也不干
        }
        return null;
    

    这种捕获后不处理的方式是非常不好的,即使真的什么也做不了,也要先把异常记录下来:

    static byte[] toGBK(String s) {
        try {
            return s.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            // 先记下来再说:
            e.printStackTrace();
        }
        return null;
    

    所有异常都可以调用printStackTrace()方法打印异常栈,这是一个简单有用的快速打印异常的方法。

    Java使用异常来表示错误,并通过try ... catch捕获异常;

    Java的异常是class,并且从Throwable继承;

    Error是无需捕获的严重错误,Exception是应该捕获的可处理的错误;

    RuntimeException无需强制捕获,非RuntimeException(Checked Exception)需强制捕获,或者用throws声明;

     

    捕获异常

    在Java中,凡是可能抛出异常的语句,都可以用try ... catch捕获。把可能发生异常的语句放在try { ... }中,然后使用catch捕获对应的Exception及其子类。

    多catch语句

    可以使用多个catch语句,每个catch分别捕获对应的Exception及其子类。JVM在捕获到异常后,会从上到下匹配catch语句,匹配到某个catch后,执行catch代码块,然后不再继续匹配。

    简单地说就是:多个catch语句只有一个能被执行。例如:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
        } catch (IOException e) {
            System.out.println(e);
        } catch (NumberFormatException e) {
            System.out.println(e);
        }
    }
    

    存在多个catch的时候,catch的顺序非常重要:子类必须写在前面。例如:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
        } catch (IOException e) {
            System.out.println("IO error");
        } catch (UnsupportedEncodingException e) { // 永远捕获不到
            System.out.println("Bad encoding");
        }
    }
    

    对于上面的代码,UnsupportedEncodingException异常是永远捕获不到的,因为它是IOException的子类。当抛出UnsupportedEncodingException异常时,会被catch (IOException e) { ... }捕获并执行。

    因此,正确的写法是把子类放到前面:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
        } catch (UnsupportedEncodingException e) {
            System.out.println("Bad encoding");
        } catch (IOException e) {
            System.out.println("IO error");
        }
    }
    

    finally语句

    无论是否有异常发生,如果我们都希望执行一些语句,例如清理工作,怎么写?

    可以把执行语句写若干遍:正常执行的放到try中,每个catch再写一遍。例如:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
            System.out.println("END");
        } catch (UnsupportedEncodingException e) {
            System.out.println("Bad encoding");
            System.out.println("END");
        } catch (IOException e) {
            System.out.println("IO error");
            System.out.println("END");
        }
    }
    

    上述代码无论是否发生异常,都会执行System.out.println("END");这条语句。

    那么如何消除这些重复的代码?Java的try ... catch机制还提供了finally语句,finally语句块保证有无错误都会执行。上述代码可以改写如下:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
        } catch (UnsupportedEncodingException e) {
            System.out.println("Bad encoding");
        } catch (IOException e) {
            System.out.println("IO error");
        } finally {
            System.out.println("END");
        }
    }
    

    注意finally有几个特点:

    1. finally语句不是必须的,可写可不写;
    2. finally总是最后执行。

    如果没有发生异常,就正常执行try { ... }语句块,然后执行finally。如果发生了异常,就中断执行try { ... }语句块,然后跳转执行匹配的catch语句块,最后执行finally

    可见,finally是用来保证一些代码必须执行的。

    某些情况下,可以没有catch,只使用try ... finally结构。例如:

    void process(String file) throws IOException {
        try {
            ...
        } finally {
            System.out.println("END");
        }
    }
    

    因为方法声明了可能抛出的异常,所以可以不写catch

    捕获多种异常

    如果某些异常的处理逻辑相同,但是异常本身不存在继承关系,那么就得编写多条catch子句:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
        } catch (IOException e) {
            System.out.println("Bad input");
        } catch (NumberFormatException e) {
            System.out.println("Bad input");
        } catch (Exception e) {
            System.out.println("Unknown error");
        }
    }
    

    因为处理IOExceptionNumberFormatException的代码是相同的,所以我们可以把它两用|合并到一起:

    public static void main(String[] args) {
        try {
            process1();
            process2();
            process3();
        } catch (IOException | NumberFormatException e) { // IOException或NumberFormatException
            System.out.println("Bad input");
        } catch (Exception e) {
            System.out.println("Unknown error");
        }
    }

    使用try ... catch ... finally时:

    • 多个catch语句的匹配顺序非常重要,子类必须放在前面;

    • finally语句保证了有无异常都会执行,它是可选的;

    • 一个catch语句也可以匹配多个非继承关系的异常。



    抛出异常

    异常的传播

    当某个方法抛出了异常时,如果当前方法没有捕获异常,异常就会被抛到上层调用方法,直到遇到某个try ... catch被捕获为止:

    public class Main {
        public static void main(String[] args) {
            try {
                process1();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        static void process1() {
            process2();
        }
    
        static void process2() {
            Integer.parseInt(null); // 会抛出NumberFormatException
        }
    }
    

    通过printStackTrace()可以打印出方法的调用栈,类似:

    java.lang.NumberFormatException: null
        at java.base/java.lang.Integer.parseInt(Integer.java:614)
        at java.base/java.lang.Integer.parseInt(Integer.java:770)
        at Main.process2(Main.java:16)
        at Main.process1(Main.java:12)
        at Main.main(Main.java:5)
    

    printStackTrace()对于调试错误非常有用,上述信息表示:NumberFormatException是在java.lang.Integer.parseInt方法中被抛出的,调用层次从上到下依次是:

    1. main()调用process1()
    2. process1()调用process2()
    3. process2()调用Integer.parseInt(String)
    4. Integer.parseInt(String)调用Integer.parseInt(String, int)

    查看Integer.java源码可知,抛出异常的方法代码如下:

    public static int parseInt(String s, int radix) throws NumberFormatException {
        if (s == null) {
            throw new NumberFormatException("null");
        }
        ...
    }
    

    并且,每层调用均给出了源代码的行号,可直接定位。

    抛出异常

    当发生错误时,例如,用户输入了非法的字符,我们就可以抛出异常。

    如何抛出异常?参考Integer.parseInt()方法,抛出异常分两步:

    1. 创建某个Exception的实例;
    2. throw语句抛出。

    下面是一个例子:

    void process2(String s) {
        if (s==null) {
            NullPointerException e = new NullPointerException();
            throw e;
        }
    }
    

    实际上,绝大部分抛出异常的代码都会合并写成一行:

    void process2(String s) {
        if (s==null) {
            throw new NullPointerException();
        }
    }
    

    如果一个方法捕获了某个异常后,又在catch子句中抛出新的异常,就相当于把抛出的异常类型“转换”了:

    void process1(String s) {
        try {
            process2();
        } catch (NullPointerException e) {
            throw new IllegalArgumentException();
        }
    }
    
    void process2(String s) {
        if (s==null) {
            throw new NullPointerException();
        }
    }
    

    process2()抛出NullPointerException后,被process1()捕获,然后抛出IllegalArgumentException()

    如果在main()中捕获IllegalArgumentException,我们看看打印的异常栈:

    public class Main {
        public static void main(String[] args) {
            try {
                process1();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        static void process1() {
            try {
                process2();
            } catch (NullPointerException e) {
                throw new IllegalArgumentException();
            }
        }
    
        static void process2() {
            throw new NullPointerException();
        }
    }
    

    打印出的异常栈类似:

    java.lang.IllegalArgumentException
        at Main.process1(Main.java:15)
        at Main.main(Main.java:5)
    

    这说明新的异常丢失了原始异常信息,我们已经看不到原始异常NullPointerException的信息了。

    为了能追踪到完整的异常栈,在构造异常的时候,把原始的Exception实例传进去,新的Exception就可以持有原始Exception信息。对上述代码改进如下:

    public class Main {
        public static void main(String[] args) {
            try {
                process1();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        static void process1() {
            try {
                process2();
            } catch (NullPointerException e) {
                throw new IllegalArgumentException(e);
            }
        }
    
        static void process2() {
            throw new NullPointerException();
        }
    }

    运行上述代码,打印出的异常栈类似:

    java.lang.IllegalArgumentException: java.lang.NullPointerException
        at Main.process1(Main.java:15)
        at Main.main(Main.java:5)
    Caused by: java.lang.NullPointerException
        at Main.process2(Main.java:20)
        at Main.process1(Main.java:13)
    

    注意到Caused by: Xxx,说明捕获的IllegalArgumentException并不是造成问题的根源,根源在于NullPointerException,是在Main.process2()方法抛出的。

    在代码中获取原始异常可以使用Throwable.getCause()方法。如果返回null,说明已经是“根异常”了。

    有了完整的异常栈的信息,我们才能快速定位并修复代码的问题。

    如果我们在try或者catch语句块中抛出异常,finally语句是否会执行?例如:

    public class Main {
        public static void main(String[] args) {
            try {
                Integer.parseInt("abc");
            } catch (Exception e) {
                System.out.println("catched");
                throw new RuntimeException(e);
            } finally {
                System.out.println("finally");
            }
        }
    }

    上述代码执行结果如下:

    catched
    finally
    Exception in thread "main" java.lang.RuntimeException: java.lang.NumberFormatException: For input string: "abc"
        at Main.main(Main.java:8)
    Caused by: java.lang.NumberFormatException: For input string: "abc"
        at ...
    

    第一行打印了catched,说明进入了catch语句块。第二行打印了finally,说明执行了finally语句块。

    因此,在catch中抛出异常,不会影响finally的执行。JVM会先执行finally,然后抛出异常。

    异常屏蔽

    如果在执行finally语句时抛出异常,那么,catch语句的异常还能否继续抛出?例如:

    public class Main {
        public static void main(String[] args) {
            try {
                Integer.parseInt("abc");
            } catch (Exception e) {
                System.out.println("catched");
                throw new RuntimeException(e);
            } finally {
                System.out.println("finally");
                throw new IllegalArgumentException();
            }
        }
    }
    

    执行上述代码,发现异常信息如下:

    catched
    finally
    Exception in thread "main" java.lang.IllegalArgumentException
        at Main.main(Main.java:11)
    

    这说明finally抛出异常后,原来在catch中准备抛出的异常就“消失”了,因为只能抛出一个异常。没有被抛出的异常称为“被屏蔽”的异常(Suppressed Exception)。

    在极少数的情况下,我们需要获知所有的异常。如何保存所有的异常信息?方法是先用origin变量保存原始异常,然后调用Throwable.addSuppressed(),把原始异常添加进来,最后在finally抛出:

    public class Main {
        public static void main(String[] args) throws Exception {
            Exception origin = null;
            try {
                System.out.println(Integer.parseInt("abc"));
            } catch (Exception e) {
                origin = e;
                throw e;
            } finally {
                Exception e = new IllegalArgumentException();
                if (origin != null) {
                    e.addSuppressed(origin);
                }
                throw e;
            }
        }
    }

    catchfinally都抛出了异常时,虽然catch的异常被屏蔽了,但是,finally抛出的异常仍然包含了它:

    Exception in thread "main" java.lang.IllegalArgumentException
        at Main.main(Main.java:11)
    Suppressed: java.lang.NumberFormatException: For input string: "abc"
        at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
        at java.base/java.lang.Integer.parseInt(Integer.java:652)
        at java.base/java.lang.Integer.parseInt(Integer.java:770)
        at Main.main(Main.java:6)
    

    通过Throwable.getSuppressed()可以获取所有的Suppressed Exception

    绝大多数情况下,在finally中不要抛出异常。因此,我们通常不需要关心Suppressed Exception

    调用printStackTrace()可以打印异常的传播栈,对于调试非常有用;

    捕获异常并再次抛出新的异常时,应该持有原始异常信息;

    通常不要在finally中抛出异常。如果在finally中抛出异常,应该原始异常加入到原有异常中。调用方可通过Throwable.getSuppressed()获取所有添加的Suppressed Exception

     

    自定义异常

    Java标准库定义的常用异常包括:

    Exception
    │
    ├─ RuntimeException
    │  │
    │  ├─ NullPointerException
    │  │
    │  ├─ IndexOutOfBoundsException
    │  │
    │  ├─ SecurityException
    │  │
    │  └─ IllegalArgumentException
    │     │
    │     └─ NumberFormatException
    │
    ├─ IOException
    │  │
    │  ├─ UnsupportedCharsetException
    │  │
    │  ├─ FileNotFoundException
    │  │
    │  └─ SocketException
    │
    ├─ ParseException
    │
    ├─ GeneralSecurityException
    │
    ├─ SQLException
    │
    └─ TimeoutException
    

    当我们在代码中需要抛出异常时,尽量使用JDK已定义的异常类型。例如,参数检查不合法,应该抛出IllegalArgumentException

    static void process1(int age) {
        if (age <= 0) {
            throw new IllegalArgumentException();
        }
    }
    

    在一个大型项目中,可以自定义新的异常类型,但是,保持一个合理的异常继承体系是非常重要的。

    一个常见的做法是自定义一个BaseException作为“根异常”,然后,派生出各种业务类型的异常。

    BaseException需要从一个适合的Exception派生,通常建议从RuntimeException派生:

    public class BaseException extends RuntimeException {
    }
    

    其他业务类型的异常就可以从BaseException派生:

    public class UserNotFoundException extends BaseException {
    }
    
    public class LoginFailedException extends BaseException {
    }
    
    ...
    

    自定义的BaseException应该提供多个构造方法:

    public class BaseException extends RuntimeException {
        public BaseException() {
            super();
        }
    
        public BaseException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public BaseException(String message) {
            super(message);
        }
    
        public BaseException(Throwable cause) {
            super(cause);
        }
    }
    

    上述构造方法实际上都是原样照抄RuntimeException。这样,抛出异常的时候,就可以选择合适的构造方法。通过IDE可以根据父类快速生成子类的构造方法。

    抛出异常时,尽量复用JDK已定义的异常类型;

    自定义异常体系时,推荐从RuntimeException派生“根异常”,再派生出业务异常;

    自定义异常时,应该提供多种构造方法。

     

    断言

    断言(Assertion)是一种调试程序的方式。在Java中,使用assert关键字来实现断言。

    我们先看一个例子:

    public static void main(String[] args) {
        double x = Math.abs(-123.45);
        assert x >= 0;
        System.out.println(x);
    }
    

    语句assert x >= 0;即为断言,断言条件x >= 0预期为true。如果计算结果为false,则断言失败,抛出AssertionError

    使用assert语句时,还可以添加一个可选的断言消息:

    assert x >= 0 : "x must >= 0";
    

    这样,断言失败的时候,AssertionError会带上消息x must >= 0,更加便于调试。

    Java断言的特点是:断言失败时会抛出AssertionError,导致程序结束退出。因此,断言不能用于可恢复的程序错误,只应该用于开发和测试阶段。

    对于可恢复的程序错误,不应该使用断言。例如:

    void sort(int[] arr) {
        assert arr != null;
    }
    

    应该抛出异常并在上层捕获:

    void sort(int[] arr) {
        if (x == null) {
            throw new IllegalArgumentException("array cannot be null");
        }
    }
    

    当我们在程序中使用assert时,例如,一个简单的断言:

    public class Main {
        public static void main(String[] args) {
            int x = -1;
            assert x > 0;
            System.out.println(x);
        }
    }

    断言x必须大于0,实际上x-1,断言肯定失败。执行上述代码,发现程序并未抛出AssertionError,而是正常打印了x的值。

    这是怎么肥四?为什么assert语句不起作用?

    这是因为JVM默认关闭断言指令,即遇到assert语句就自动忽略了,不执行。

    要执行assert语句,必须给Java虚拟机传递-enableassertions(可简写为-ea)参数启用断言。所以,上述程序必须在命令行下运行才有效果:

    $ java -ea Main.java
    Exception in thread "main" java.lang.AssertionError
    	at Main.main(Main.java:5)
    

    还可以有选择地对特定地类启用断言,命令行参数是:-ea:com.itranswarp.sample.Main,表示只对com.itranswarp.sample.Main这个类启用断言。

    或者对特定地包启用断言,命令行参数是:-ea:com.itranswarp.sample...(注意结尾有3个.),表示对com.itranswarp.sample这个包启动断言。

    实际开发中,很少使用断言。更好的方法是编写单元测试,后续我们会讲解JUnit的使用。

    断言是一种调试方式,断言失败会抛出AssertionError,只能在开发和测试阶段启用断言;

    对可恢复的错误不能使用断言,而应该抛出异常;

    断言很少被使用,更好的方法是编写单元测试。

     

    JDK Logging

    在编写程序的过程中,发现程序运行结果与预期不符,怎么办?当然是用System.out.println()打印出执行过程中的某些变量,观察每一步的结果与代码逻辑是否符合,然后有针对性地修改代码。

    代码改好了怎么办?当然是删除没有用的System.out.println()语句了。

    如果改代码又改出问题怎么办?再加上System.out.println()

    反复这么搞几次,很快大家就发现使用System.out.println()非常麻烦。

    怎么办?

    解决方法是使用日志。

    那什么是日志?日志就是Logging,它的目的是为了取代System.out.println()

    输出日志,而不是用System.out.println(),有以下几个好处:

    1. 可以设置输出样式,避免自己每次都写"ERROR: " + var
    2. 可以设置输出级别,禁止某些级别输出。例如,只输出错误日志;
    3. 可以被重定向到文件,这样可以在程序运行结束后查看日志;
    4. 可以按包名控制日志级别,只输出某些包打的日志;
    5. 可以……

    总之就是好处很多啦。

    那如何使用日志?

    因为Java标准库内置了日志包java.util.logging,我们可以直接用。先看一个简单的例子:

    // logging
    import java.util.logging.Level;
    import java.util.logging.Logger;
    public class Hello {
        public static void main(String[] args) {
            Logger logger = Logger.getGlobal();
            logger.info("start process...");
            logger.warning("memory is running out...");
            logger.fine("ignored.");
            logger.severe("process will be terminated...");
        }
    }

    运行上述代码,得到类似如下的输出:

    Mar 02, 2019 6:32:13 PM Hello main
    INFO: start process...
    Mar 02, 2019 6:32:13 PM Hello main
    WARNING: memory is running out...
    Mar 02, 2019 6:32:13 PM Hello main
    SEVERE: process will be terminated...
    

    对比可见,使用日志最大的好处是,它自动打印了时间、调用类、调用方法等很多有用的信息。

    再仔细观察发现,4条日志,只打印了3条,logger.fine()没有打印。这是因为,日志的输出可以设定级别。JDK的Logging定义了7个日志级别,从严重到普通:

    • SEVERE
    • WARNING
    • INFO
    • CONFIG
    • FINE
    • FINER
    • FINEST

    因为默认级别是INFO,因此,INFO级别以下的日志,不会被打印出来。使用日志级别的好处在于,调整级别,就可以屏蔽掉很多调试相关的日志输出。

    使用Java标准库内置的Logging有以下局限:

    Logging系统在JVM启动时读取配置文件并完成初始化,一旦开始运行main()方法,就无法修改配置;

    配置不太方便,需要在JVM启动时传递参数-Djava.util.logging.config.file=<config-file-name>

    因此,Java标准库内置的Logging使用并不是非常广泛。更方便的日志系统我们稍后介绍。

    使用logger.severe()打印异常:

            Logger logger = Logger.getLogger(Main.class.getName());
            logger.info("Start process...");
            try {
                "".getBytes("invalidCharsetName");
            } catch (UnsupportedEncodingException e) {
                // TODO: 使用logger.severe()打印异常
            }
            logger.info("Process end.");
    

    日志是为了替代System.out.println(),可以定义格式,重定向到文件等;

    日志可以存档,便于追踪问题;

    日志记录可以按级别分类,便于打开或关闭某些级别;

    可以根据配置文件调整日志,无需修改代码;

    Java标准库提供了java.util.logging来实现日志功能。

     

    Commons Logging

    和Java标准库提供的日志不同,Commons Logging是一个第三方日志库,它是由Apache创建的日志模块。

    Commons Logging的特色是,它可以挂接不同的日志系统,并通过配置文件指定挂接的日志系统。默认情况下,Commons Loggin自动搜索并使用Log4j(Log4j是另一个流行的日志系统),如果没有找到Log4j,再使用JDK Logging。

    使用Commons Logging只需要和两个类打交道,并且只有两步:

    第一步,通过LogFactory获取Log类的实例; 第二步,使用Log实例的方法打日志。

    示例代码如下:

    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    public class Main {
        public static void main(String[] args) {
            Log log = LogFactory.getLog(Main.class);
            log.info("start...");
            log.warn("end.");
        }
    }

    运行上述代码,肯定会得到编译错误,类似error: package org.apache.commons.logging does not exist(找不到org.apache.commons.logging这个包)。因为Commons Logging是一个第三方提供的库,所以,必须先把它下载下来。下载后,解压,找到commons-logging-1.2.jar这个文件,再把Java源码Main.java放到一个目录下,例如work目录:

    work
    │
    ├─ commons-logging-1.2.jar
    │
    └─ Main.java
    

    然后用javac编译Main.java,编译的时候要指定classpath,不然编译器找不到我们引用的org.apache.commons.logging包。编译命令如下:

    javac -cp commons-logging-1.2.jar Main.java
    

    如果编译成功,那么当前目录下就会多出一个Main.class文件:

    work
    │
    ├─ commons-logging-1.2.jar
    │
    ├─ Main.java
    │
    └─ Main.class
    

    现在可以执行这个Main.class,使用java命令,也必须指定classpath,命令如下:

    java -cp .;commons-logging-1.2.jar Main
    

    注意到传入的classpath有两部分:一个是.,一个是commons-logging-1.2.jar,用;分割。.表示当前目录,如果没有这个.,JVM不会在当前目录搜索Main.class,就会报错。

    如果在Linux或macOS下运行,注意classpath的分隔符不是;,而是:

    java -cp .:commons-logging-1.2.jar Main
    

    运行结果如下:

    Mar 02, 2019 7:15:31 PM Main main
    INFO: start...
    Mar 02, 2019 7:15:31 PM Main main
    WARNING: end.
    

    Commons Logging定义了6个日志级别:

    • FATAL
    • ERROR
    • WARNING
    • INFO
    • DEBUG
    • TRACE

    默认级别是INFO

    使用Commons Logging时,如果在静态方法中引用Log,通常直接定义一个静态类型变量:

    // 在静态方法中引用Log:
    public class Main {
        static final Log log = LogFactory.getLog(Main.class);
    
        static void foo() {
            log.info("foo");
        }
    }
    

    在实例方法中引用Log,通常定义一个实例变量:

    // 在实例方法中引用Log:
    public class Person {
        protected final Log log = LogFactory.getLog(getClass());
    
        void foo() {
            log.info("foo");
        }
    }
    

    注意到实例变量log的获取方式是LogFactory.getLog(getClass()),虽然也可以用LogFactory.getLog(Person.class),但是前一种方式有个非常大的好处,就是子类可以直接使用该log实例。例如:

    // 在子类中使用父类实例化的log:
    public class Student extends Person {
        void bar() {
            log.info("bar");
        }
    }
    

    由于Java类的动态特性,子类获取的log字段实际上相当于LogFactory.getLog(Student.class),但却是从父类继承而来,并且无需改动代码。

    此外,Commons Logging的日志方法,例如info(),除了标准的info(String)外,还提供了一个非常有用的重载方法:info(String, Throwable),这使得记录异常更加简单:

    try {
        ...
    } catch (Exception e) {
        log.error("got exception!", e);
    }

    Commons Logging是使用最广泛的日志模块;

    Commons Logging的API非常简单;

    Commons Logging可以自动检测并使用其他日志模块。

     

    Log4j

    前面介绍了Commons Logging,可以作为“日志接口”来使用。而真正的“日志实现”可以使用Log4j。

    Log4j是一种非常流行的日志框架,最新版本是2.x。

    Log4j是一个组件化设计的日志系统,它的架构大致如下:

    log.info("User signed in.");
     │
     │   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
     ├──>│ Appender │───>│  Filter  │───>│  Layout  │───>│ Console  │
     │   └──────────┘    └──────────┘    └──────────┘    └──────────┘
     │
     │   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
     ├──>│ Appender │───>│  Filter  │───>│  Layout  │───>│   File   │
     │   └──────────┘    └──────────┘    └──────────┘    └──────────┘
     │
     │   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
     └──>│ Appender │───>│  Filter  │───>│  Layout  │───>│  Socket  │
         └──────────┘    └──────────┘    └──────────┘    └──────────┘
    

    当我们使用Log4j输出一条日志时,Log4j自动通过不同的Appender把同一条日志输出到不同的目的地。例如:

    • console:输出到屏幕;
    • file:输出到文件;
    • socket:通过网络输出到远程计算机;
    • jdbc:输出到数据库

    在输出日志的过程中,通过Filter来过滤哪些log需要被输出,哪些log不需要被输出。例如,仅输出ERROR级别的日志。

    最后,通过Layout来格式化日志信息,例如,自动添加日期、时间、方法名称等信息。

    上述结构虽然复杂,但我们在实际使用的时候,并不需要关心Log4j的API,而是通过配置文件来配置它。

    以XML配置为例,使用Log4j的时候,我们把一个log4j2.xml的文件放到classpath下就可以让Log4j读取配置文件并按照我们的配置来输出日志。下面是一个配置文件的例子:

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration>
    	<Properties>
            <!-- 定义日志格式 -->
    		<Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36}%n%msg%n%n</Property>
            <!-- 定义文件名变量 -->
    		<Property name="file.err.filename">log/err.log</Property>
    		<Property name="file.err.pattern">log/err.%i.log.gz</Property>
    	</Properties>
        <!-- 定义Appender,即目的地 -->
    	<Appenders>
            <!-- 定义输出到屏幕 -->
    		<Console name="console" target="SYSTEM_OUT">
                <!-- 日志格式引用上面定义的log.pattern -->
    			<PatternLayout pattern="${log.pattern}" />
    		</Console>
            <!-- 定义输出到文件,文件名引用上面定义的file.err.filename -->
    		<RollingFile name="err" bufferedIO="true" fileName="${file.err.filename}" filePattern="${file.err.pattern}">
    			<PatternLayout pattern="${log.pattern}" />
    			<Policies>
                    <!-- 根据文件大小自动切割日志 -->
    				<SizeBasedTriggeringPolicy size="1 MB" />
    			</Policies>
                <!-- 保留最近10份 -->
    			<DefaultRolloverStrategy max="10" />
    		</RollingFile>
    	</Appenders>
    	<Loggers>
    		<Root level="info">
                <!-- 对info级别的日志,输出到console -->
    			<AppenderRef ref="console" level="info" />
                <!-- 对error级别的日志,输出到err,即上面定义的RollingFile -->
    			<AppenderRef ref="err" level="error" />
    		</Root>
    	</Loggers>
    </Configuration>
    

    虽然配置Log4j比较繁琐,但一旦配置完成,使用起来就非常方便。对上面的配置文件,凡是INFO级别的日志,会自动输出到屏幕,而ERROR级别的日志,不但会输出到屏幕,还会同时输出到文件。并且,一旦日志文件达到指定大小(1MB),Log4j就会自动切割新的日志文件,并最多保留10份。

    有了配置文件还不够,因为Log4j也是一个第三方库,我们需要从这里下载Log4j,解压后,把以下3个jar包放到classpath中:

    • log4j-api-2.x.jar
    • log4j-core-2.x.jar
    • log4j-jcl-2.x.jar

    因为Commons Logging会自动发现并使用Log4j,所以,把上一节下载的commons-logging-1.2.jar也放到classpath中。

    要打印日志,只需要按Commons Logging的写法写,不需要改动任何代码,就可以得到Log4j的日志输出,类似:

    03-03 12:09:45.880 [main] INFO  com.itranswarp.learnjava.Main
    Start process...
    

    最佳实践

    在开发阶段,始终使用Commons Logging接口来写入日志,并且开发阶段无需引入Log4j。如果需要把日志写入文件, 只需要把正确的配置文件和Log4j相关的jar包放入classpath,就可以自动把日志切换成使用Log4j写入,无需修改任何代码。

    通过Commons Logging实现日志,不需要修改代码即可使用Log4j 使用Log4j只需要把log4j2.xml和相关jar放入classpath 如果要更换Log4j,只需要移除log4j2.xml和相关jar 只有扩展Log4j时,才需要引用Log4j的接口(例如,将日志加密写入数据库的功能,需要自己开发)

     

    SLF4J和Logback

    前面介绍了Commons Logging和Log4j这一对好基友,它们一个负责充当日志API,一个负责实现日志底层,搭配使用非常便于开发。

    有的童鞋可能还听说过SLF4J和Logback。这两个东东看上去也像日志,它们又是啥?

    其实SLF4J类似于Commons Logging,也是一个日志接口,而Logback类似于Log4j,是一个日志的实现。

    为什么有了Commons Logging和Log4j,又会蹦出来SLF4J和Logback?

    这是因为Java有着非常悠久的开源历史,不但OpenJDK本身是开源的,而且我们用到的第三方库,几乎全部都是开源的。

    开源生态丰富的一个特定就是,同一个功能,可以找到若干种互相竞争的开源库。

    因为对Commons Logging的接口不满意,有人就搞了SLF4J。因为对Log4j的性能不满意,有人就搞了Logback。

    我们先来看看SLF4J对Commons Logging的接口有何改进。

    在Commons Logging中,我们要打印日志,有时候得这么写:

    int score = 99;
    p.setScore(score);
    log.info("Set score " + score + " for Person " + p.getName() + " ok.");
    

    拼字符串是一个非常麻烦的事情,所以SLF4J的日志接口改进成这样了:

    int score = 99;
    p.setScore(score);
    logger.info("Set score {} for Person {} ok.", score, p.getName());
    

    我们靠猜也能猜出来,SLF4J的日志接口传入的是一个带占位符的字符串,用后面的变量自动替换占位符,所以看起来更加自然。

    如何使用SLF4J?它的接口实际上和Commons Logging几乎一模一样:

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    class Main {
        final Logger logger = LoggerFactory.getLogger(getClass());
    }
    

    对比一下Commons Logging和SLF4J的接口:

    Commons Logging SLF4J
    org.apache.commons.logging.Log org.slf4j.Logger
    org.apache.commons.logging.LogFactory org.slf4j.LoggerFactory

    不同之处就是Log变成了Logger,LogFactory变成了LoggerFactory。

    使用SLF4J和Logback和前面讲到的使用Commons Logging加Log4j是类似的,先分别下载SLF4JLogback,然后把以下jar包放到classpath下:

    • slf4j-api-1.7.x.jar
    • logback-classic-1.2.x.jar
    • logback-core-1.2.x.jar

    然后使用SLF4J的Logger和LoggerFactory即可。和Log4j类似,我们仍然需要一个Logback的配置文件,把logback.xml放到classpath下,配置如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    
    	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    		<encoder>
    			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    		</encoder>
    	</appender>
    
    	<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    		<encoder>
    			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    			<charset>utf-8</charset>
    		</encoder>
    		<file>log/output.log</file>
    		<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
    			<fileNamePattern>log/output.log.%i</fileNamePattern>
    		</rollingPolicy>
    		<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
    			<MaxFileSize>1MB</MaxFileSize>
    		</triggeringPolicy>
    	</appender>
    
    	<root level="INFO">
    		<appender-ref ref="CONSOLE" />
    		<appender-ref ref="FILE" />
    	</root>
    </configuration>
    

    运行即可获得类似如下的输出:

    13:15:25.328 [main] INFO  com.itranswarp.learnjava.Main - Start process...
    

    从目前的趋势来看,越来越多的开源项目从Commons Logging加Log4j转向了SLF4J加Logback。

    SLF4J和Logback可以取代Commons Logging和Log4j;

    始终使用SLF4J的接口写入日志,使用Logback只需要配置,不需要修改代码。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 返回本章节 返回作业目录 需求说明: 从控制输入计算机磁盘后缀名为“....创建类Read,该类导入java.io.FileInputStream类,Read类定义静态方法readFile(),该方法有一个String类型的参数,该参数表示从

    返回本章节

    返回作业目录


    需求说明:

    1. 从控制中输入计算机磁盘中后缀名为“.txt”的文件的完整物理路径。
    2. 如果该文件存在,则在控制台输出友好提示信息,告知用户该文件存在,如果文件不存在,程序运行时会抛出异常,将异常进行捕获。
    3. 无论程序是否出现异常,最终通过finally语句库释放输入流所占用的物理资源。

    实现思路:

    创建类Read,在该类中导入java.io.FileInputStream类,在Read类中定义静态方法readFile(),该方法有一个String类型的参数,该参数表示从控制台读取到的用户输入的文件全路径。

    在readFile()方法中定义FileInputStream类型变量fis,该变量封装所读入的文件路径。在try语句中创建FileInputStream实例,如果所读入的文件路径存在,则在控制台输出友好的提示信息,告知用户该文件存在。

    实现代码:

    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Scanner;
    
    public class File {
    
    	public static void main(String[] args) {
    		System.out.println("请输入文件路径:");
    		String filePath = new Scanner(System.in).next();
    		FileInputStream fis=null;
    		try{
    			fis = new FileInputStream(filePath);
    			System.out.println("恭喜您!"+filePath+"文件存在");
    		}catch (IOException e) {
    			System.err.println(e.getMessage());
    		}finally{
    			if(fis!=null){
    			    try {
    			    	fis.close();
    			    } catch (IOException e) {
    				   e.printStackTrace();
    			    }
    		     }
    		}
    
    	}
    
    }
    

     

    展开全文
  • JAVA中异常处理机制 任何程序都追求正确有效的运行,除了保证我们代码尽可能的少出错之外,我们还要考虑如何有效的处理异常, 一个良好的异常框架对于系统来说是至关重要的。最近给公司写采集框架的时候系统的...

    JAVA中异常处理机制

    	任何程序都追求正确有效的运行,除了保证我们代码尽可能的少出错之外,我们还要考虑如何有效的处理异常,
    	一个良好的异常框架对于系统来说是至关重要的。最近在给公司写采集框架的时候系统的了解一边,收获颇多,特此记录相关的理论。
    

    1. 什么是异常

    	异常就是程序在运行期间可能出现的各种异常不到的信息、导致程序不能正常的运行。
    

    2. 异常的本质

    	异常的本质就是确保程序在运行期间能够正常的运行、再出现异常的情况下能够正确的关闭程序。
    

    3. 异常的分类

    JDK中定义了很多异常类、这些类对应着不同的各种可能出现异常信息的事件、所有的异常对象都远胜于Throwable类的一个实例、	
    如果内置的异常类不能够满足需要、还可以自己创建异常java对异常进行了分类处理、不同的异常分别有着不同的java类表示、
    所有的异常根类是属于java.lang.Throwable Throwable下面有派生出两个子类 Error  和  Exception 
    

    体系结构图:
    在这里插入图片描述

    4. Error和Exception的理解

    4.1、Error:(错误):是程序中无法处理的错误,表示运行应用程序中出现了严重的错误。此类错误一般表示代码运行时JVM出现问题。
    通常有Virtual MachineError(虚拟机运行错误)、NoClassDefFoundError(类定义错误)等。
    比如说当jvm耗完可用内存时,将出现OutOfMemoryError。此类错误发生时,JVM将终止线程。
    这些错误是不可查的,非代码性错误。因此,当此类错误发生时,应用不应该去处理此类错误。
    4.2、Exception(异常):程序本身可以捕获并且可以处理的异常。这类异常需要我们程序员去捕获异常、并处理异常、所谓真正的异常。
    	异常有分为两大类:
    	RuntimeException(运行期间异常)
    		我们在编写好代码之后、是的程序进行运行状态的时候、发生了位置的异常信息、比如、NullPointerException(空指针)、
    		ArithmeticException(运算异常)等、像这样的位置异常就属于我们运行期间业务出错手动造成的异常
    	CheckedException(编译期间异常)
    		编译期异常不难理解、我们都知道我们的java程序最终都是将.java文件编译成.class文件、最后将class文件运行在JVM虚
    		拟机上的、那么出现编译期异常也就说明程序还没有启动在编译过程中就已经出现错误了、绝大多数的错误就是类没有调对、
    		方法没有写正确、单词写错、加载JAR包出现问题、代码书写不规范等原因造成的、仔细检查排查出错误再继续运行即可
    

    5. 举例说明

    数学运算异常
    运行结果
    我们可以看出来、在上述程序中、并不属于JVM或者系统内部的错误、而是我们的业务逻辑出现的错误、这样的一场我们需要进行捕获和处理、不然程序将无法正确执行。那么我们程序员处理这类异常主要的方式有抛出异常和捕获处理异常的两种方式

    使用try-catch-finally代码块来进行手动捕获异常、并进行处理异常
    捕获并处理异常信息
    在这里插入图片描述

    5.1可检查异常、和不受检查异常

    1、可查异常:编译器要求必须处理的异常。正确的程序在运行过程中,经常容易出现的、符合预期的异常情况。一旦发生此类异常,就必须采用某种方式进行处理。除RuntimeException及其子类外,其他的Exception异常都属于可查异常。编译器会检查此类异常,也就是说当编译器检查到应用中的某处可能会此类异常时,将会提示你处理本异常——要么使用try-catch捕获,要么使用throws语句抛出,否则编译不通过。

    2、不可查异常:编译器不会进行检查并且不要求必须处理的异常,也就说当程序中出现此类异常时,即使我们没有try-catch捕获它,也没有使用throws抛出该异常,编译也会正常通过。该类异常包括运行时异常(RuntimeException极其子类)和错误(Error)。

    5.2 异常处理的流程

    在JAVA应用当中、异常处理的机制包括:捕获异常和抛出异常两种

    抛出异常:当一个方法出现错误而引发异常的时候、该方法会将可能出现的异常信息类型和异常出现的信息封装成一个异常对 象、任何代码都可以通过throw关键词抛出异常,比如java源代码抛出异常、自己编写的代码抛出异常等。
    捕获异常:一旦方法抛出异常、系统会根据该异常对象去寻找对应的异常处理器(ExceptionHandler)、来处理异常。

    6. try-catch-finally代码块的执行顺序

    try代码块

    6.1 try-catch-finally代码块执行的顺序

    在这里插入图片描述
    从上述代码中我们来进行分析try-catch-finally代码块的执行顺序、假设现在1号程序代码块出现了异常信息、那么程序会进行将1号程序出现的异常信息封装成一个异常对象 e、并将e对象存放在本程序中、JVM会调用该异常对象所匹配的ExceptionHandler异常处理器、最后返回结果、可以看出、在1号程序出现错误的时候、2 号程序和3号程序都不会再去执行、直接进入异常处理的部分、在最后的finally代码快中、无论程序是否发生异常信息、都回去执行、那么在封装完异常对象之后、就只执行finally代码块中的程序、一般在这块代码区域编写一些释放资源、检查等后期维护等代码块

    7. 总结异常

    我们可以出现嵌套异常try-catch
    在这里插入图片描述
    try代码块:用于捕获异常。其后可以接零个或者多个catch块。如果没有catch块,后必须跟finally块,来完成资源释放等操作,另外建议不要在finally中使用return,不用尝试通过catch来控制代码流程。
    Throwa异常的基类、超级父类
    Error是系统异常不需要处理
    Exception是异常积累、需要进行程序员处理

    8. 抛出异常信息

    public class Math {
        public int  method(int i,int j)throws Exception{
         int c =i/j;
         return c;      
        }
    }
    

    上述代码我们可以看出、method方法抛出了一个异常信息、那么我们在调用这个方法的时候就需要进行对该方法抛出的异常信息进行处理、不处理也可以那么就是用throws向上继续抛出该异常信息即可、也可以使用try-catch语句进行内部处理、不在抛出抛异常、否则会报出编译期异常信息
    在这里插入图片描述
    再来看这行代码:我们使用throw自定义了一个异常信息、当程序执行到16行的时候、出现了异常信息、那么17行就不会再去执行、并且报出编译期间的异常、就说明在发生异常的情况下之后的代码程序不再回去执行了

    面试题 throws和throw的区别?
    throws
    1. 用来定义一个方法可能出现的异常、一直往上抛、谁调用谁就来处理
    2. 用在方法声明后面,跟的是异常类名
    3. 可以跟多个异常类名,用逗号隔开(可以同时抛出很多异常、也可以直接采用超类Exception)
    4. 表示抛出异常,由该方法的调用者来处理
    5. throws表示出现异常的一种可能性,并不一定会发生这些异常
    throw
    1. 用来自定义一个异常信息
    2. 一定会发生的一个异常信息
    3. 主要声明方式在方法体内进行声明
    4. 每次只能抛出一个异常对象
    5. 若执行了带有throw的语句、那么一定会抛出一个异常

    9. 常见的异常类说明

    java.lang.IllegalAccessError:违法访问错误。当一个应用试图访问、修改某个类的域(Field)或者调用其方法,但是又违反域或方法的可见性声明,则抛出该异常。
    
    java.lang.InstantiationError:实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.
    
    java.lang.OutOfMemoryError:内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。
    java.lang.StackOverflowError:堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出或者陷入死循环时抛出该错误。
    
    java.lang.ClassCastException:类造型异常。假设有类A和B(A不是B的父类或子类),O是A的实例,那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。
    java.lang.ClassNotFoundException:找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。
    
    java.lang.ArithmeticException:算术条件异常。譬如:整数除零等。
    java.lang.ArrayIndexOutOfBoundsException:数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
    
    java.lang.IndexOutOfBoundsException:索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时,抛出该异常。
    java.lang.InstantiationException:实例化异常。当试图通过newInstance()方法创建某个类的实例,而该类是一个抽象类或接口时,抛出该异常。
    
    java.lang.NoSuchFieldException:属性不存在异常。当访问某个类的不存在的属性时抛出该异常。
    java.lang.NoSuchMethodException:方法不存在异常。当访问某个类的不存在的方法时抛出该异常。
    java.lang.NullPointerException:空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
    java.lang.NumberFormatException:数字格式异常。当试图将一个String转换为指定的数字类型,而该字符串确不满足数字类型要求的格式时,抛出该异常。
    
    java.lang.StringIndexOutOfBoundsException:字符串索引越界异常。当使用索引值访问某个字符串中的字符,而该索引值小于0或大于等于序列大小时,抛出该异常。
    

    10、其他异常

    java.lang.AbstractMethodError:抽象方法错误。当应用试图调用抽象方法时抛出。
    java.lang.AssertionError:断言错。用来指示一个断言失败的情况。
    java.lang.ClassCircularityError:类循环依赖错误。在初始化一个类时,若检测到类之间循环依赖则抛出该异常。
    java.lang.ClassFormatError:类格式错误。当Java虚拟机试图从一个文件中读取Java类,而检测到该文件的内容不符合类的有效格式时抛出。
    java.lang.Error:错误。是所有错误的基类,用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。
    java.lang.ExceptionInInitializerError:初始化程序错误。当执行一个类的静态初始化程序的过程中,发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。
    java.lang.IncompatibleClassChangeError:不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时,抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下,容易引发该错误。
    java.lang.InternalError:内部错误。用于指示Java虚拟机发生了内部错误。
    java.lang.LinkageError:链接错误。该错误及其所有子类指示某个类依赖于另外一些类,在该类编译之后,被依赖的类改变了其类定义而没有重新编译所有的类,进而引发错误的情况。
    java.lang.NoClassDefFoundError:未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类,而找不到该类的定义时抛出该错误。
    java.lang.NoSuchFieldError:域不存在错误。当应用试图访问或者修改某类的某个域,而该类的定义中没有该域的定义时抛出该错误。
    java.lang.NoSuchMethodError:方法不存在错误。当应用试图调用某类的某个方法,而该类的定义中没有该方法的定义时抛出该错误。
    java.lang.ThreadDeath:线程结束。当调用Thread类的stop方法时抛出该错误,用于指示线程结束。
    java.lang.UnknownError:未知错误。用于指示Java虚拟机发生了未知严重错误的情况。
    java.lang.UnsatisfiedLinkError:未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。
    java.lang.UnsupportedClassVersionError:不支持的类版本错误。当Java虚拟机试图从读取某个类文件,但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候,抛出该错误。
    java.lang.VerifyError:验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。
    java.lang.VirtualMachineError:虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。
    java.lang.ArrayStoreException:数组存储异常。当向数组中存放非数组声明类型对象时抛出。
    java.lang.CloneNotSupportedException:不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。
    java.lang.EnumConstantNotPresentException:枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象,但该枚举对象并不包含常量时,抛出该异常。
    java.lang.Exception:根异常。用以描述应用程序希望捕获的情况。
    java.lang.IllegalAccessException:违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法,而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。
    java.lang.IllegalMonitorStateException:违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象(O)的监控器或者通知其他线程等待该对象(O)的监控器时,抛出该异常。
    java.lang.IllegalStateException:违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态,而调用了该方法时,抛出该异常。
    java.lang.IllegalThreadStateException:违法的线程状态异常。当县城尚未处于某个方法的合法调用状态,而调用了该方法时,抛出异常。
    java.lang.InterruptedException:被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态,而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。
    java.lang.NegativeArraySizeException:数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。
    java.lang.SecurityException:安全异常。由安全管理器抛出,用于指示违反安全情况的异常。
    java.lang.TypeNotPresentException:类型不存在异常。
    
    展开全文
  • java(3)-深入理解java异常处理机制

    万次阅读 多人点赞 2011-01-20 18:44:00
    不过,我亲自体验的“教训”告诉我,这个东西可不是想象的那么简单、听话。不信?那你看看下面的代码,“猜猜”它执行后的结果会是什么?不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确,那么这...

     

    二.前言:引子


           try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训”告诉我,这个东西可不是想象中的那么简单、听话。不信?那你看看下面的代码,“猜猜”它执行后的结果会是什么?不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确,那么这篇文章你就不用浪费时间看啦。

    package Test;
    
    public class TestException {
    	public TestException() {
    	}
    
    	boolean testEx() throws Exception {
    		boolean ret = true;
    		try {
    			ret = testEx1();
    		} catch (Exception e) {
    			System.out.println("testEx, catch exception");
    			ret = false;
    			throw e;
    		} finally {
    			System.out.println("testEx, finally; return value=" + ret);
    			return ret;
    		}
    	}
    
    	boolean testEx1() throws Exception {
    		boolean ret = true;
    		try {
    			ret = testEx2();
    			if (!ret) {
    				return false;
    			}
    			System.out.println("testEx1, at the end of try");
    			return ret;
    		} catch (Exception e) {
    			System.out.println("testEx1, catch exception");
    			ret = false;
    			throw e;
    		} finally {
    			System.out.println("testEx1, finally; return value=" + ret);
    			return ret;
    		}
    	}
    
    	boolean testEx2() throws Exception {
    		boolean ret = true;
    		try {
    			int b = 12;
    			int c;
    			for (int i = 2; i >= -2; i--) {
    				c = b / i;
    				System.out.println("i=" + i);
    			}
    			return true;
    		} catch (Exception e) {
    			System.out.println("testEx2, catch exception");
    			ret = false;
    			throw e;
    		} finally {
    			System.out.println("testEx2, finally; return value=" + ret);
    			return ret;
    		}
    	}
    
    	public static void main(String[] args) {
    		TestException testException1 = new TestException();
    		try {
    			testException1.testEx();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    你的答案是什么?是下面的答案吗?

    i=2
    i=1
    testEx2, catch exception
    testEx2, finally; return value=false
    testEx1, catch exception
    testEx1, finally; return value=false
    testEx, catch exception
    testEx, finally; return value=false

    如果你的答案真的如上面所说,那么你错啦。^_^,那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试,你会发现有很多事情不是原来想象中的那么简单的。现在公布正确答案:

    i=2
    i=1
    testEx2, catch exception
    testEx2, finally; return value=false
    testEx1, finally; return value=false
    testEx, finally; return value=false

     

    注意说明:

    finally语句块不应该出现 应该出现return。上面的return ret最好是其他语句来处理相关逻辑。

     

    二.JAVA异常


       异常指不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。异常是一个事件,它发生在程序运行期间,干扰了正常的指令流程。Java通 过API中Throwable类的众多子类描述各种不同的异常。因而,Java异常都是对象,是Throwable子类的实例,描述了出现在一段编码中的 错误条件。当条件生成时,错误将引发异常。

          Java异常类层次结构图:

     

            

     

     

                                                                        图1 Java异常类层次结构图

     

     

            在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
           Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常处理的重要子类,各自都包含大量子类。

     

           Error(错误):是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 不再有继续执行操作所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。

    。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,因为它们在应用程序的控制和处理能力之 外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过Error的子类描述。

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

           Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。

       注意:异常和错误的区别:异常能被程序本身可以处理,错误是无法处理。

       通常,Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)
          可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常状况。可查异常虽然是异常状况,但在一定程度上它的发生是可以预计的,而且一旦发生这种异常状况,就必须采取某种方式进行处理。

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

         不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。

         Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

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

          运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。
           非运行时异常 (编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常

      

    三.处理异常机制


            在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。

            抛出异常当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

            捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。

            对于运行时异常、错误或可查异常,Java技术所要求的异常处理方式有所不同。

            由于运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常。

           对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常。

           对于所有的可查异常,Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常。

            能够捕捉异常的方法,需要提供相符类型的异常处理器。所捕捉的异常,可能是由于自身语句所引发并抛出的异常,也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常简单地说,异常总是先被抛出,后被捕捉的。

             任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。

            从方法中抛出的任何异常都必须使用throws子句。

            捕捉异常通过try-catch语句或者try-catch-finally语句实现。

             总体来说,Java规定:对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

    3.1 捕获异常:try、catch 和 finally

    1.try-catch语句

         在Java中,异常通过try-catch语句捕获。其一般语法形式为:

    try {
        // 可能会发生异常的程序代码
    } catch (Type1 id1){
        // 捕获并处置try抛出的异常类型Type1
    }
    catch (Type2 id2){
         //捕获并处置try抛出的异常类型Type2
    }

     

           关键词try后的一对大括号将一块可能发生异常的代码包起来,称为监控区域。Java方法在运行过程中出现异常,则创建异常对象。将异常抛出监控区域之 外,由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句,则运行其异常处理代码,try-catch语句结束。

           匹配的原则是:如果抛出的异常对象属于catch子句的异常类,或者属于该异常类的子类,则认为生成的异常对象与catch块捕获的异常类型相匹配。

    例1  捕捉throw语句抛出的“除数为0”异常。

    public class TestException {
    	public static void main(String[] args) {
    		int a = 6;
    		int b = 0;
    		try { // try监控区域
    			
    			if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常
    			System.out.println("a/b的值是:" + a / b);
    		}
    		catch (ArithmeticException e) { // catch捕捉异常
    			System.out.println("程序出现异常,变量b不能为0。");
    		}
    		System.out.println("程序正常结束。");
    	}
    }

    运行结果:程序出现异常,变量b不能为0。

                        程序正常结束。

            例1  在try监控区域通过if语句进行判断,当“除数为0”的错误条件成立时引发ArithmeticException异常,创建 ArithmeticException异常对象,并由throw语句将异常抛给Java运行时系统,由系统寻找匹配的异常处理器catch并运行相应异 常处理代码,打印输出“程序出现异常,变量b不能为0。”try-catch语句结束,继续程序流程。

            事实上,“除数为0”等ArithmeticException,是RuntimException的子类。而运行时异常将由运行时系统自动抛出,不需要使用throw语句。

    例2  捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常。

    	public static void main(String[] args) {
    		int a = 6;
    		int b = 0;
    		try {
    			System.out.println("a/b的值是:" + a / b);
    		} catch (ArithmeticException e) {
    			System.out.println("程序出现异常,变量b不能为0。");
    		}
    		System.out.println("程序正常结束。");
    	}
    }

    运行结果:程序出现异常,变量b不能为0。

                      程序正常结束。

    例2  中的语句:

    System.out.println("a/b的值是:" + a/b);

          在运行中出现“除数为0”错误,引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域,转而匹配合适的异常处理器catch,并执行相应的异常处理代码。

          由于检查运行时异常的代价远大于捕捉异常所带来的益处,运行时异常不可查。Java编译器允许忽略运行时异常,一个方法可以既不捕捉,也不声明抛出运行时异常。

    例3  不捕捉、也不声明抛出运行时异常。

    public class TestException {
    	public static void main(String[] args) {
    		int a, b;
    		a = 6;
    		b = 0; // 除数b 的值为0
    		System.out.println(a / b);
    	}
    }

    运行结果:

    Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Test.TestException.main(TestException.java:8)

    例4  程序可能存在除数为0异常和数组下标越界异常。

    public class TestException {
    	public static void main(String[] args) {
    		int[] intArray = new int[3];
    		try {
    			for (int i = 0; i <= intArray.length; i++) {
    				intArray[i] = i;
    				System.out.println("intArray[" + i + "] = " + intArray[i]);
    				System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值:  "
    						+ intArray[i] % (i - 2));
    			}
    		} catch (ArrayIndexOutOfBoundsException e) {
    			System.out.println("intArray数组下标越界异常。");
    		} catch (ArithmeticException e) {
    			System.out.println("除数为0异常。");
    		}
    		System.out.println("程序正常结束。");
    	}
    }

    运行结果:

    intArray[0] = 0

    intArray[0]模 -2的值:  0

    intArray[1] = 1

    intArray[1]模 -1的值:  0

    intArray[2] = 2

    除数为0异常。

    程序正常结束。

          例4  程序可能会出现除数为0异常,还可能会出现数组下标越界异常。程序运行过程中ArithmeticException异常类型是先行匹配的,因此执行相匹配的catch语句:

    catch (ArithmeticException e){
          System.out.println("除数为0异常。");
     }

     

           需要注意的是,一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。一经处理结束,就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

          Java通过异常类描述异常类型,异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言,应该尽量将捕获底层异常类的catch子 句放在前面,同时尽量将捕获相对高层的异常类的catch子句放在后面。否则,捕获底层异常类的catch子句将可能会被屏蔽。

          RuntimeException异常类包括运行时各种常见的异常,ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此,RuntimeException异常类的catch子句应该放在 最后面,否则可能会屏蔽其后的特定异常处理或引起编译错误。

    2. try-catch-finally语句

          try-catch语句还可以包括第三部分,就是finally子句。它表示无论是否出现异常,都应当执行的内容。try-catch-finally语句的一般语法形式为:

                    try {
    			// 可能会发生异常的程序代码
    		} catch (Type1 id1) {
    			// 捕获并处理try抛出的异常类型Type1
    		} catch (Type2 id2) {
    			// 捕获并处理try抛出的异常类型Type2
    		} finally {
    			// 无论是否发生异常,都将执行的语句块
    		}

    例5  带finally子句的异常处理程序。

    public class TestException {
    	public static void main(String args[]) {
    		int i = 0;
    		String greetings[] = { " Hello world !", " Hello World !! ",
    				" HELLO WORLD !!!" };
    		while (i < 4) {
    			try {
    				// 特别注意循环控制变量i的设计,避免造成无限循环
    				System.out.println(greetings[i++]);
    			} catch (ArrayIndexOutOfBoundsException e) {
    				System.out.println("数组下标越界异常");
    			} finally {
    				System.out.println("--------------------------");
    			}
    		}
    	}
    }

    运行结果:

    Hello world !

    --------------------------

    Hello World !!

    --------------------------

    HELLO WORLD !!!

    --------------------------

    数组下标越界异常

    --------------------------

         在例5中,请特别注意try子句中语句块的设计,如果设计为如下,将会出现死循环。如果设计为:

     

    try {
          System.out.println (greetings[i]); i++;
    }

     

    小结:

    try 块:用于捕获异常。其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
    catch 块:用于处理try捕获到的异常。
    finally 块:无论是否捕获或处理异常,finally块里的语句都会被执行。
    当在try块或catch块中遇到return语句时,finally语句块将在方法返回之前被执行。在以下4种特殊情况下,finally块不会被执行:
    1)在finally语句块中发生了异常。
    2)在前面的代码中用了System.exit()退出程序。
    3)程序所在的线程死亡。
    4)关闭CPU。

     

     

    3. try-catch-finally 规则(异常处理语句的语法规则):

    1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块,但至少有一个块。
    2) 必须遵循块顺序:若代码同时使用 catch 和 finally 块,则必须将 catch 块放在 try 块之后。
    3) catch 块与相应的异常类的类型相关。
    4) 一个 try 块可能有多个 catch 块。若如此,则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配,如果异常对象为某个异常类型或其子类的实例,就执行这个catch代码块,不会再执行其他的 catch代码块
    5) 可嵌套 try-catch-finally 结构。
    6) 在 try-catch-finally 结构中,可重新抛出异常。
    7) 除了下列情况,总将执行 finally 做为结束:JVM 过早终止(调用 System.exit(int));在 finally 块中抛出一个未处理的异常;计算机断电、失火、或遭遇病毒攻击。

    4. try、catch、finally语句块的执行顺序:

     

    1)当try没有捕获到异常时:try语句块中的语句逐一被执行,程序将跳过catch语句块,执行finally语句块和其后的语句;

    2)当try捕获到异常,catch语句块里没有处理此异常的情况:当try语句块里的某条语句出现异常时,而没有处理此异常的catch语句块时,此异常将会抛给JVM处理,finally语句块里的语句还是会被执行,但finally语句块后的语句不会被执行;

    3)当try捕获到异常,catch语句块里有处理此异常的情况:在try语句块中是按照顺序来执行的,当执行到某一条语句出现异常时,程序将跳到catch语句块,并与catch语句块逐一匹配,找到与之对应的处理程序,其他的catch语句块将不会被执行,而try语句块中,出现异常之后的语句也不会被执行,catch语句块执行完后,执行finally语句块里的语句,最后执行finally语句块后的语句;

     图示try、catch、finally语句块的执行:

                                              图2  图示try、catch、finally语句块的执行
     

    3.2 抛出异常

          任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。

    1. throws抛出异常

       如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障,汽车本身没办法处理这个故障,那就让开车的人来处理。

         throws语句用在方法定义时声明该方法要抛出的异常类型,如果抛出的是Exception异常类型,则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为:

    methodname throws Exception1,Exception2,..,ExceptionN
    {
    }

        方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时,方法将不对这些类型及其子类类型的异常作处理,而抛向调用该方法的方法,由他去处理。例如:

     

    import java.lang.Exception;
    public class TestException {
    	static void pop() throws NegativeArraySizeException {
    		// 定义方法并抛出NegativeArraySizeException异常
    		int[] arr = new int[-3]; // 创建数组
    	}
    
    	public static void main(String[] args) { // 主方法
    		try { // try语句处理异常信息
    			pop(); // 调用pop()方法
    		} catch (NegativeArraySizeException e) {
    			System.out.println("pop()方法抛出的异常");// 输出异常信息
    		}
    	}
    
    }

     

        使用throws关键字将异常抛给调用者后,如果调用者不想处理该异常,可以继续向上抛出,但最终要有能够处理该异常的调用者。

        pop方法没有处理异常NegativeArraySizeException,而是由main函数来处理。

        Throws抛出异常的规则:

        1) 如果是不可查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。

        2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误

        3)仅当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,而不是囫囵吞枣。

     

        4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

        例如:

     

    void method1() throws IOException{}  //合法  
     
    //编译错误,必须捕获或声明抛出IOException  
    void method2(){  
      method1();  
    }  
     
    //合法,声明抛出IOException  
    void method3()throws IOException {  
      method1();  
    }  
     
    //合法,声明抛出Exception,IOException是Exception的子类  
    void method4()throws Exception {  
      method1();  
    }  
     
    //合法,捕获IOException  
    void method5(){  
     try{  
        method1();  
     }catch(IOException e){…}  
    }  
     
    //编译错误,必须捕获或声明抛出Exception  
    void method6(){  
      try{  
        method1();  
      }catch(IOException e){throw new Exception();}  
    }  
     
    //合法,声明抛出Exception  
    void method7()throws Exception{  
     try{  
      method1();  
     }catch(IOException e){throw new Exception();}  
    } 

         判断一个方法可能会出现异常的依据如下:
         1)方法中有throw语句。例如,以上method7()方法的catch代码块有throw语句。
         2)调用了其他方法,其他方法用throws子句声明抛出某种异常。例如,method3()方法调用了method1()方法,method1()方法声明抛出IOException,因此,在method3()方法中可能会出现IOException。

     

    2. 使用throw抛出异常

       throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。
      我们知道,异常是异常类的实例对象,我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为:
        throw new exceptionname;
        例如抛出一个IOException类的异常对象:
        throw new IOException;
        要注意的是,throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的:
        throw new String("exception");

        这是因为String 不是Throwable 类的子类。

        如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

        如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。

    package Test;
    import java.lang.Exception;
    public class TestException {
    	static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
    		if (y < 0) { // 判断参数是否小于0
    			throw new MyException("除数不能是负数"); // 异常信息
    		}
    		return x/y; // 返回值
    	}
    	public static void main(String args[]) { // 主方法
    		int  a =3;
    		int  b =0; 
    		try { // try语句包含可能发生异常的语句
    			int result = quotient(a, b); // 调用方法quotient()
    		} catch (MyException e) { // 处理自定义异常
    			System.out.println(e.getMessage()); // 输出异常信息
    		} catch (ArithmeticException e) { // 处理ArithmeticException异常
    			System.out.println("除数不能为0"); // 输出提示信息
    		} catch (Exception e) { // 处理其他异常
    			System.out.println("程序发生了其他的异常"); // 输出提示信息
    		}
    	}
    
    }
    class MyException extends Exception { // 创建自定义异常类
    	String message; // 定义String类型变量
    	public MyException(String ErrorMessagr) { // 父类方法
    		message = ErrorMessagr;
    	}
    
    	public String getMessage() { // 覆盖getMessage()方法
    		return message;
    	}
    }

    注意:

    1、Throw (是 catch 中还是非 catch 中)后面不能再跟其他代码块了 ,否则编译不能通过,

    例如把return和throw放在一起,IDEA直接提示错误:"Unreachable statement" .

    2、但可以在finally语句块有return语句,finally语句块成功骗过编译器让throw和return两者并存

    我们根据开头引子的例子,可以得出结论:

    finally如果有return会覆盖catch里的throw,同样如果finally里有throw会覆盖catch里的return。

    进而如果catch里和finally都有return, finally中的return会覆盖catch中的。throw也是如此。

     

    3.3 异常链

          1) 如果调用quotient(3,-1),将发生MyException异常,程序调转到catch (MyException e)代码块中执行;

          2) 如果调用quotient(5,0)将会因“除数为0”错误引发ArithmeticException异常,属于运行时异常类,由Java运行时系统自动抛出。quotient()方法没有捕捉ArithmeticException异常,Java运行时系统将沿方法调用栈查到main方法,将抛出的异常上传至quotient()方法的调用者:

             int result = quotient(a, b); // 调用方法quotient()
            由于该语句在try监控区域内,因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出,并匹配catch子句:

           catch (ArithmeticException e) { // 处理ArithmeticException异常
    System.out.println("除数不能为0"); // 输出提示信息

            处理结果是输出“除数不能为0”。Java这种向上传递异常信息的处理机制,形成异常链

           Java方法抛出的可查异常将依据调用栈、沿着方法调用的层次结构一直传递到具备处理能力的调用方法,最高层次到main方法为止。如果异常传递到main方法,而main不具备处理能力,也没有通过throws声明抛出该异常,将可能出现编译错误。

     

          3)如还有其他异常发生,将使用catch (Exception e)捕捉异常。由于Exception是所有异常类的父类,如果将catch (Exception e)代码块放在其他两个代码块的前面,后面的代码块将永远得不到执行,就没有什么意义了,所以catch语句的顺序不可掉换。

    3.4 Throwable类中的常用方法

    注意:catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型,e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

         getCause():返回抛出异常的原因。如果 cause 不存在或未知,则返回 null。

      getMeage():返回异常的消息信息。

      printStackTrace():对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值。

         有时为了简单会忽略掉catch语句后的代码,这样try-catch语句就成了一种摆设,一旦程序在运行过程中出现了异常,就会忽略处理异常,而错误发生的原因很难查找。

     

    四.try catch finally 语句中有return情况


    1、try中有return语句和最后有return:

    我们看看这段代码的输出结果:

    public class testExcReurn {
        public int add(int a,int b) {
            try {
                return a+b;
            }catch(Exception e){
                System.out.println("catch语句块");
            }finally {
                System.out.println("finally语句块");
            }
            return 0;
        }
        public static void main(String[] args) {
            testExcReurn t = new testExcReurn();
            System.out.println("和="+t.add(9, 34));
        }
    }

    A、catch语句块 和=43
    B、编译异常
    C、finally语句块 和=43
    D、和=43 finally语句块

    正确答案:C

    合理的解释是,在try中执行到return语句时,不会真正的return,即只是会计算return中的表达式,之后将结果保存在一个临时栈中,接着执行finally中的语句,最后才会从临时栈中取出之前的结果返回。

    2、try和finally都有return语句:

    public class testExcReurn {
        public int add(int a,int b) {
            try {
                return a+b;
            }catch(Exception e){
                System.out.println("catch语句块");
            }finally {
                System.out.println("finally语句块");
                return 0;
            }
        }
        public static void main(String[] args) {
            testExcReurn t = new testExcReurn();
            System.out.println("和="+t.add(9, 34));
        }
    }

    finnaly会覆盖try的return语句。

    3、return的数据是引用数据类型

    public class testExcReurn {
        public int a;
        public testExcReurn set() {
            try {
                this.a  = 10;
                return this;
            }catch(Exception e){
                System.out.println("catch语句块");
            }finally {
                System.out.println("finally语句块");
                this.a = 200;
            }
            return this;
        }
        public static void main(String[] args) {
            testExcReurn t = new testExcReurn();
            t.set();
            System.out.println("a="+ t.a);
        }
    }

     

    结论:

    1、finally覆盖catch(开头引子的例子):

          1)如果finally有return会覆盖catch里的throw,同样如果finally里有throw会覆盖catch里的return。

          2) 如果catch里和finally都有return, finally中的return会覆盖catch中的。throw也是如此。

    2、catch有return而finally没有:

         当 try 中抛出异常且catch 中有 return 语句,finally 中没有 return 语句, java 先执行 catch 中非 return 语句,再执行 finally 语句,最后执行 catch 中 return 语句。

    3、try有return语句,后续还有return语句,分为以下三种情况:

        情况一:如果finally中有return语句,则会将try中的return语句”覆盖“掉,直接执行finally中的return语句,得到返回值,这样便无法得到try之前保留好的返回值。

        情况二:如果finally中没有return语句,也没有改变要返回值,则执行完finally中的语句后,会接着执行try中的return语句,返回之前保留的值。

        情况三:如果finally中没有return语句,但是改变了要返回的值,这里有点类似与引用传递和值传递的区别,分以下两种情况,:

            1)如果return的数据是基本数据类型或文本字符串,则在finally中对该基本数据的改变不起作用,try中的return语句依然会返回进入finally块之前保留的值。

            2)如果return的数据是引用数据类型,而在finally中对该引用数据类型的属性值的改变起作用,try中的return语句返回的就是在finally中改变后的该属性的值。

     

     

    五.Java常见异常


    在Java中提供了一些异常用来描述经常发生的错误,对于这些异常,有的需要程序员进行捕获处理或声明抛出,有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:

     

    1. runtimeException子类:

        1、 java.lang.ArrayIndexOutOfBoundsException
        数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
        2、java.lang.ArithmeticException
        算术条件异常。譬如:整数除零等。
        3、java.lang.NullPointerException
        空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
        4、java.lang.ClassNotFoundException
        找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。

       5、java.lang.NegativeArraySizeException  数组长度为负异常

       6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

       7、java.lang.SecurityException 安全性异常

       8、java.lang.IllegalArgumentException 非法参数异常

    2.IOException

    IOException:操作输入流和输出流时可能出现的异常。

    EOFException   文件已结束异常

    FileNotFoundException   文件未找到异常

    3. 其他

    ClassCastException    类型转换异常类

    ArrayStoreException  数组中包含不兼容的值抛出的异常

    SQLException   操作数据库异常类

    NoSuchFieldException   字段未找到异常

    NoSuchMethodException   方法未找到抛出的异常

    NumberFormatException    字符串转换为数字抛出的异常

    StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

    IllegalAccessException  不允许访问某类异常

    InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例,而指定的类对象无法被实例化时,抛出该异常

     

     5.自定义异常


    使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外,用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可。
    在程序中使用自定义异常类,大体可分为以下几个步骤:

    1)创建自定义异常类:一般会选择继承Exception和RuntimeException,如果不要求调用者一定要处理抛出的异常,就继承RuntimeException。
    2)抛出自定义异常:在方法中通过throw关键字抛出异常对象。
    3)捕获自定义异常:如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作。
    4)在出现异常方法的调用者中捕获并处理异常
    在上面的“使用throw抛出异常”例子已经提到了:

    class MyException extends Exception { // 创建自定义异常类
        String message; // 定义String类型变量
        public MyException(String ErrorMessagr) { // 父类方法
            message = ErrorMessagr;
        }
    
        public String getMessage() { // 覆盖getMessage()方法
            return message;
        }
    }

     

     
    展开全文
  • java中异常处理

    2015-08-01 21:26:50
    异常在程序运行过程不正常的情况,也就是问题被称为异常。问题分为两种:  一种是非常严重的问题,称为Error。java针对Error一般不编写针对性的代码对其进行处理。JVM直接终止。  一种是不严重的问题, 称为...
  • java异常处理

    千次阅读 2017-10-24 18:15:42
    java异常处理基础
  • Java编写简单的自定义异常

    万次阅读 多人点赞 2017-12-29 19:19:07
    在程序中明确抛出引发的异常,比如throw new Exception(); 3:throws 表明方法可能会引发异常方法内部并不处理这个异常,想要得到异常的话,调用者使用try catch语句即可得到 4:finally 不管有没有异常程序段...
  • Java异常处理

    千次阅读 2018-10-27 22:40:55
    Java提供了异常处理机制来帮程序员检查可能出现的错误,保证了程序的可读性和可维护性。它将异常封装到一个类,当出现错误时(比如打开一个不存在的文件、网络Socket连接超时等)就会抛出异常Java类库的每个包...
  • Java 异常处理

    千次阅读 2017-10-07 11:18:08
    总结异常的概念异常程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误java.lang.Error;如果你用System.out
  • java中异常处理

    2016-05-21 18:05:11
    java程序正在执行过程异常事件可以分为两类: Error:java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。 如:java.lang.StackOverflowError栈溢出...
  • JAVA异常处理

    千次阅读 2015-12-27 15:09:00
    一个方法的运行过程,如果发生了异常,则这个方法(或者java虚拟机)生成一个代表该异常的对象,该异常对象包括了异常事件类型以及发生异常时应用程序目前的状态和调用过程。异常的分类java类库定了了
  • JAVA中异常处理机制及异常分类

    万次阅读 多人点赞 2017-04-01 16:18:27
    JAVA异常处理机制:如果某个方法不能按照正常的途径完成任务,就可以通过另一种路径退出方法。这种情况下会抛出一个封装了错误信息的对象。此时,这个方法会立刻退出同时不返回任何值。另外,调用这个方法的其他...
  • Java学习-详谈Java异常异常处理

    千次阅读 2020-09-13 17:14:17
    1、异常 ...在Java等面向对象的编程语言异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。 2、异常体系 2.1Throwable类 异常的根类: java.lang.T
  • Java中异常类的编写

    千次阅读 2018-07-18 08:17:05
    我们系统我们经常需要编写自己的异常类,那我们应该如果编写呢?今天我们就来看一下,话不多说上个类图展示一下 java异常类设计 ——————————————————————————————————...
  • Java异常处理的技巧

    千次阅读 2017-06-17 10:31:57
    Java异常分为检查异常和...Java异常处理机制可以很好帮助程序员在编写程序的过程,了解到使用的方法可能出现的异常并进行相应的处理,而不像C或者C++语言。但是Java异常处理机制,也存在着很大的问题。 比如
  • JAVA 异常处理

    千次阅读 热门讨论 2020-10-31 17:19:59
    1、异常:就是程序运行时出现不正常情况 异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。 对于问题的划分(两种)...
  • Java中异常处理

    千次阅读 2012-12-10 16:00:04
    对于初学JAVA的菜鸟,往往对异常处理不是很清楚。本文比较全面浅显的介绍下异常处理。 1.异常处理的优势 异常处理最根本的优势是将检测错误(由被调用的方法完成)从处理错误(由调用方法完成)分离出来。 2....
  • Python 和 Java 异常处理对比

    千次阅读 2017-07-01 13:43:42
    当你在编写程序时,可能由于人为或其它因素导致发生异常后,如果不对异常处理程序就无法继续执行。Python语言也有自己的异常处理,下面我们先看下Java中异常处理,然后再对比Python异常处理,其实它们都...
  • Java ,所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable: 有两个重要的子类:Exception(异常) 和 Error(错误) ,二者都是 Java 异常处理的重要子类,各自都包含大量子类。 Error...
  • Java异常处理:给程序罩一层保险

    千次阅读 2019-01-11 08:31:46
    异常发生了,是任程序自生自灭,还是将错误输出给用户? Java为此提供的解决方案是——异常处理机制。
  • 目录异常的产生处理异常异常处理流程throws关键字throw关键字throws与thorw的区别:Exception与其父类Throwable总结 异常的产生 1.异常程序上的错误,包括程序逻辑错误和系统错误。如算术错误、使用空的引用、...
  • Java 处理异常

    千次阅读 2017-06-08 22:36:39
    Java 使用 try-catch 或 try-catch-finally 来捕获并处理异常。一、关于try - catch基本语法try{ //一些会抛出异常的方法 }catch(Exception e){ //处理异常的代码块 }如果try块的代码抛出异常会发生什么呢?抛...
  • Java中的常用异常处理方法

    万次阅读 2016-05-26 09:50:49
    觉得自己是一个Java专家...下面这段代码,你能够迅速找出异常处理的六个问题吗? 1 OutputStreamWriter out = ... 2 java.sql.Connection conn = ... 3 try { // ⑸ 4 Statement stat = conn.createStatemen
  • JAVA异常处理

    2013-09-04 10:38:39
    异常处理主要包括捕获异常程序流程的跳转和异常处理语句块的定义等。当一个异常被抛出时,应该有专门的语句来捕获这个被抛出的异常对象,这个过程被称为捕获异常。当一个异常类的对象被捕获后,用户程序就会发生...
  • Java中异常以及对异常处理

    千次阅读 2018-04-23 21:57:17
    Java代码运行时期发生的问题就是异常Java,把异常信息封装成了一...Exception类及其子类是Throwable的一种形式,它用来表示Java程序中可能会产生的异常,并要求对产生的异常进行合理的异常处理。 Exceptio...
  • java异常处理机制

    千次阅读 2016-02-29 23:15:07
    当我们在处理程序的过程难免会不犯错误,为了更高效率的提高程序的可行性,詹姆斯大叔(詹姆斯·高斯林)为我们提供了一种异常处理的机制,以处理程序中可能出现的错误与异常。在这里我先大胆的将异常机制定义为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 254,487
精华内容 101,794
关键字:

在编写异常处理的java程序中

java 订阅