异常_矿异常 - CSDN
异常 订阅
异常是一个汉语词语,读音为yì cháng,指非正常的;不同于平常的;非常。出自《后汉书·皇后纪上·光烈阴皇后》。 展开全文
异常是一个汉语词语,读音为yì cháng,指非正常的;不同于平常的;非常。出自《后汉书·皇后纪上·光烈阴皇后》。
信息
近义词
反常
中文名
异常
反义词
寻常
外文名
unusual
注    音
ㄧˋ ㄔㄤˊ
拼    音
yì cháng
异常词语辨析
反义词:正常
收起全文
  • 1、什么是异常?  程序开发和运行过程中会出现编译错误和运行错误。编译错误容易被发现并排除,而运行错误(逻辑错误和异常)很难预料。因此为了程序的稳定性和可靠性,就需要对程序异常处理和保护。 异常( ...

    1、什么是异常?

           程序开发和运行过程中会出现编译错误运行错误。编译错误容易被发现并排除,而运行错误(逻辑错误异常)很难预料。因此为了程序的稳定性和可靠性,就需要对程序异常处理和保护。
    异常( Exception ):正常程序流程所不能处理或者没有处理的异常情况或异常事件
    2、为什么要使用异常?
           传统的程序设计中会像下面的伪代码形式来处理错误:
          
                   执行一个任务

              if   前一个任务未能正确执行

                   执行错误处理

                  执行下一个任务

             if   前一个任务未能正确执行

                 执行错误处理

    而这样只会让程序更加复杂!
    3、异常的分类
              <1>根据异常在编译时是否被检测来分,异常可以分为两类:受检异常(CheckedException)非受检异常(UncheckedException)
              <2>非受检异常不能在编译时检测到非受检异常包括运行时异常(RuntimeException)和错误(Error)
     错误指的是致命性错误,常常无法处理。
              <3>根据异常的严重性,可以分为可以处理的异常错误异常
               异常以类的形式封装。程序可以处理的异常对应的类是java.lang.Exception及其子类。
               运行时异常对应的类是java.lang.RuntimeException
               错误异常对应的类是java.lang.Error
    4、异常相关类的继承图
    5、异常的产生
          <1>可以由Java虚拟机在执行程序时自动发现并产生异常
            <2>也可以在程序中显式地生成异常,这种方法称为抛出异常(ThrowExceptions)。抛出异常采用throw语句,格式如下:
    throw new ArithmeticException( );
    或者:
    ArithmeticException e=new ArithmeticException( );
    throw e;
    

    6、异常的处理
          <1>捕捉异常(try_catch_finally语句)
    try{
        //可能产生异常的语句;
    }catch(Exception1 e1){
        //处理语句1;
    }catch(Exception2 e2){
        //处理语句2;
    }finally{
        //语句序列;
    }
    /*
    1)catch语句块可以有多个;
    2)catch语句块和finally语句块可以同时存在,也可以只有其一;
    3)如果发生异常,则会跳转到捕捉对应异常的catch语句块,发生异常语句之后的语句序列不会被执行。
    4)不管异常是否发生,finally语句块总是会被执行,除非碰到强制退出程序的System.exit(0)语句;
    5)如果try语句块或catch语句块中有return语句,则会执行完finally语句块再执行返回。
    */
            一个demo:
     
    public class J_ExceptionCatch
    {
        public static void main(String args[ ])
        {
            try
            {
                System.out.println("try语句块");
                throw new Exception( );
            }
            catch(Exception e)
            {
                System.err.println("catch语句块");
                e.printStackTrace( );
            }
            finally
            {
                System.out.println("finally语句块");
            } // try-catch-finally结构结束
        } // 方法main结束
    } // 类J_ExceptionCatch结束
    
    /*运行流程:
    1.try语句块捕捉throw的异常
    2.跳转到相关的catch语句块
    3.最后执行finally语句块的内容
    */
            
            <2>throws抛出异常
    public class Test{
        public static void main(String[] args) throws IOException{
            FileInputStream fis = new FileInputStream("a.txt"); 
        }
    }
    //上面的main方法throws了IOException,声明但不去处理,所以在运行之后,
    //该异常就会交给JVM处理,程序一旦遇到该异常,就会打印该异常的跟踪栈信息
    //并结束程序


    7、自定义异常
         
    public class NewException extends Exception{
        //自定义的异常类    
        public NewException (msg){
            super(msg);
        }
    }
    //第一种用法:直接在一个判断语句下throw该异常
    public class Test{
        public static void main(String[] args){
            if(条件){
               throw new NewException("我是抛出的新异常!"); 
            }
        }
    }
    //第二种:throws之后,再try——catch
    public static void test()throws NewException{
        if(条件){
            throw new NewException("我是抛出的新异常!"); 
        }
    }
    public class Test{
        public static void main(String[] args){
            try{
                test();
            }catch(NewException e){
                System.out,println(e.getMessage());
            }
        }
    }

    ---------本人为小白,欢迎评论指正错误,一起进步!
          



    展开全文
  • 异常

    2019-05-30 17:34:18
    01. 异常的概念 02. 捕获异常 2.1 简单的捕获异常语法 2.2 错误类型捕获 2.3 异常捕获完整语法 03. 异常的传递 04. 抛出raise异常 4.1 应用场景 4.2 抛出异常 目标 异常的概念 捕获异常 异常的传递 抛...

    目录

     

    目标

    01. 异常的概念

    02. 捕获异常

    2.1 简单的捕获异常语法

    2.2 错误类型捕获

    2.3 异常捕获完整语法

    03. 异常的传递

    04. 抛出 raise 异常

    4.1 应用场景

    4.2 抛出异常


    目标

    • 异常的概念
    • 捕获异常
    • 异常的传递
    • 抛出异常

    01. 异常的概念

    • 程序在运行时,如果 Python 解释器 遇到 到一个错误,会停止程序的执行,并且提示一些错误信息,这就是 异常
    • 程序停止执行并且提示错误信息 这个动作,我们通常称之为:抛出(raise)异常

    程序开发时,很难将 所有的特殊情况 都处理的面面俱到,通过 异常捕获 可以针对突发事件做集中的处理,从而保证程序的 稳定性和健壮性

    02. 捕获异常

    2.1 简单的捕获异常语法

    • 在程序开发中,如果 对某些代码的执行不能确定是否正确,可以增加 try(尝试) 来 捕获异常
    • 捕获异常最简单的语法格式:
    try:
        尝试执行的代码
    except:
        出现错误的处理
    
    • try 尝试,下方编写要尝试代码,不确定是否能够正常执行的代码
    • except 如果不是,下方编写尝试失败的代码

    简单异常捕获演练 —— 要求用户输入整数

    try:
        # 提示用户输入一个数字
        num = int(input("请输入数字:"))
    except:
        print("请输入正确的数字")
    
    
    
    try:
        # 不能确定正确执行的代码
        num = int(input("请输入一个整数:"))
    except:
        # 错误的处理代码
        print("请输入正确的整数")
    
    print("-" * 50)
    
    

    2.2 错误类型捕获

    • 在程序执行时,可能会遇到 不同类型的异常,并且需要 针对不同类型的异常,做出不同的响应,这个时候,就需要捕获错误类型了

    • 语法如下:

    try:
        # 尝试执行的代码
        pass
    except 错误类型1:
        # 针对错误类型1,对应的代码处理
        pass
    except (错误类型2, 错误类型3):
        # 针对错误类型2 和 3,对应的代码处理
        pass
    except Exception as result:
        print("未知错误 %s" % result)
    
    • 当 Python 解释器 抛出异常 时,最后一行错误信息的第一个单词,就是错误类型

    异常类型捕获演练 —— 要求用户输入整数

    需求

    1. 提示用户输入一个整数
    2. 使用 8 除以用户输入的整数并且输出
    try:
        num = int(input("请输入整数:"))
        result = 8 / num
        print(result)
    except ValueError:
        print("请输入正确的整数")
    except ZeroDivisionError:
        print("除 0 错误")
    
    

    捕获未知错误

    • 在开发时,要预判到所有可能出现的错误,还是有一定难度的
    • 如果希望程序 无论出现任何错误,都不会因为 Python 解释器 抛出异常而被终止,可以再增加一个 except

    语法如下:

    except Exception as result:
        print("未知错误 %s" % result)
    

    2.3 异常捕获完整语法

    • 在实际开发中,为了能够处理复杂的异常情况,完整的异常语法如下:

    提示:

    • 有关完整语法的应用场景,在后续学习中,结合实际的案例会更好理解
    • 现在先对这个语法结构有个印象即可
    try:
        # 尝试执行的代码
        pass
    except 错误类型1:
        # 针对错误类型1,对应的代码处理
        pass
    except 错误类型2:
        # 针对错误类型2,对应的代码处理
        pass
    except (错误类型3, 错误类型4):
        # 针对错误类型3 和 4,对应的代码处理
        pass
    except Exception as result:
        # 打印错误信息
        print(result)
    else:
        # 没有异常才会执行的代码
        pass
    finally:
        # 无论是否有异常,都会执行的代码
        print("无论是否有异常,都会执行的代码")
    
    • else 只有在没有异常时才会执行的代码
    • finally 无论是否有异常,都会执行的代码

    • 之前一个演练的 完整捕获异常 的代码如下:

    try:
        num = int(input("请输入整数:"))
        result = 8 / num
        print(result)
    except ValueError:
        print("请输入正确的整数")
    except ZeroDivisionError:
        print("除 0 错误")
    except Exception as result:
        print("未知错误 %s" % result)
    else:
        print("正常执行")
    finally:
        print("执行完成,但是不保证正确")
    
    

    03. 异常的传递

    • 异常的传递 —— 当 函数/方法 执行 出现异常,会 将异常传递 给 函数/方法 的 调用一方
    • 如果 传递到主程序,仍然 没有异常处理,程序才会被终止

    提示

    • 在开发中,可以在主函数中增加 异常捕获
    • 而在主函数中调用的其他函数,只要出现异常,都会传递到主函数的 异常捕获 中
    • 这样就不需要在代码中,增加大量的 异常捕获,能够保证代码的整洁

    需求

    1. 定义函数 demo1() 提示用户输入一个整数并且返回
    2. 定义函数 demo2() 调用 demo1()
    3. 在主程序中调用 demo2()
    def demo1():
        return int(input("请输入一个整数:"))
    
    
    def demo2():
        return demo1()
    
    try:
        print(demo2())
    except ValueError:
        print("请输入正确的整数")
    except Exception as result:
        print("未知错误 %s" % result)
    
    

    04. 抛出 raise 异常

    4.1 应用场景

    • 在开发中,除了 代码执行出错 Python 解释器会 抛出 异常之外
    • 还可以根据 应用程序 特有的业务需求 主动抛出异常

    示例

    • 提示用户 输入密码,如果 长度少于 8,抛出 异常

    注意

    • 当前函数 只负责 提示用户输入密码,如果 密码长度不正确,需要其他的函数进行额外处理
    • 因此可以 抛出异常,由其他需要处理的函数 捕获异常

    4.2 抛出异常

    • Python 中提供了一个 Exception 异常类
    • 在开发时,如果满足 特定业务需求时,希望 抛出异常,可以:
      1. 创建 一个 Exception 的 对象
      2. 使用 raise 关键字 抛出 异常对象

    需求

    • 定义 input_password 函数,提示用户输入密码
    • 如果用户输入长度 < 8,抛出异常
    • 如果用户输入长度 >=8,返回输入的密码
    def input_password():
    
        # 1. 提示用户输入密码
        pwd = input("请输入密码:")
    
        # 2. 判断密码长度,如果长度 >= 8,返回用户输入的密码
        if len(pwd) >= 8:
            return pwd
    
        # 3. 密码长度不够,需要抛出异常
        # 1> 创建异常对象 - 使用异常的错误信息字符串作为参数
        ex = Exception("密码长度不够")
    
        # 2> 抛出异常对象
        raise ex
    
    
    try:
        user_pwd = input_password()
        print(user_pwd)
    except Exception as result:
        print("发现错误:%s" % result)
    

     

    展开全文
  • 一、异常的抛出 1、定义 : 一个方法不处理这个异常,而是调用层次向上传递,谁调用这个方法,这个异常就由谁来处理。2、throw : 将产生的异常抛出(强调的是动作),抛出的既可以是异常的引用,也可以是异常对象。...

    一、异常的抛出

    1、定义 : 一个方法不处理这个异常,而是调用层次向上传递,谁调用这个方法,这个异常就由谁来处理。

    2、throw : 将产生的异常抛出(强调的是动作),抛出的既可以是异常的引用,也可以是异常对象。(位置: 方法体内

    3、throws : 如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常(可以是一种类型,也可以是多种类型,用逗号隔开)(位置: 写在方法名 或方法名列表之后 ,在方法体之前。)

    注意 : 调用可能会抛出异常的方法,必须添加try-catch代码块尝试去捕获异常 或者 添加throws 声明 来将异常 抛出给更上一层的调用者进行处理,这里需要注意一个细节:新的异常包含原始异常的所有信息,根据这个我们可以去追溯最初异常发生的位置

    如下图所示
    这里写图片描述

    4、简单使用

    // 定义一个方法,抛出 数组越界和算术异常(多个异常 用 "," 隔开)
        public void Test1(int x) throws ArrayIndexOutOfBoundsException,ArithmeticException{
    
        System.out.println(x);
    
        if(x == 0){
    
            System.out.println("没有异常");
            return;
        }
    
        //数据越界异常
        else if (x == 1){
    
            int[] a = new int[3];
             a[3] = 5;
        }
    
        //算术异常
        else if (x == 2){
    
            int i = 0;
            int j = 5/0;
        }
    
        }

    在main方法中调用

    public static void main(String[] args) {
    
            //创建对象
            ExceptionInital object = new ExceptionInital();
    
            // 调用会抛出异常的方法,用try-catch块
            try{
    
                object.Test1(0);
    
            }catch(Exception e){
    
                System.out.println(e);
            }
    
            // 数组越界异常
            try{
    
                object.Test1(1);
            }catch (ArrayIndexOutOfBoundsException e) {
    
                System.out.println("数组越界异常:"+e);
            }
    
    
            // 算术异常
            try{
    
                object.Test1(2);
    
            }catch(ArithmeticException e){
    
                System.out.println("算术异常:"+e);
            }
    
    
            //使用 throw 抛出异常(可以抛出异常对象,也可以抛出异常对象的引用)
            try{
    
                ArrayIndexOutOfBoundsException  exception = new ArrayIndexOutOfBoundsException();
    
                throw exception;//new ArrayIndexOutOfBoundsException();
    
            }catch(ArrayIndexOutOfBoundsException e){
    
                System.out.println("thorw抛出异常:"+e);
            }
    
        }

    运行结果
    这里写图片描述

    总结下 throw 和throws 关键字的区别

    1、写法上 : throw 在方法体内使用,throws 函数名后或者参数列表后方法体前
    2、意义 : throw 强调动作,而throws 表示一种倾向、可能但不一定实际发生
    3、throws 后面跟的是异常类,可以一个,可以多个,多个用逗号隔开。throw 后跟的是异常对象,或者异常对象的引用。
    4、throws 用户抛出异常,当在当前方法中抛出异常后,当前方法执行结束(throws 后,如果有finally语句的话,会执行到finally语句后再结束。)。可以理解成return一样。

    二、自定义异常

    前面所讲的异常,都是系统自带的,系统自己处理,但是很多时候项目会出现特有问题,而这些问题并未被java所描述并封装成对象,所以对于这些特有的问题可以按照java的对问题封装的思想,将特有的问题进行自定义异常封装。在Java中要想创建自定义异常,需要继承Throwable或者他的子类Exception。

    语法

    class  自定义异常类 extends 异常类型(Exception){
    
     // 因为父类已经把异常信息的操作都完成了,所在子类只要在构造时,将异常信息传递给父类通过super 语句即可。
      // 重写 有参 和 无参  构造方法
    }

    例如:

    public class CustomException extends Exception {
    
        //无参构造方法
        public CustomException(){
    
            super();
        }
    
        //有参的构造方法
        public CustomException(String message){
            super(message);
    
        }
    
        // 用指定的详细信息和原因构造一个新的异常
        public CustomException(String message, Throwable cause){
    
            super(message,cause);
        }
    
        //用指定原因构造一个新的异常
         public CustomException(Throwable cause) {
    
             super(cause);
         }
    
    }
    
    // 备注: 这些方法怎么来的? 重写父类Exception的方法,那么如何查看Exception具有哪些API,快捷键:选中Exception, command+单击。windows系统 :选中Exception, control+单击。

    自定义异常的使用例子:
    自定义test1()方法,抛出 “我喝酒了”的异常信息,test2()方法调用test1()方法,并将异常包装成RuntimeException类型的异常,继续抛出,在main方法中调用test2()方法,并尝试捕获异常

    public void test2() {
    
            try{
    
                test1();
    
            }catch (CustomException e){
    
               RuntimeException exception  =  new RuntimeException(e);
               //exception.initCause(cause)
               throw  exception;
            }
    
        }
    
        public void test1() throws CustomException{
    
            throw new CustomException("我喝酒了");
        }
    // main方法
        public static void main(String[] args) {
    
            CustomExceptionInital object =  new  CustomExceptionInital();
    
            //try{
    
                object.test2();
    
            //}catch(Exception e){
    
            //e.printStackTrace();
    
            //}
    
        }

    输出结果:
    这里写图片描述

    思考 ? 为什么上述demo, test1() 方法 抛出异常了,但是test1() 方法自己没办法处理,所以在 参数列表后方法体前将该异常抛出了,test2() 方法调用了test1()方法捕获其异常,并将其异常 包装成 RuntimeException 异常继续抛出,但是test2()方法却没有声明 抛出异常 ? 而且,在main 方法中,调用test2()方法的时候,也不用try-catch 代码块去捕获 异常呢 ?点击我告诉你为什么

    本篇文章demo传送门

    展开全文
  • Java 中的异常(Exception)又称为例外,是一个在程序执行期间发生的事件,它中断正在执行的程序的正常指令流。为了能够及时有效地处理程序中的运行错误,必须使用异常类。 异常简介 在程序中,错误可能产生于...

    Java 中的异常(Exception)又称为例外,是一个在程序执行期间发生的事件,它中断正在执行的程序的正常指令流。为了能够及时有效地处理程序中的运行错误,必须使用异常类。

    异常简介

    在程序中,错误可能产生于程序员没有预料到的各种情况,或者超出程序员可控范围的环境,例如用户的坏数据、试图打开一个不存在的文件等。为了能够及时有效地处理程序中的运行错误,Java 专门引入了异常类。

    例 1

    为了更好地理解什么是异常,下面来看一段非常简单的 Java 程序。下面的示例代码实现了允许用户输入 1~3 以内的整数,其他情况提示输入错误。

    
     
    1. package ch11;
    2. import Java.util.Scanner;
    3. public class TestO1
    4. {
    5. public static void main(String[] args)
    6. {
    7. System.out.println("请输入您的选择:(1~3 之间的整数)");
    8. Scanner input=new Scanner(System.in);
    9. int num=input.nextInt();
    10. switch(num)
    11. {
    12. case 1:
    13. System.out.println("one");
    14. break;
    15. case 2:
    16. System.out.println("two");
    17. break;
    18. case 3:
    19. System.out.println("three");
    20. break;
    21. default:
    22. System.out.println("error");
    23. break;
    24. }
    25. }
    26. }


    正常情况下,用户会按照系统的提示输入 1~3 之间的数字。但是,如果用户没有按要求进行输入,例如输入了一个字母“a”,则程序在运行时将会发生异常,运行结果如下所示。

    请输入您的选择:(1~3 之间的整数)
    a
    Exception in thread "main" java.util.InputMismatchException
    at java.util.Scanner.throwFor(Unknown Source)
    at java.util.Scanner.next(Unknown Source)
    at java.util.Scanner.nextInt(Unknown Source)
    at java.util.Scanner.nextInt(Unknown Source)
    at text.text.main(text.java:11)

    异常产生的原因及使用原则

    在 Java 中一个异常的产生,主要有如下三种原因:

    1. Java 内部错误发生异常,Java 虚拟机产生的异常。
    2. 编写的程序代码中的错误所产生的异常,例如空指针异常、数组越界异常等。这种异常称为未检査的异常,一般需要在某些类中集中处理这些异常。
    3. 通过 throw 语句手动生成的异常,这种异常称为检査的异常,一般用来告知该方法的调用者一些必要的信息。


    Java 通过面向对象的方法来处理异常。在一个方法的运行过程中,如果发生了异常,则这个方法会产生代表该异常的一个对象,并把它交给运行时的系统,运行时系统寻找相应的代码来处理这一异常。

    我们把生成异常对象,并把它提交给运行时系统的过程称为拋出(throw)异常。运行时系统在方法的调用栈中查找,直到找到能够处理该类型异常的对象,这一个过程称为捕获(catch)异常。

    Java 异常强制用户考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程,其主要作用是捕获程序在运行时发生的异常并进行相应处理。编写代码处理某个方法可能出现的异常,可遵循如下三个原则:

    1. 在当前方法声明中使用 try catch 语句捕获异常。
    2. 一个方法被覆盖时,覆盖它的方法必须拋出相同的异常或异常的子类。
    3. 如果父类抛出多个异常,则覆盖方法必须拋出那些异常的一个子集,而不能拋出新异常。

    异常类型

    在 Java 中所有异常类型都是内置类 java.lang.Throwable 类的子类,即 Throwable 位于异常类层次结构的顶层。Throwable 类下有两个异常分支 Exception 和 Error,如图 1 所示。
     


    图1 异常结构图


    由图 2 可以知道,Throwable 类是所有异常和错误的超类,下面有 Error 和 Exception 两个子类分别表示错误和异常。其中异常类 Exception 又分为运行时异常和非运行时异常,这两种异常有很大的区别,也称为不检查异常(Unchecked Exception)和检查异常(Checked Exception)。

    • Exception 类用于用户程序可能出现的异常情况,它也是用来创建自定义异常类型类的类。
    • Error 定义了在通常环境下不希望被程序捕获的异常。Error 类型的异常用于 Java 运行时由系统显示与运行时系统本身有关的错误。堆栈溢出是这种错误的一例。
    • 本章不讨论关于 Error 类型的异常处理,因为它们通常是灾难性的致命错误,不是程序可以控制的。本章接下来的内容将讨论 Exception 类型的异常处理。


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

    非运行时异常是指 RuntimeException 以外的异常,类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如 IOException、ClassNotFoundException 等以及用户自定义的 Exception 异常,一般情况下不自定义检查异常。表 1 列出了一些常见的异常类型及它们的作用。
     

    表1 Java中常见的异常类型
    异常类型 说明
    Exception 异常层次结构的根类
    RuntimeException 运行时异常,多数 java.lang 异常的根类
    ArithmeticException 算术谱误异常,如以零做除数
    ArraylndexOutOfBoundException 数组大小小于或大于实际的数组大小
    NullPointerException 尝试访问 null 对象成员,空指针异常
    ClassNotFoundException 不能加载所需的类
    NumberF ormatException 数字转化格式异常,比如字符串到 float 型数字的转换无效
    IOException I/O 异常的根类
    F ileN otF oundException 找不到文件
    EOFException 文件结束
    InterruptedException 线程中断
    IllegalArgumentException 方法接收到非法参数
    ClassCastException 类型转换异常
    SQLException 操作数据库异常
    展开全文
  • 异常(Exception)基础 Throwable 最大的 Error 错误不是异常,是脱离程序员控制的问题,错误在代码中通常会被忽略.例如, 当栈溢出时,错误就会产生,也无法被检测 Error类对象由Java虚拟机产生,当JVM不再有继续执行操作...

    常见的几种异常

    NullPointerException空指针异常
    IOException操作输入输出流的错误
    ArrayIndexOutOfBoundsException下标越界异常
    ClassCastException类型转换出现异常
    IllegalArgumentException参数出现异常
    NumberFormatException字符串与数字转换会出现的错误

    异常(Exception)基础

    img

    Throwable

    最大的

    Error

    错误不是异常,是脱离程序员控制的问题,错误在代码中通常会被忽略.例如, 当栈溢出时,错误就会产生,也无法被检测

    Error类对象由Java虚拟机产生,当JVM不再有继续执行操作所需的内存资源时,将出现OutOfMemoryError.这些异常发生时,Java虚拟机(JVM)一般会选择线程终止;

    Exception

    几种常见的异常
    在这里插入图片描述Exception的五个关键字:

    ​ catch,try,finally,throw(在方法中抛出异常),throws(在方法上异常)

    public static void main(String[] args) {
    
    //ctrl+alt+t 可以一键生成异常
    
        try {   //监控的区域
            new demo01().a();
        } catch (Error e) { //想要捕获的异常类型,可以使用多个catch(要注意递进关系,从小到大)
            System.out.println("错误了");
    
        } finally {//无论异常是否出现都会执行 (可要可不要)
            System.out.println("程序结束");
        }
    
    }
    
    //假设方法中无法处理异常,就在方法上抛出异常,当使用时再去捕获
        public void test(int a) throws ArithmeticException{
            if(a==0){
                throw new ArithmeticException();//主动抛出异常
            }
        }
    

    e.printStackTrace()用来打印出错误的信息和位置


    自定义异常

    用户同时可以自定义异常

    1. 创建自定义异常 继承Exception类
    2. 设置参数进行传参,编写toString方法(异常的打印信息)
    3. 可以在抛出异常的方法中用try-catch处理异常,或者通过throws抛出到方法调用时,进行处理

    在这里插入图片描述


    展开全文
  • 异常(Exception)

    2019-01-06 17:23:12
    异常
  • Java之常见异常Exception

    2018-08-15 08:55:30
    异常是程序编译或运行时可能会发生的一些小的错误,如果发生会导致程序正常的运行。 编译期异常是可检查的,编译的时候提醒编程的人要处理,运行期异常是不可检查的  1.编译异常 /** * function: 1.2.1编译异常...
  • 常见的异常类Exception

    2018-11-30 11:38:15
    Java中常见的异常类型   先详细说明几个常见的异常   1. java.lang.nullpointerexception    这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的...
  • 《Java:详解Java中的异常(Error与Exception)》 《Java:简述Java中的自定义异常》 《Java:简述throw-throws异常抛出》 《Java:简述try-catch-finally异常捕获》 《Java:简述try-catch-finally中return返回》...
  • 什么事异常????  异常(exception) 是程序运行过程中发生的事件, 该事件可以中断程序指令的正常执行流程.   异常的处理机制(重点) 1当JAVA程序运行时出现问题时,系统会自动检测到该错误,并立即生成一个与该...
  • 异常是什么?

    2019-04-14 15:42:28
    异常[exception] ArrayIndexOutOfBoundsException 数组越界异常 ClassCastException 类型转换异常 ClassNotFoundException 类找不到异常 NullPointerException 空指针异常 NPE … 1. 了解异常概念 异常:在程序运行...
  • C++异常和Windows结构异常的比较 Windows结构异常有如下几个特性: 1、它使用__try、__except、__finally和__leave关键字和RaiseException API。 2、它由Windows所支持,因此它不适合其它操作系统。 3、它不处理...
  • 异常值处理一般分为以下几个步骤:异常值检测、异常值筛选、异常值处理。 其中异常值检测的方法主要有:箱型图、简单统计量(比如观察极值) 异常值处理方法主要有:删除法、插补法、替换法。 提到异常值不得不说...
  • 异常与断言标签: JavaStudy异常什么是异常: 程序运行过程中出现的不正常现象,比如:除法运算,除以0,这个就是算术异常; 记住一点:异常是运行时的程序出错,编译时检查的只是语法错误,不运行何来的异常? ...
  • Java异常类型及处理

    2018-09-21 10:54:18
    前言: Java异常,大家都很熟悉。但是对于具体怎么分类的,JVM对其怎么处理的...上图可以简单展示一下异常类实现结构图,当然上图不是所有的异常,用户自己也可以自定义异常实现。上图已经足够帮我们解释和理解异常...
  • 局部异常因子算法-Local Outlier Factor(LOF) 在数据挖掘方面,经常需要在做特征工程和模型训练之前对数据进行清洗,剔除无效数据和异常数据。异常检测也是数据挖掘的一个方向,用于反作弊、伪基站、金融诈骗等领域...
  • 本文出处:CSDN http://blog.csdn.net/xcyyueqiu/article/details/52357567啰嗦几句…前不久才重装过系统,可是没多久就出现了一个很恶心的问题:word文档、excel文档图标异常,显示的是下面这样: 打开倒是可以...
  • 所有的异常跟错误都继承与Throwable类,也就是说所有的异常都是一个对象。 从大体来分异常为两块: 1、error---错误 : 是指程序无法处理的错误,表示应用程序运行时出现的重大错误。例如jvm运行时出现的...
  • 我们知道,系统中异常包括两类:编译时异常和运行时异常RuntimeException,前者通过捕获异常从而获取异常信息,后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。在开发中,不管是dao层、service层还是...
  • 算术异常类:ArithmeticExecption 空指针异常类:NullPointerException 类型强制转换异常:ClassCastException 数组负下标异常:NegativeArrayException 数组下标越界异常:...
1 2 3 4 5 ... 20
收藏数 2,296,329
精华内容 918,531
关键字:

异常