异常 订阅
异常是一个汉语词语,读音为yì cháng,指非正常的;不同于平常的;非常。出自《后汉书·皇后纪上·光烈阴皇后》。 展开全文
异常是一个汉语词语,读音为yì cháng,指非正常的;不同于平常的;非常。出自《后汉书·皇后纪上·光烈阴皇后》。
信息
外文名
unusual
注    音
ㄧˋ ㄔㄤˊ
拼    音
yì cháng
近义词
反常
中文名
异常
反义词
寻常
异常词语辨析
反义词:正常
收起全文
精华内容
参与话题
问答
  • Java的异常Exception----(最简单明了的总结)

    万次阅读 多人点赞 2017-11-01 21:05:48
    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());
            }
        }
    }

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



    展开全文
  • Java:详解Java中的异常(Error与Exception)

    万次阅读 多人点赞 2018-06-22 16:54:26
    《Java:详解Java中的异常(Error与Exception)》 《Java:简述Java中的自定义异常》 《Java:简述throw-throws异常抛出》 《Java:简述try-catch-finally异常捕获》 《Java:简述try-catch-finally中return返回》...
    1. Java:详解Java中的异常(Error与Exception)
    2. Java:简述Java中的自定义异常
    3. Java:简述throw-throws异常抛出
    4. Java:简述try-catch-finally异常捕获
    5. Java:简述try-catch-finally中return返回

    一、 异常机制的概述
          异常机制是指当程序出现错误后,程序如何处理。具体来说,异常机制提供了程序退出的安全通道。当出现错误后,程序执行的流程发生改变,程序的控制权转移到异常处理器。

          程序错误分为三种:1.编译错误;2.运行时错误;3.逻辑错误。
          (1)编译错误是因为程序没有遵循语法规则,编译程序能够自己发现并且提示我们错误的原因和位置,这个也是大家在刚接触编程语言最常遇到的问题。
          (2)运行时错误是因为程序在执行时,运行环境发现了不能执行的操作。
          (3)逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误,而异常处理就是对这些错误进行处理和控制。
     

    二、 异常的结构    
           在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。


           Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常处理的重要子类,各自都包含大量子类。异常和错误的区别是:异常能被程序本身可以处理,错误是无法处理。
          Throwable类中常用方法如下:

    1. 返回异常发生时的详细信息
    public string getMessage();
    
    2. 返回异常发生时的简要描述
    public string toString();
    
    3. 返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法,可以声称本地化信息。如果子类没有覆盖该方法,则该方法返回的信息与getMessage()返回的结果相同
    public string getLocalizedMessage();
    
    4. 在控制台上打印Throwable对象封装的异常信息
    public void printStackTrace();

           Error(错误):是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 不再有继续执行操作所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,因为它们在应用程序的控制和处理能力之 外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过Error的子类描述。 

          Exception(异常):是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。
          Exception(异常)分两大类:运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。
          1.运行时异常:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。
          2.非运行时异常 (编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常。

           通常,Java的异常(Throwable)分为可查的异常(checked exceptions)不可查的异常(unchecked exceptions)


           1. 可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常状况。除了Exception中的RuntimeException及RuntimeException的子类以外,其他的Exception类及其子类(例如:IOException和ClassNotFoundException)都属于可查异常。这种异常的特点是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,否则编译不会通过。
          2. 不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。RuntimeException表示编译器不会检查程序是否对RuntimeException作了处理,在程序中不必捕获RuntimException类型的异常,也不必在方法体声明抛出RuntimeException类。RuntimeException发生的时候,表示程序中出现了编程错误,所以应该找出错误修改程序,而不是去捕获RuntimeException。

    三、 异常处理的机制
          在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。
          1. 抛出异常:当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。详细信息请查看简述throw-throws异常抛出》。
          2. 捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。详细信息请查看Java:简述try-catch-finally异常捕获》。

          对于错误、运行时异常、可查异常,Java技术所要求的异常处理方式有所不同。
          1. 错误:对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常。
          2. 运行时异常:由于运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常。
          3. 可查异常:对于所有的可查异常,Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常。

            能够捕捉异常的方法,需要提供相符类型的异常处理器。所捕捉的异常,可能是由于自身语句所引发并抛出的异常,也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常。简单地说,异常总是先被抛出,后被捕捉的。
            异常抛出:任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。
            异常捕获:捕捉异常通过try-catch语句或者try-catch-finally语句实现。
            总体来说,Java规定:对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

    三、Java常见异常
          1. RuntimeException子类:    

    序号 异常名称 异常描述
    1 java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
    2 java.lang.ArithmeticException  算术条件异常。譬如:整数除零等。
    3 java.lang.SecurityException  安全性异常
    4 java.lang.IllegalArgumentException 非法参数异常
    5 java.lang.ArrayStoreException  数组中包含不兼容的值抛出的异常 
    6 java.lang.NegativeArraySizeException 数组长度为负异常 
    7 java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。

          2.IOException

    序号 异常名称 异常描述
    1 IOException 操作输入流和输出流时可能出现的异常
    2 EOFException 文件已结束异常
    3 FileNotFoundException 文件未找到异常

          3. 其他    

    序号 异常名称 异常描述
    1 ClassCastException 类型转换异常类
    2 ArrayStoreException 数组中包含不兼容的值抛出的异常
    3 SQLException 操作数据库异常类
    4 NoSuchFieldException 字段未找到异常
    5 NoSuchMethodException 方法未找到抛出的异常
    6 NumberFormatException 字符串转换为数字抛出的异常
    7 StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
    8 IllegalAccessException 不允许访问某类异常
    9 InstantiationException

     当应用程序试图使用Class类中的newInstance()方法创建

    一个类的实例,而指定的类对象无法被实例化时,抛出该异常

    10 java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。

    四、相关的问题
          1. 为什么要创建自己的异常?
          答:当Java内置的异常都不能明确的说明异常情况的时候,需要创建自己的异常。

          2. 应该在声明方法抛出异常还是在方法中捕获异常?
          答:捕捉并处理知道如何处理的异常,而抛出不知道如何处理的异常。

    展开全文
  • Java 如何抛出异常、自定义异常

    万次阅读 多人点赞 2017-06-13 23:18:02
    一、异常的抛出 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传送门

    在这里插入图片描述

    展开全文
  • 异常

    2019-05-21 21:00:32
    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)
    

     

    展开全文
  • 异常(Exception)基础 Throwable 最大的 Error 错误不是异常,是脱离程序员控制的问题,错误在代码中通常会被忽略.例如, 当栈溢出时,错误就会产生,也无法被检测 Error类对象由Java虚拟机产生,当JVM不再有继续执行操作...
  • Python-异常&文件

    2020-05-17 10:11:33
    1. 异常简介 程序在运⾏过程中可能会出现⼀些错误。⽐如: 使⽤了不存在的索引,两个不同类型的数据相加… 这些错误我们称之为异常。 print(a) # NameError: name 'a' is not defined print(10/0) # ...
  • 目录学习Python(13)错误和异常&文件读写一.错误和异常1.概念2.异常处理3.assert断言4.自定义异常二.文件读写1.概念2.文件操作3.编码和解码4.csv文件的读写5.复制文件 学习Python(13)错误和异常&文件读写 一....
  • 15—(异常&文件)

    2020-10-24 10:37:29
    1. 异常简介 程序在运⾏过程中可能会出现⼀些错误。⽐如: 使⽤了不存在的索引,两个不同类型的数据相加…这些错误我们称之为异常 处理异常 程序运⾏时出现异常,⽬的并不是让我们的程序直接终⽌!Python是希望在...
  • Python基础——异常&文件1.异常简介2.异常的传播3.异常对象4.文件打开5.关闭文件6.读取文件7.较大文件的读取8.文件写入9.二进制文件写入 1.异常简介 程序在运行过程中可能会出现一些错误。⽐如: 使⽤了不存在的...
  • 异常&文件1. 异常简介2. 异常的传播 1. 异常简介 程序在运行过程中可能会出现一些错误。 比如: 使用了不存在的索引,两个不同类型的数据相加… 这些错误我们称之为异常 处理异常 程序运行时出现异常,目的并...
  • java异常分类和处理

    万次阅读 2018-03-08 14:57:37
    -------------------------------------java异常分类和处理--------------------------------异常 异常都是以Exception结尾的。 在我们写程序的时候难免会出现错误,java中的异常机制为了提高我们程序的健壮性和...
  • 异常

    2020-11-04 22:27:04
    一、异常的概念 当写完程序之后,最终交给Python的解释器执行。解释器执行时,遇到错误就会抛出异常。 例1: 当输入a: 二、异常捕获 2.1 最简单...
  • Java之常见异常Exception

    万次阅读 2018-08-15 08:45:36
    异常是程序编译或运行时可能会发生的一些小的错误,如果发生会导致程序正常的运行。 编译期异常是可检查的,编译的时候提醒编程的人要处理,运行期异常是不可检查的  1.编译异常 /** * function: 1.2.1编译异常...
  • java中异常的捕获及处理

    万次阅读 多人点赞 2019-03-16 15:28:13
    一、Java异常简介 什么是异常? 程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常异常发生时,是任程序自生自灭,立刻退出终止。在Java中即,Java在编译或运行或者运行过程...
  • java(3)-深入理解java异常处理机制

    万次阅读 多人点赞 2011-01-20 18:44:00
    1. 引子 try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训”告诉我,这个东西可不是想象中的那么简单、听话。...
  • Java异常分类

    万次阅读 多人点赞 2012-11-27 15:46:48
    1 基本概念 java.lang.Throwable是所有异常的根 ...一般分为Checked异常和Runtime异常,所有RuntimeException类及其子类的实例被称为Runtime异常,不属于该范畴的异常则被称为CheckedException。 2.1...
  • Java异常面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:15:59
    受检异常与非受检异常受检异常非受检异常Java异常关键字Java异常处理声明异常抛出异常捕获异常如何选择异常类型常见异常处理方式直接抛出异常封装异常再抛出捕获异常自定义异常try-catch-finallytry-with-r...
  • (精华)2020年6月29日 C#类库 全局异常

    万次阅读 2020-06-29 11:23:17
    using Coldairarrow.Util; using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.Extensions.Logging; using System; using System.Threading.Tasks; ...namespace Core.Api ... public class GlobalExceptionFilter ...
  • 本文通过对RESTful WebService中异常处理的几个关键点如自定义错误码、定制错误消息、自定义异常、全局异常处理进行介绍,分享本人对Spring异常处理和对RESTful API设计的思考和实践。 随着前后端分离,前端工程化...
  • Word、Excel、PPT等图标异常解决方案

    万次阅读 多人点赞 2016-08-30 00:06:48
    本文出处:CSDN http://blog.csdn.net/xcyyueqiu/article/details/52357567啰嗦几句…前不久才重装过系统,可是没多久就出现了一个很恶心的问题:word文档、excel文档图标异常,显示的是下面这样: 打开倒是可以...

空空如也

1 2 3 4 5 ... 20
收藏数 2,520,741
精华内容 1,008,296
关键字:

异常