精华内容
下载资源
问答
  • java异常处理
    千次阅读
    2021-06-27 19:41:22

    1.java异常处理机制
    java的异常处理机制可以让程序具有极好的容错性,让程序更加健壮。当程序运行出现意外情形时,系 统会自动生成一个 Exception对象来通知程序,从而实现将“业务功能实现代码”和“错误处理代码”分离, 提供更好的可读性
    2.使用try…catch捕获异常
    一、Java异常处理机制为:抛出异常,捕捉异常,处理异常。
    二、Java…catch语法格式:
    try { //业务功能代码 }
    catch(异常类1 e1)
    { //异常处理代码1 }
    catch(异常类2 e2)
    { //异常处理代码1 }

    catch(异常类n en)
    { //异常处理代码n }
    三、在使用try…catch捕获处理异常时需要注意:
     不要过度使用异常,不能使用异常处理机制来代替正常的流程控制语句
     异常捕获时,一定要先捕获小异常,再捕获大异常。否则小异常将无法被捕获
     避免出现庞大的try块
     避免使用catch(Exception e){}
     不要略异常
    2.java异常体系(错误和异常)
    一、java把所有的非正常情况分成两种:异常(Exception)和错误(Error),它们都继承Throwable父类。
    二、Error错误,一般是指与虚拟机相关的问题,如系统崩溃、虚拟机错误、动态链接失败等,这种错误无法 恢复或不可能捕获,将导致应用程序中断。通常应用程序无法处理这些错误,因此应用程序不应该试图 使用catch块来捕获Error对象。在定义该方法时,也无须在其throws子句中声明该方法可能抛出Error及 其任何子类。
    3.多异常捕获
    一、从java7开始,一个catch块可以捕获多种类型异常
    二、在使用一个catch块捕获多种异常类型时需要注意:
     捕获多种类型异常时,多种异常类型之间用竖线(|)隔开
     捕获多种类型的异常时,异常变量有隐式的final修饰,因此程序不能对异常变重新赋值
    4.finally块
    finally块一般用来关闭物理资源(数据库连接,网络连接,磁盘文件等),这些物理资源必须显式关 闭。除非在try块、catch块中调用了退出虚拟机的方法( System.exit(0); ),否则不管在try块、 catch块中执行怎样的代码,出现怎样的情况,异常处理的finally块一定会被执行。
    5. Checked异常和Runtime异常
    一、Java的异常被分为两大类:Checked异常和Runtime异常(运行时异常)。
     Runtime异常:所有的RuntimeException类及其子类的实例;
     Checked异常:不是RuntimeException类及其子类的异常实例。
    二、只有Java语言提供了Checked异常,其他语言都没有提供Checked异常。Java认为Checked异常都是可 以被处理(修复)的异常,所以Java程序必须显式处理Checked异常。如果程序没有处理Checked异 常,该程序在编译时就会发生错误,无法通过编译。
    三、Checked异常体现了Java的设计哲学:没有完善错误处理的代码根本就不会被执行。
    四、Runtime异常则更加灵活,Runtime异常无须显式声明抛出,如果程序需要捕获Runtime异常,也可以 使用try…catch块来实现。
    6. 使用throws抛出异常
    一、使用throws声明抛出异常的思路是,当前方法不知道如何处理这种类型的异常,该异常应该由上级调用 者处理;如果main方法也不知道如何处理这种类型的异常,也可以使用throws声明抛出异常,该异常将 交给JVM处理。JVM对异常的处理方法是,打印异常的跟踪栈信息,并中止程序运行。
    二、throws声明抛出异常的格式:
    throws 异常类1,异常类2,异常类3,…
    7. 使用throw抛出异常
    一、Java也允许程序自行抛出异常,自行抛出异常使用throw语句来完成(注意此处的throw没有后面的s)
    二、如果需要在程序中自行抛出异常,则应使用throw语句,throw语句可以单独使用,throw语句抛出的不 是异常类,而是一个异常实例,而且每次只能抛出一个异常实例。
    三、throw语句的语法格式:
    throw 异常实例
    8.自定义异常
    用户自定义异常都应该继承Exception基类;如果希望自定义Runtime异常,则应该继承 RuntimeException基类。定义异常类时通常需要提供两个构造器:一个是无参数的构造器;另一个是带 个字符串参数的构造器,这个字符串将作为该异常对象的描述信息(也就是异常对象的getMessage()方 法的返回值)。

    更多相关内容
  • 最全最详细的Java异常处理机制

    千次阅读 多人点赞 2022-01-27 11:21:36
    一、异常概述与异常体系结构 异常概述 在使用计算机语言进行项目开发的过程中,即使程序员把代码写得尽善尽美,在系统的运行过程中仍然会遇到一些问题,因为...Java程序在执行过程中所发生的异常事件可分为两类: ...

    一、异常概述与异常体系结构

    异常概述

            在使用计算机语言进行项目开发的过程中,即使程序员把代码写得尽善尽美,在系统的运行过程中仍然会遇到一些问题,因为很多问题不是靠代码能够避免的,比如:客户输入数据的格式,读取文件是否存在,网络是否始终保持通畅等等。
        
            程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常(开发过程中的语法错误和逻辑错误不是异常)。

            Java程序在执行过程中所发生的异常事件可分为两类:
            Error:Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError(栈溢出)和OOM(内存溢出)。一般不编写针对性的代码进行处理。
            Exception: 其它因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。例如:
                空指针访问
                试图读取不存在的文件
                网络连接中断
                数组角标越界

    Error示例代码:

    public class ErrorTest {
        public static void main(String[] args) {
            /*
             * 1、栈溢出:java.lang.StackOverflowError
             *   原因 : 函数调用栈太深了,注意代码中是否有了循环调用方法而无法退出的情况
             *   StackOverflowError 是一个java中常出现的错误:在jvm运行时的数据区域中有一个java虚拟机栈,当执行java方法时会进行压栈弹栈的操作。在栈中会保存局部变量,操作数栈,方法出口等等。jvm规定了栈的最大深度,当执行时栈的深度大于了规定的深度,就会抛出StackOverflowError错误。
             * */
            main(args);
    
            /*
             * 2、堆溢出:java.lang.OutOfMemoryError
             *   原因:Java中所有的对象都存储在堆中,通常如果JVM无法再分配新的内存,内存耗尽,垃圾回收无法及时回收内存,就会抛出OutOfMemoryError。
             * */
            Integer[] arr = new Integer[1024 * 1024 * 1024];
    
        }
    }

    Exception示例代码:

    import java.io.FileInputStream;
    
    public class ExceptionTest {
        public static void main(String[] args) {
            /*
             * 1、运行时异常:java.lang.ArithmeticException
             *  原因:ArithmeticException
             * */
            int a = 10;
            int b = 0;
            System.out.println(a / b);
    
            /*
             * 2、编译期异常:java.io.FileNotFoundException
             *   原因:文件找不到异常通常是两种情况:1、系统找不到指定的路径 2、拒绝访问(指定的是目录时,就会报拒绝访问异常)
             * */
            FileInputStream fis = new FileInputStream("a.txt");
    
        }
    }

            异常发生时,是任程序自生自灭,立刻退出终止,还是输出错误给用户?或者用C语言风格:用函数返回值作为执行状态?

            Java提供了更加优秀的解决办法:异常处理机制。异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续执行,且保持代码的清晰。

            Java中的异常可以是函数中的语句执行时引发的,也可以是程序员通过throw 语句手动抛出的,只要在Java程序中产生了异常,就会用一个对应类型的异常对象来封装异常,JRE就会试图寻找异常处理程序来处理异常。
     
            Throwable类是Java异常类型的顶层父类,一个对象只有是 Throwable 类的(直接或者间接)实例,他才是一个异常对象,才能被异常处理机制识别。JDK中内建了一些常用的异常类,我们也可以自定义异常。

    异常体系结构

            Java标准库内建了一些通用的异常,这些类以Throwable为顶层父类。

            Throwable又派生出Error类和Exception类。

            错误:Error类以及它的子类的实例,代表了JVM本身的错误。错误不能被程序员通过代码处理,Error很少出现。因此,程序员应该关注Exception为父类的分支下的各种异常类。

            异常:Exception以及它的子类,代表程序运行时发生的各种不期望发生的事件。可以被Java异常处理机制使用,是异常处理的核心。

    Error和Exception的区别:

            Error和Exception都有一个共同的根类是Throwable类。
        
            Error是系统中的错误,程序员是不能改变的和处理的,一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢等。对于这类错误的导致的应用程序中断,仅靠程序本身无法恢复和和预防,遇到这样的错误,建议让程序终止。因此我们编写程序时不需要关心这类错误。
        
            Exception,也就是我们经常见到的一些异常情况,表示程序可以处理的异常,可以捕获且可能恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。

    异常体系结构图:

    异常分类

            总体上我们根据Javac对异常的处理要求,将异常类分为2类。
        
            我们常说的异常是狭义上的:就是指Exception及其子类,但是广义上的异常是包括Exception和Error;

            Java的异常(包括Exception和Error)从广义上分为检查异常(checked exceptions)和非检查的异常(unchecked exceptions)。

            其中根据Exception异常进行划分,可分为运行时异常和非运行时异常。

            需要明确的是:检查和非检查是对于javac来说的,这样就很好理解和区分了。

    检查异常

    What:什么是检查异常(checked exception)?

            就是编译器要求你必须处置的异常。不知道你编程的时候有没有遇到过,你写的某段代码,编译器要求你必须要对这段代码try...catch,或者throws exception,如果你遇见过,没错,这就是检查异常,也就是说,你代码还没运行呢,编译器就会检查你的代码,会不会出现异常,要求你对可能出现的异常必须做出相应的处理。

            javac强制要求程序员为这样的异常做预备处理工作(使用try...catch...finally或者throws)。在方法中要么用try-catch语句捕获它并处理,要么用throws子句声明抛出它,否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下,而程序员无法干预用户如何使用他编写的程序,于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

            比如:我们调用日期格式化类解析字符串的时候;

    How:怎样处理检查异常(checked exception)?

            1、继续抛出,消极的方法,一直可以抛到java虚拟机来处理,就是通过throws Exception抛出。

            2、用try...catch捕获

            注意,对于检查的异常必须处理,或者必须捕获或者必须抛出

    Where:检查异常有哪些呢?

            除了RuntimeException与其子类,以及错误(Error),其他的都是检查异常(绝对的大家族)。

    非检查异常

    What:什么是非检查异常(unchecked exceptions)?

            编译器不要求强制处置的异常,虽然你有可能出现错误,但是编译器不会在编译的时候检查,没必要,也不可能。

            javac在编译时,不会提示和发现这样的异常,不要求在程序处理这些异常。所以如果愿意,我们可以编写代码处理(使用try...catch...finally)这样的异常,也可以不处理。

            对于这些异常,我们应该修正代码,而不是去通过异常处理器处理。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException,错误的强制类型转换错误ClassCastException,数组索引越界ArrayIndexOutOfBoundsException,使用了空对象NullPointerException等等。

    How:对非检查的异常(unchecked exception )怎样处理?

            1、用try...catch捕获
            2、继续抛出
            3、不处理
            4、通过代码处理

            一般我们是通过代码处理的,因为你很难判断会出什么问题,而且有些异常你也无法运行时处理,比如空指针,需要人手动的去查找。

            而且,捕捉异常并处理的代价远远大于直接抛出。

    Why:为什么有非检查异常?

            你想想非检查异常都有哪些?NullPointerException,IndexOutOfBoundsException,VirtualMachineError等,这些异常你编译的时候检查吗?再说了,明明可以运行时检查,都在编译的时候检查,你写的代码还能看吗?而且有些异常只能在运行时才能检查出来,比如空指针,堆溢出等。

    Where:非检查异常有哪些?

            RuntimeException与其子类,以及错误(Error)。

    Exception异常划分

            Exception异常进行划分,它可分为运行时异常和编译期异常。

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

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

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

    二、初识异常与常见异常

    初识异常

            下面的代码会演示2个异常类型:ArithmeticException 和 InputMismatchException。

            前者由于整数除0引发,后者是输入的数据不能被转换为int类型引发。

    import java.util.Scanner;
    
    public class AllDemo {
        public static void main(String[] args) {
            System.out.println("----欢迎使用命令行除法计算器----");
            CMDCalculate();
        }
    
        public static void CMDCalculate() {
            Scanner scan = new Scanner(System.in);
            int num1 = scan.nextInt();
            int num2 = scan.nextInt();
            int result = devide(num1, num2);
            System.out.println("result:" + result);
            scan.close();
        }
    
        public static int devide(int num1, int num2) {
            return num1 / num2;
        }
    }
    
    /*****************************************
    ----欢迎使用命令行除法计算器----
    2
    0
    Exception in thread "main" java.lang.ArithmeticException: / by zero
    	at AllDemo.devide(AllDemo.java:19)
    	at AllDemo.CMDCalculate(AllDemo.java:13)
    	at AllDemo.main(AllDemo.java:6)
    
    ----欢迎使用命令行除法计算器----
    ----欢迎使用命令行除法计算器----
    1
    r
    Exception in thread "main" java.util.InputMismatchException
    	at java.util.Scanner.throwFor(Scanner.java:864)
    	at java.util.Scanner.next(Scanner.java:1485)
    	at java.util.Scanner.nextInt(Scanner.java:2117)
    	at java.util.Scanner.nextInt(Scanner.java:2076)
    	at AllDemo.CMDCalculate(AllDemo.java:12)
    	at AllDemo.main(AllDemo.java:6)
    *****************************************/

            异常是在执行某个函数时引发的,而函数又是层级调用,形成调用栈的,因为,只要一个函数发生了异常,那么他的所有的caller都会被异常影响。当这些被影响的函数以异常信息输出时,就形成的了异常追踪栈。

            异常最先发生的地方,叫做异常抛出点。

            从上面的例子可以看出,当devide函数发生除0异常时,devide函数将抛出ArithmeticException异常,因此调用它的CMDCalculate函数也无法正常完成,因此也发送异常,而CMDCalculate的caller——main 因为CMDCalculate抛出异常,也发生了异常,这样一直向调用栈的栈底回溯。这种行为叫做异常的冒泡,异常的冒泡是为了在当前发生异常的函数或者这个函数的caller中找到最近的异常处理程序。由于这个例子中没有使用任何异常处理机制,因此异常最终由main函数抛给JRE,导致程序终止。

            上面的代码不使用异常处理机制,也可以顺利编译,因为2个异常都是非检查异常。但是下面的例子就必须使用异常处理机制,因为异常是检查异常。

            代码中我选择使用throws声明异常,让函数的调用者去处理可能发生的异常。但是为什么只throws了IOException呢?因为FileNotFoundException是IOException的子类,在处理范围内。

    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class ExceptionTest {
        public void testException() throws IOException {
            //FileInputStream的构造函数会抛出FileNotFoundException
            FileInputStream fileIn = new FileInputStream("E:\\a.txt");
    
            int word;
            //read方法会抛出IOException
            while ((word = fileIn.read()) != -1) {
                System.out.print((char) word);
            }
            //close方法会抛出IOException
            fileIn.close();
        }
    }

    常见异常

            java.lang.RuntimeException: 运行时异常
                    ClassCastException: 类类型转换异常,当试图将对象强制转换为不是实例的子类时,抛出该异常;
                    ArrayIndexOutOfBoundsException: 数组下标越界异常,当你使用不合法的索引访问数组时会抛出该异常;
                    NullPointerException: 空指针异常,通过null进行方法和属性调用会抛出该异常;
                    ArithmeticException: 算术运算异常,除数为0,抛出该异常;
                    NumberFormatException: 数字转换异常,当试图将一个String转换为指定的数字类型,而该字符串确不满足数字类型要求的格式时,抛出该异常;
                    InputMismatchException: 输入不匹配异常,输入的值数据类型与设置的值数据类型不能匹配。
            ...

    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Date;
    import java.util.Scanner;
    
    public class ExceptionTest {
        //ClassCastException
        public void test1() {
            Object obj = new Date();
            String str = (String) obj;
        }
    
        //IndexOutOfBoundsException
        public void test2() {
            //ArrayIndexOutOfBoundsException
            int[] arr = new int[10];
            System.out.println(arr[10]);
    
            //StringIndexOutOfBoundsException
            String str = "abc";
            System.out.println(str.charAt(3));
        }
    
        //NullPointerException
        public void test3() {
            int[] arr = null;
            System.out.println(arr[3]);
    
            String str = "abc";
            str = null;
            System.out.println(str.charAt(0));
        }
    
        //ArithmeticException
        public void test4() {
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        }
    
        //NumberFormatException
        public void test5() {
            String str = "123";
            str = "abc";
            int num = Integer.parseInt(str);
        }
    
        //InputMismatchException
        public void test6() {
            Scanner scanner = new Scanner(System.in);
            int score = scanner.nextInt();
            System.out.println(score);
            scanner.close();
        }
    }

            java.io.IOExeption: 输入输出异常
                    FileNotFoundException: 文件找不到异常,通常是两种情况:1、系统找不到指定的路径 2、拒绝访问(指定的是目录时,就会报拒绝访问异常)
                    EOFException: 文件已结束异常,抛出EOFException一定是因为连接断了还在继续read;

            java.lang.ClassNotFoundException: 类找不到异常,当我们通过配置文件去查找一个类的时候,如果配置路径写错,就会抛出该异常,比如:web.xml文件中根本就不存在该类的配置或者配置的路径写错;(比较常见)
            
            java.sql.SQLException: SQL异常,数据库的各种信息的异常;

    import java.io.File;
    import java.io.FileInputStream;
    
    public class ExceptionTest {
        
        public void test7() {
            File file = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file);
    
            int data = fis.read();
            while (data != -1) {
                System.out.print((char) data);
                data = fis.read();
            }
    
            fis.close();
        }
    
    }

    三、异常处理的处理机制

            在编写程序时,经常要在可能出现错误的地方加上检测的代码,如进行x/y运算时,要检测分母为0,数据为空,输入的不是数据而是字符等。过多的if-else分支会导致程序的代码加长、臃肿,可读性差。因此采用异常处理机制。    

            在编写代码处理异常时,对于检查异常/非检查异常,都有2种不同的处理方式:
                    1、使用try...catch...finally语句块处理它。
                    2、在函数签名中使用throws 声明交给函数调用者caller去解决。
        
            比如现有一辆车,这个车你可以是方法,这辆车在可能存在各种风险,那么对于这些风险的处理方式,就相当于异常的处理方式:
            1、使用try...catch...finally语句块处理它。
                    我们把这辆车可能出现的问题都考虑清楚了,并提供了备选方案(出现问题怎么做),如果没有出现问题,那么用不到备选方案;
                    如果出现了问题,根据问题去找对应的备选方案,以保证车的正常运行;
                    如果出现了问题,但是又没备选方案,那么车就跑不了;
            2、在函数签名中使用throws 声明交给函数调用者caller去解决。
                    我知道车可能又问题,但是我不处理,谁来使用了,告诉调用者,这里可能有问题;
                    那么调用者可以处理这个问题,也可以不处理;如果它不处理,还是会出现问题,如果处理了,肯定没问题;
                    A -》 B -》 C

            Java采用的异常处理机制,是将异常处理的程序代码集中在一起,与正常的程序代码分开,使得程序简洁、优雅,并易于维护。

            Java提供的是异常处理的抓抛模型。
        
            Java程序的执行过程中如出现异常,会生成一个异常类对象,该异常对象将被提交给Java运行时系统,这个过程称为抛出(throw)异常。

            异常对象的生成:
                    由虚拟机自动生成:程序运行过程中,虚拟机检测到程序发生了问题,如果在当前代码中没有找到相应的处理程序,就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。
                    由开发人员手动创建:Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响,和创建一个普通对象一样。

            异常的抛出机制:
                    如果一个方法内抛出异常,该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理,它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去,直到异常被处理。这一过程称为捕获(catch)异常。
                    如果一个异常回到main()方法,并且main()也不处理,则程序运行终止。
                    程序员通常只能处理Exception,而对Error无能为力。

    异常处理机制一:try-catch-finally

    	语法格式:
            try{
                ...... //可能产生异常的代码
            }
            catch( ExceptionName1 e ){
                ...... //当产生ExceptionName1型异常时的处置措施
            }
            catch( ExceptionName2 e ){
                ...... //当产生ExceptionName2型异常时的处置措施
            }
            [ finally{
                ...... //无论是否发生异常,都无条件执行的语句
            } ]
    
    	语法解释:
    		try:
    			捕获异常的第一步是用try{…}语句块选定捕获异常的范围,将可能出现异常的代码放在try语句块中。
    			如果发生异常,则尝试去匹配catch块,catch块可以有多个(因为try块可以出现多个不同类型异常);
    			如果执行完try不管有没有发生异常,则接着去执行finally块和finally后面的代码(如果有的话)。			
    		catch (Exceptiontype e):
    			在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句,用于处理可能产生的不同类型的异常对象。
    			每一个catch块用于捕获并处理一个特定的异常,或者这异常类型的子类。Java可以将多个异常声明在一个catch中。 catch(Exception1 | Exception2 | Exception3 e)
    			catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的,则虚拟机将使用这个catch块来处理异常。
    			在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量,其它块不能访问。与其它对象一样,可以访问一个异常对象的成员变量或调用它的方法。
    				①、getMessage() 获取异常信息,返回字符串。
    				②、printStackTrace() 获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。
    			如果当前try块中发生的异常在后续的所有catch中都没捕获到,则先去执行finally,然后到这个函数的外部caller中去匹配异常处理器。
    			如果try中没有发生异常,则所有的catch块将被忽略。
    			注意:如果明确知道产生的是何种异常,可以用该异常类作为catch的参数;也可以用其父类作为catch的参数。比如:可以用 ArithmeticException 类作为参数的地方,就可以用RuntimeException类作为参数,或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常,如NullPointerException(catch中的语句将不会执行)。
    
    		finally:
    			finally块通常是可选的。捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口,使得在控制流转到程序的其它部分以前,能够对程序的状态作统一的管理。
    			不论在try代码块中是否发生了异常事件,catch语句是否执行,catch语句是否有异常,catch语句中是否有return,finally块中的语句都会被执行。
    			一个try至少要有一个catch块,否则, 至少要有1个finally块。但是finally不是用来处理异常的,finally不会捕获异常。
    			finally主要做一些清理工作,如流的关闭,数据库连接的关闭等。 
    public class Test_Input_01 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            /*
    		 * 当我们只写一个try{}的时候,会报错:
    		 * 	Syntax error, insert "Finally" to complete TryStatement
    		 * 	语法错误,插入“Finally”来完成Try块
    		 * 
    		 * 总结: try不能单独存在,必须结合catch或finally来使用
    		 * 	try块中没有异常,会执行finally(如果有)
    		 *  try块中有异常,会执行对应的catch块(如果有),try中异常发生点之后的代码将不会执行
    		 */
            try{
                //try块中放可能发生异常的代码。
                //如果执行完try且不发生异常,则接着去执行finally块和finally后面的代码(如果有的话)。
                //如果发生异常,则尝试去匹配catch块。异常点之后的代码不会运行
    
                //这行代码有可能出错
                int num1 = sc.nextInt(); //这行代码如果出现异常,那么后面的输出语句就不执行
    
                int num2 = sc.nextInt();
    
                System.out.println(num1+"\t"+num2);
    
                System.out.println(num1/num2);
    
    
                String str = null;
                System.out.println(str.charAt(0));
    
            }catch(InputMismatchException | NullPointerException e) { 
                // catch(异常对象)	当异常发生了,catch就会捕获对应的异常
                // 每一个catch块用于捕获并处理一个特定的异常,或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。 catch(Exception1 | Exception2 | Exception3 e)
                // catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的,则虚拟机将使用这个catch块来处理异常。
                // 在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量,其它块不能访问。
                // 如果当前try块中发生的异常在后续的所有catch中都没捕获到,则先去执行finally,然后到这个函数的外部caller中去匹配异常处理器。
                // 如果try中没有发生异常,则所有的catch块将被忽略。
                System.out.println("catch块 - try里面发生了异常 - 空指针和输入不匹配异常都走这个Catch");
            }catch(java.lang.ArithmeticException e){
                e.getMessage();
                System.out.println("算数异常:除数不能为0");
    
            }catch(Exception e){
                System.out.println("程序发生未知异常");
            }finally {
                // finally块通常是可选的。
                // 无论异常是否发生,异常是否匹配被处理,finally都会执行。
                // 一个try至少要有一个catch块,否则, 至少要有1个finally块。但是finally不是用来处理异常的,finally不会捕获异常。
                // finally主要做一些清理工作,如流的关闭,数据库连接的关闭等。 
                System.out.println("finally块");
            }
    
            System.out.println("异常捕获之后的代码");
        }
    }	

    需要注意的地方

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

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

            3、java中,异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说:当一个函数的某条语句发生异常时,这条语句的后面的语句不会再执行,它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行,异常被处理完后,执行流会接着在“处理了这个异常的catch代码块”后面接着执行。

            有的编程语言当异常被处理后,控制流会恢复到异常抛出点接着执行,这种策略叫做:resumption model of exception handling(恢复式异常处理模式)

            而Java则是让执行流恢复到处理了异常的catch块后接着执行,这种策略叫做:termination model of exception handling(终结式异常处理模式)

    public static void main(String[] args){
        try {
            foo();
        }catch(ArithmeticException ae) {
            System.out.println("处理异常");
        }
    }
    public static void foo(){
        int a = 5/0;  //异常抛出点
        System.out.println("Look me!!!");  //不会执行
    }

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

            良好的编程习惯是:在try块中打开资源,在finally块中清理释放这些资源。

            需要注意的地方:

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

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

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

            这是正常的情况,但是也有特例。关于finally有很多恶心,偏、怪、难的问题.

            具体在最后一节:finally块和return 讲解

    不捕获异常时的情况:

            前面使用的异常都是RuntimeException类或是它的子类,这些类的异常的特点是:即使没有使用try和catch捕获,Java自己也能捕获,并且编译通过( 但运行时会发生异常使得程序运行终止 )。

            如果抛出的异常是IOException等类型的非运行时异常,则必须捕获,否则编译错误。也就是说,我们必须处理编译时异常,将异常进行捕捉,转化为运行时异常。

    import java.io.*;
    
    public class IOExp {
        public static void main(String[] args) {
            try {
                FileInputStream in = new FileInputStream("hello.txt");
                int b;
                b = in.read();
                while (b != -1) {
                    System.out.print((char) b);
                    b = in.read();
                }
                in.close();
            } catch (IOException e) {
                System.out.println(e);
            } finally {
                System.out.println(" It’s ok!");
            }
        }
    }

    异常处理机制二:throws

            throws是另一种处理异常的方式,它不同于try...catch...finally,throws仅仅是将函数中可能出现的异常向调用者声明,而自己则不具体处理。

            throws声明:如果一个方法内部的代码会抛出检查异常(checked exception),而方法自己又没有完全处理掉或并不能确定如何处理这种异常,则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常,表明该方法将不对这些异常进行处理,而由该方法的调用者负责处理,否则编译不通过。

            在方法声明中用throws语句可以声明抛出异常的列表,throws后面的异常类型可以是方法中产生的异常类型,也可以是它的父类。

            采取这种异常处理的原因可能是:方法本身不知道如何处理这样的异常,或者说让调用者处理更好,调用者需要为可能发生的异常负责。

            语法格式:
            修饰符 返回值类型 方法名() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN{ 
                //方法内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常,或者他们的子类的异常对象。
            }

    import java.io.*;
    
    public class ThrowsTest {
        public static void main(String[] args) {
            ThrowsTest t = new ThrowsTest();
            try {
                t.readFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public void readFile() throws IOException {
            FileInputStream in = new FileInputStream("hello.txt");
            int b;
            b = in.read();
            while (b != -1) {
                System.out.print((char) b);
                b = in.read();
            }
            in.close();
        }
    }

    四、手动抛出异常:throw

            Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出,也可根据需要使用人工创建并抛出。

            首先要生成异常类对象,然后通过throw语句实现抛出操作(提交给Java运行环境)。
                    throw exceptionObject

            程序员也可以通过throw语句手动显式的抛出一个异常。throw语句的后面可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误:
                    throw new String("你抛我试试.");

            throw 语句必须写在函数中,执行throw 语句的地方就是一个异常抛出点,它和由JRE自动形成的异常抛出点没有任何差别。

    public class StudentTest {
        public static void main(String[] args) {
            try {
                Student s = new Student();
                s.regist(-1001);
                System.out.println(s);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
    
    class Student {
        private int id;
    
        public void regist(int id) throws Exception {
            if (id > 0) {
                this.id = id;
            } else {
                // System.out.println("您输入的数据非法!");
    
                //手动抛出异常对象
                // throw new RuntimeException("您输入的数据非法!");
                throw new Exception("您输入的数据非法!");
    
                //错误的
                // throw new String("不能输入负数");
            }
    
        }
    
        @Override
        public String toString() {
            return "Student [id=" + id + "]";
        }
    }

    throws和throw的区别:

            throw是语句抛出一个异常。
                    语法:throw (异常对象);
                        throw e;

            throws是方法可能抛出异常的声明。(用在声明方法时,表示该方法可能要抛出异常)
                    语法:[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
                        public void doA(int a) throws Exception1,Exception3{......}

            throw语句用在方法体内,表示抛出异常,由方法体内的语句处理。
            throws出现在方法函数头,表示在抛出异常,由该方法的调用者来处理。

            throws主要是声明这个方法会抛出这种类型的异常,使它的调用者知道要捕获这个异常。
            throw是具体向外抛异常的动作,所以它是抛出一个异常实例。

            throws说明你有那个可能,倾向。
            throw的话,那就是你把那个倾向变成真实的了。

            两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用处理。

    五、异常的链化

            在一些大型的,模块化的软件开发中,一旦一个地方发生异常,则如骨牌效应一样,将导致一连串的异常。假设B模块完成自己的逻辑需要调用A模块的方法,如果A模块发生异常,则B也将不能完成而发生异常,但是B在抛出异常时,会将A的异常信息掩盖掉,这将使得异常的根源信息丢失。异常的链化可以将多个模块的异常串联起来,使得异常信息不会丢失。

            异常链化:以一个异常对象为参数构造新的异常对象。新的异对象将包含先前异常的信息。这项技术主要是异常类的一个带Throwable参数的函数来实现的。这个当做参数的异常,我们叫它根源异常(cause)。

            查看Throwable类源码,可以发现里面有一个Throwable字段cause,就是它保存了构造时传递的根源异常参数。这种设计和链表的结点类设计如出一辙,因此形成链也是自然的了。

    public class Throwable implements Serializable {
        private Throwable cause = this;
    
        public Throwable(String message, Throwable cause) {
            fillInStackTrace();
            detailMessage = message;
            this.cause = cause;
        }
    
        public Throwable(Throwable cause) {
            fillInStackTrace();
            detailMessage = (cause == null ? null : cause.toString());
            this.cause = cause;
        }
    
        //........
    }

            下面是一个例子,演示了异常的链化:从命令行输入2个int,将他们相加,输出。输入的数不是int,则导致getInputNumbers异常,从而导致add函数异常,则可以在add函数中抛出一个链化的异常。

    public static void main(String[] args){
        System.out.println("请输入2个加数");
        int result;
        try{
            result = add();
            System.out.println("结果:"+result);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    //获取输入的2个整数返回
    private static List<Integer> getInputNumbers(){
        List<Integer> nums = new ArrayList<>();
        Scanner scan = new Scanner(System.in);
        try {
            int num1 = scan.nextInt();
            int num2 = scan.nextInt();
            nums.add(new Integer(num1));
            nums.add(new Integer(num2));
        }catch(InputMismatchException immExp){
            throw immExp;
        }finally {
            scan.close();
        }
        return nums;
    }
    
    //执行加法计算
    private static int add() throws Exception{
        int result;
        try {
            List<Integer> nums =getInputNumbers();
            result = nums.get(0)  + nums.get(1);
        }catch(InputMismatchException immExp){
            throw new Exception("计算失败",immExp);  /链化:以一个异常对象为参数构造新的异常对象。
        }
        return  result;
    }
    
    /*
    请输入2个加数
    r 1
    java.lang.Exception: 计算失败
        at practise.ExceptionTest.add(ExceptionTest.java:53)
        at practise.ExceptionTest.main(ExceptionTest.java:18)
    Caused by: java.util.InputMismatchException
        at java.util.Scanner.throwFor(Scanner.java:864)
        at java.util.Scanner.next(Scanner.java:1485)
        at java.util.Scanner.nextInt(Scanner.java:2117)
        at java.util.Scanner.nextInt(Scanner.java:2076)
        at practise.ExceptionTest.getInputNumbers(ExceptionTest.java:30)
        at practise.ExceptionTest.add(ExceptionTest.java:48)
        ... 1 more
    
    */

    六、自定义异常

    自定义异常规则

            如果要自定义异常类,则扩展Exception类即可,因此这样的自定义异常都属于检查异常(checked exception)。如果要自定义非检查异常,则扩展自RuntimeException。

            按照国际惯例,自定义的异常应该总是包含如下的构造函数:
                    一个无参构造函数
                    一个带有String参数的构造函数,并传递给父类的构造函数。
                    一个带有String参数和Throwable参数,并都传递给父类构造函数。
                    一个带有Throwable 参数的构造函数,并传递给父类的构造函数。

    下面是IOException类的完整源代码,可以借鉴。

    public class IOException extends Exception {
        static final long serialVersionUID = 7818375828146090155L;
    
        public IOException() {
            super();
        }
    
        public IOException(String message) {
            super(message);
        }
    
        public IOException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public IOException(Throwable cause) {
            super(cause);
        }
    }

    自定义异常构建

    首先写一个自定义异常,继承Exception,代码如下:

    public class MyException extends Exception {
    
        public MyException() {
            super();
        }
    
        public MyException(String message) {
            super(message);
        }
    
        public MyException(String message, Throwable cause) {
            super(message, cause);
        }
    
    
        public MyException(Throwable cause) {
            super(cause);
        }
    }

    使用自定义异常

            如果自定义异常是为了提示,在使用的时候,一定要用try..catch,不要直接用throw往外抛。

    public class Test {
        public static void main(String[] args) {
            A a = new A();
            try {
                a.show(-2);
            } catch (MyException e) {
                System.out.println(e.getMessage());
            }
        }
    }
    
    class A {
        public void show(int num) throws MyException {
            if (num < 0) {
                MyException me = new MyException("异常:" + num + "不是正数");
                throw me;//抛出异常,结束方法show()的执行
            }
            System.out.println(num);
        }
    }

    七、异常的注意事项

            1、当子类重写父类的带有 throws声明的函数时,其throws声明的异常必须在父类异常的可控范围内——用于处理父类的throws方法的异常处理器,必须也适用于子类的这个带throws方法 。这是为了支持多态。

            例如,父类方法throws 的是2个异常,子类就不能throws 3个及以上的异常。父类throws IOException,子类就必须throws IOException或者IOException的子类。

            至于为什么?我想,也许下面的例子可以说明。

    class Father {
        public void start() throws IOException {
            throw new IOException();
        }
    }
    
    class Son extends Father {
        public void start() throws Exception {
            throw new SQLException();
        }
    }
    
    /**********************假设上面的代码是允许的(实质是错误的)***********************/
    class Test {
        public static void main(String[] args) {
            Father[] objs = new Father[2];
            objs[0] = new Father();
            objs[1] = new Son();
    
            for (Father obj : objs) {
                // 因为Son类抛出的实质是SQLException,而IOException无法处理它。
                // 那么这里的try。。catch就不能处理Son中的异常。
                // 多态就不能实现了。
                try {
                    obj.start();
                } catch (IOException ioException) {
                    // 处理IOException
                }
            }
        }
    }

            2、Java程序可以是多线程的。每一个线程都是一个独立的执行流,独立的函数调用栈。如果程序只有一个线程,那么没有被任何代码处理的异常会导致程序终止。如果是多线程的,那么没有被任何代码处理的异常仅仅会导致异常所在的线程结束。

            也就是说,Java中的异常是线程独立的,线程的问题应该由线程自己来解决,而不要委托到外部,也不会直接影响到其它线程的执行。

    八、finally块和return

    1、一个不容易理解的事实:在 try块中即便有return,break,continue等改变执行流的语句,finally也会执行。

    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
    */

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

    public static void main(String[] args){
        int result;
    
        result  =  foo();
        System.out.println(result);     /2
    
        result = bar();
        System.out.println(result);    /2
    }
    
    @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;
        }
    }

    3、finally中的return会抑制(消灭)前面try或者catch块中的异常

    class TestException {
        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中的异常被抑制
        //J2SE 提供的最后一个批注是 @SuppressWarnings。该批注的作用是给编译器一条指令,告诉它对被批注的代码元素内部的某些警告保持静默。
        @SuppressWarnings("finally")
        public static int bar() throws Exception {
            try {
                int a = 5 / 0;
                return 1;
            } finally {
                return 100;
            }
        }
    }

    4、finally中的异常会覆盖(消灭)前面try或者catch中的异常

    public class TestException {
        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("我是finally中的Exception");
            }
        }
    
        //try中的异常被抑制
        @SuppressWarnings("finally")
        public static int bar() throws Exception {
            try {
                int a = 5 / 0;
                return 1;
            } finally {
                throw new Exception("我是finally中的Exception");
            }
    
        }
    }

    上面的3个例子都异于常人的编码思维,因此我建议:

            不要在fianlly中使用return。

            不要在finally中抛出异常。

            减轻finally的任务,不要在finally中做一些其它的事情,finally块仅仅用来释放资源是最合适的。

            将尽量将所有的return写在函数的最后面,而不是try ... catch ... finally中。

    展开全文
  • java异常处理

    万次阅读 2018-02-14 17:54:11
    java异常处理 java异常体系 Java的所有异常继承自Throwable,分为error(错误)和Exception(异常),Exception又分为可查异常和不可查异常,可查异常指的是编译器可以检查处理来,在编写代码的时候需要进行处理...

    java异常处理

    java异常体系

    异常体系

    Java的所有异常继承自Throwable,分为error(错误)和Exception(异常),Exception又分为可查异常不可查异常,可查异常指的是编译器可以检查处理来,在编写代码的时候需要进行处理,不可查异常指的是运行时异常例如NullException(空指针异常)在编写代码的时候可以不处理;error一般是jvm(虚拟机)错误不能处理,异常指的是一般可以被程序处理。

    try catch finally

    分析一下代码,说明输出:

    示例一

    package xuelongjiang.baseGrama.exceptiondeal;
    
    /**
     * @Author xuelongjiang
     */
    public class SimpleException {
    
    
        public static void main(String[] args) {
    
            SimpleException simpleException = new SimpleException();
    
            System.out.println(simpleException.exceptionTest(0));
        }
    
        public int  exceptionTest(int a2) {
    
            System.out.println("a2除数:"+a2);
             int a1  = 0;
    
             try {
             a1 = 10/a2;
             System.out.println("处理正常。。。。。");
             return a1;
    
             }catch (Exception e){
                 System.out.println("异常被抓住了。。。。。");
                 return 0;
             }finally {
                 System.out.println("进入finaly。。。。。");
                 System.out.println("a1:"+a1);
                 return 100;
             }
        }
    
    }
    

    输出结果:

    a2除数:0

    异常被抓住了。。。。。

    进入finaly。。。。。

    a1:0

    100

    示例二

    package xuelongjiang.baseGrama.exceptiondeal;
    
    /**
     * @Author xuelongjiang
     */
    public class SimpleException {
    
    
        public static void main(String[] args) {
    
            SimpleException simpleException = new SimpleException();
            try {
                System.out.println(simpleException.exceptionTest(0));
    
            }catch (Exception e){
                System.out.println("最外层的catch。。。。");
            }
    
    
        }
    
        public int  exceptionTest(int a2) throws  Exception {
    
            System.out.println("a2除数:"+a2);
             int a1  = 0;
    
             try {
             a1 = 10/a2;
             System.out.println("处理正常。。。。。");
             return a1;
    
             }catch (Exception e){
                 System.out.println("异常被抓住了。。。。。");
                 throw  e;
                 //return 0;
             }finally {
                 System.out.println("进入finaly。。。。。");
                 System.out.println("a1:"+a1);
                 return 100;
             }
        }
    
    }
    
    

    输出:

    a2除数:0

    异常被抓住了。。。。。

    进入finaly。。。。。

    a1:0
    100

    示例三

    package xuelongjiang.baseGrama.exceptiondeal;
    
    /**
     * @Author xuelongjiang
     */
    public class SimpleException {
    
    
        public static void main(String[] args) {
    
            SimpleException simpleException = new SimpleException();
            try {
                System.out.println(simpleException.exceptionTest(0));
    
            }catch (Exception e){
                System.out.println("最外层的catch。。。。");
            }
    
    
        }
    
        public int  exceptionTest(int a2) throws  Exception {
    
            System.out.println("a2除数:"+a2);
             int a1  = 0;
    
             try {
             a1 = 10/a2;
             System.out.println("处理正常。。。。。");
             return a1;
    
             }catch (Exception e){
                 System.out.println("异常被抓住了。。。。。");
                 throw  e;
                 //return 0;
             }finally {
                 System.out.println("进入finaly。。。。。");
                 System.out.println("a1:"+a1);
                 //return 100;
             }
        }
    
    }
    

    输出:

    a2除数:0

    异常被抓住了。。。。。

    进入finaly。。。。。

    a1:0

    最外层的catch。。。。

    根据以上代码给出结论:

    如果有finally即使try 和catch中有return也不会返回,而是返回finally中的return
    如果finally中没有return语句,并且try和catch中有返回语句或throw那么会执行try,catch中的返回

    throw throws

    在上面的示例中,我们看到了throws和throw的用法,有时方法没有能力处理异常,需要向上抛出异常,由其他方法来处理异常。

    throw 检查异常处理的时候,如果使用throw 那么必须使用throws .
    throw 用于方法中, thows用于方法的签名。

    总结

    如果异常处理太多会影响正常代码的阅读,一般建议专门有个异常处理的方法,来处理异常。而产生异常的方法只需要抛出代码,这样能极大的方便阅读代码,及整洁代码。

    展开全文
  • JAVA 异常处理小技巧

    千次阅读 2021-03-01 06:33:12
    1、异常:就是程序运行时出现不正常情况异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。对于问题的划分(两种):一...

    1、异常:就是程序运行时出现不正常情况

    异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

    对于问题的划分(两种):一种是严重的问题,一种是非严重的问题;

    对于严重的,java通过Error类进行描述。

    对于Error一般不编写针对性的代码对其进行编写

    对于非严重的,java通过Exception类进行描述。

    对于Exception可以使用针对性的处理方式进行处理

    无论Error还是Exception都具有一些共性内容

    Throwableb6dc2a9476e2ab86b30c810fac876958.png

    2、异常的处理

    java 提供了特有语句进行处理。1bcdeafd31ca01a54d419d1985fe62bc.png

    3、对捕获到的异常对象常见方法操作

    String getMessage( ):捕获异常信息。

    在函数上声明,让调用出进行处理,不处理则编译失败。

    对多异常的处理

    1、声明异常时,建议声明更为具体,这样处理的可以更具体。

    2、对方声明几个异常,就对应有几个catch块,不要定义多余的catch块。

    如果多个catch块中的异常出现继承关系,父类异常catc块放在最下面。

    建议:

    在进行catch处理时,catch中一定要定义具体处理方式,也不要简单的就写一条输出语句。

    当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作:

    要么在内部try catch处理,要么在函数上声明让调用者处理。

    一般情况在函数内部出现异常,函数上需要声明。

    发现打印的结果中只有异常的名称,却没有异常的信息,那么如何定义异常信息呢?

    因为父类中已经把异常信息的操作都完成了,所以子类只要在构造时,将异常信息传递给父类通过super语句,那么

    就可以直接通过getMessage方法获取自定义的异常信息。

    自定义异常:

    定义类继承Exception或者RuntimeException

    1、为了让该类自定义类具备可抛性。

    2、让该类具备操作异常的共性方法。978043ab5c55a3c2ef7479e735e26a3a.png

    throw和throws的区别:throw使用在函数上,throws使用在函数内。throws后面跟的异常类,可以跟多个,用“ ,”隔开

    throw后跟的是异常对象。

    当函数内容有throw抛出异常对象,并未进行try处理,必须要在函数上声明,都在编译失败。

    注意:RuntimeException除外,也就是说,函数内如果抛出的RuntimeException异常,函数可以不用声明。

    如果函数声明了异常,调用者需要进行处理,处理方法可以throws,可以try。

    finaly{ } //存放的是一定对被执行的代码 通常用于关闭资源。

    finally中定义的通常是 关闭资源代码。因为资源必须释放。

    finally只有一种情况不会执行,当执行到System.exit(0);finally不会执行。

    异常处理语句:c2719667e4e9fcf0b42055ee75fa97ce.png

    72b3fb92ce8291bec4b79461a1c66761.png

    002ccdbb6d099ba2b50befb335831ad2.png

    异常的好处:1、将问题进行封装

    2、将正常流程代码和问题处理代码相分离,方便于阅读。

    异常的处理原则:

    1、处理方式有两种:try 或者throws;

    2、调用到抛出异常的功能时,抛出几个,就处理几个。

    一个try对应多个catch。

    3、多个catch,父类的catch放到最下面。

    4、catch内,需要定义针对性的处理方式,不要简单的定义printStackTrace,输出语句。43f22cc0a369353794e6885981694a9d.png

    异常的注意事项:

    在子父类覆盖时:

    1、子类抛出的异常必须是父类的异常的子类或者子集;

    2、如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。

    帮到你的话,点个赞吧d=====( ̄▽ ̄*)b原作者姓名:胡小冰

    原出处:CSDN

    展开全文
  • Java异常处理的两种方式

    千次阅读 2021-11-15 12:43:43
    异常处理方式一:在当前方法中直接用try…catch处理 异常处理方式二:在当前方法中不处理,throws 异常抛给调用者处理 一. try-catch的方式就是捕获异常。 try:该代码块中编写可能产生异常的代码。 ...
  • Java异常处理(Java必备知识)

    千次阅读 2021-02-01 01:27:09
    Java提供了异常处理机制来帮助程序员检查可能出现的错误,提高了程序的可读性和可维护性。Java中将异常封装到一个类中,出现错误就会抛出异常。 目录 异常概述 捕捉处理异常 在方法中抛出异常 ......
  • JAVA异常处理

    千次阅读 2021-03-03 13:27:11
    出bug是写代码的时候非常常见的情况,今天就来讲一下。首先明确一下什么是异常,代码正常运行不会出问题,但是遇到意外...//java.lang.ArithmeticException:/ by zero除以零结果无穷大异常2.String str = null;Syst...
  • 第1关:学习-Java异常处理之try-catch之异常捕获 任务描述 相关知识 什么是异常 非运行时异常 运行时异常 错误 捕获异常 异常的使用原则 编程要求 测试说明 任务描述 本关任务:求给定两个数的商...
  • Java异常处理机制

    千次阅读 2019-04-24 20:19:37
    作者:小符 撰写时间:2018.4.24 学会了异常处理可以帮助...Java异常处理机制为:抛出异常,捕捉异常,处理异常。 语法格式: try…catch 在使用try…catch捕获处理异常时需要注意: **·**不要过度使用异常,不能使...
  • java异常处理机制原理和应用

    千次阅读 多人点赞 2021-11-20 13:50:48
    一、Java异常简介 大家对trycatch可能并不陌生,也都使用的非常熟练了。 当程序运行过程中发生错误时,就会抛出异常,抛出异常总比终止程序来的好的多。 也可以在已知某个错误要发生时,进行trycatch操作,异常时...
  • JAVA异常处理实战心得

    千次阅读 2018-09-28 16:42:12
    尤其是在各种服务相关的代码中,可能正常业务逻辑的代码量很少,大部分都是各种try catch处理各种异常的代码,因为实际中异常情况很多,为了保证服务的健壮与稳定性,要尽可能考虑与处理掉各种异常情况。所以在java...
  • 第1关:练习-Java异常处理之try-catch之异常捕获 任务描述 编程要求 测试说明 任务描述 本关任务:根据逗号(英文逗号)切割给定的一行字符串,得到一个字符串数组,输出数组中第五个元素,并捕获数组越界异常。...
  • Java异常处理简单实例

    千次阅读 2019-05-12 16:56:35
    Java异常处理 异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。 比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println...
  • Java异常处理

    千次阅读 2021-09-14 16:51:48
    处理异常的两种方式: 1.抛出去(交给JVM处理 格式:在方法的声明后面加关键字 方法声明(形参)throws 异常类名{ } 注意: a.可以同时抛多个异常,中间用逗号分割 b.抛出了父类型的异常,子类型的异常就可以...
  • 第1关:学习-Java异常处理之try-catch之异常捕获 任务描述 本关任务:求给定两个数的商,并捕获除数为 0 的异常。 相关知识 为了完成本关任务,你需要掌握: 1.什么是异常; 2.如何捕获异常; 3.异常的使用原则。 ...
  • java异常处理(较详细)

    万次阅读 多人点赞 2020-02-21 17:30:34
    java异常处理(较详细) 在使用计算机语言进行项目开发的过程中,即使程序员把代码写得尽善尽美,在系统的运行过程中仍然会遇到一些问题,因为很多问题不是靠代码能够避免的。 比如: 客户输入数据的格式, 读取文件...
  • Java 异常处理

    千次阅读 2017-10-07 11:18:08
    Java异常的处理机制 抛出异常 捕获异常 异常处理的基本语法 try-catch throw throws finally 问题扩展面试题 异常链 自定义异常 总结异常的概念异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候...
  • Java-异常处理大全(万字宝典)

    千次阅读 多人点赞 2022-01-10 21:44:51
    什么是异常异常产生了之后如何处理?如何自定义异常?抓紧收藏,这篇文章看了你还不懂来打我!!
  • 如果在继承中,子类如何处理异常?这两个问题,我们这篇来总结下,然后来几个异常的练习题。1.异常注意事项- 子类重写父类方法时,子类的方法必须抛出相同的异常或者父类异常的子类。(父亲坏了,儿子不能更坏)- ...
  • Java异常处理(代码演示)

    千次阅读 2019-04-22 22:28:09
    * 异常处理 * * 1.Throwable是异常的基类,分为Error和Exception,在编程中我们关注Exception * 2.Exception分为编译期异常(受检)和运行期异常(非受检) 3.异常会导致程序中断,无法继续执行 * 4...
  • Java异常处理个人心得总结

    千次阅读 2018-10-09 20:42:35
    1、异常处理的流程总是首先抛出异常,然后才进行处理 public class TestException { public static void main(String[] args) { int a = 6; int b = 0; try { // try监控区域 if (b == 0) throw new...
  • java异常处理常用关键字

    千次阅读 2019-08-06 20:04:39
    异常处理两种方式: 1、捕获异常:try catch 直接处理可能出现的异常! 2、声明异常:throws 声明告诉调用者可能的异常,暴露问题,调用者自己处理! 异常处理的5 个关键字: try, catch, finally throw, throws...
  • Java异常处理之释放资源

    千次阅读 2020-02-10 15:25:52
    有时在try-catch语句中会占用一些非Java资源,如:打开文件、网络连接、打开数据库连接和使用数据 结果集等,这些资源并非Java资源,不能通过JVM的垃圾收集器回收,需要程序员释放。为了确保这 些资源能够被释放可以...
  • java异常 — — 异常的处理

    千次阅读 2021-08-31 12:21:02
    Java异常处理的五个关键字: try、catch、finally、throw、throws 2.1、抛出异常throw 在编写程序时,我们必须要考虑程序出现问题的情况。比如,在定义方法时,方法需要接受参数。那么,当调用方法使用接受到的参数时...
  • Java——你真的了解Java异常处理机制吗?

    万次阅读 多人点赞 2022-01-02 08:33:10
    你真的了解java异常处理吗?
  • Java异常处理最佳实践

    千次阅读 2019-06-30 18:38:55
    这也是绝大多数开发团队都会制定一些规则来规范进行异常处理的原因。而团队之间的这些规范往往是截然不同的。 本文给出几个被很多团队使用的异常处理最佳实践。 在 finally 块中清理资源或者使用 try-with-resource...
  • Java异常处理-原则

    千次阅读 2016-04-12 17:26:56
    异常处理重要原则:只有在你知道如何处理的情况才捕获异常,否则就往上抛出异常3.异常处理目标:把错误处理代码同错误发生的地点分离4.只能忽略RuntimeException(及其子类)类型异常,其他类型异常的处理都是有...
  • JAVA异常处理(随笔)

    千次阅读 2021-03-22 17:03:07
    异常处理异常从方法中抛出。方法调用者可以捕获以及处理该异常。(不应该让方法终止程序,应有调用者决定是否终止程序)throw语句的执行称为“抛出一个异常(throw an exception)”,异常就是一个从异常类创建的对象;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 961,308
精华内容 384,523
关键字:

java异常处理