精华内容
下载资源
问答
  • 程序之中如果出现异常并且没有合理处理的话会导致程序终止执行。 为了保证程序在出现之后可以正常执行完毕,需要进行异常处理。 先来看一下异常的继承类结构: 所有的异常都是由Throwable继承而来。其中...

    异常是导致程序中断执行的一种指令流。程序之中如果出现异常并且没有合理处理的话就会导致程序终止执行。

    为了保证程序在出现之后可以正常执行完毕,就需要进行异常处理。

    先来看一下异常的继承类结构:

    所有的异常都是由Throwable继承而来。其中Error类描述了Java运行时内部错误和资源耗尽错误。应用程序不抛出此类异常,这种内部错误一旦出现,除了告知用户并使程序安全终止之外,再无能为力。这种情况很少出现。

    我们需要关心的是Exception以及其子类。在Exception之下又分为两个分支,RuntimeException和IOException。

    RuntimeException:由于程序错误导致的异常

    IOException:程序本身没有问题,由于向像I/O错误这类问题导致的异常

    非受查异常(无须强制处理):所有继承于Error或RuntimeException的异常类称为非受查异常。

    受查异常(必须强制处理):所有继承于Exception与IOException的类称为受查异常。

    范例:异常产生(被除数为0)

    现在程序之中产生了异常,可以看出在异常语句之前的语句可以正常执行完毕,而异常产生之后程序直接结束。为了保证程序出现异常后还可以继续向下执行,就需要异常处理。

    try{
        有可能出现异常的语句 ;
    }[catch (异常类 对象) {
        异常处理
    } ... ]
    [finally {
        异常的出口(无论会不会出现异常都会执行finally块)
    }]

    [ ]内的为可选项。catch块捕获异常并进行处理。

    对于以上三个关键字,可以出现的组合:try...catch... , try...finally... , try...catch...finally...

    对异常进行处理

    • 关键字throws,关键字throw

    throws:作用于方法上。在进行方法定义时,如果要明确告诉调用者本方法可能产生哪些异常,可以使用throws关键字进行声明,表示将异常拋回给调用方。并且当方法出现问题后可以不进行处理。

    注意:如果调用了throws声明的方法,那么在调用时必须明确的使用try...catch...进行捕获,因为该方法有可能产生异常,所以必须按照异常的方式来进行处理。***主方法本身也是一个方法,所以主方法上也可以使用throws进行异常抛出,这个时候如果产生了异常就会交给JVM处理。

    throw:用在方法中,一般与自定义的异常类搭配使用。throw语句直接写在方法之中,表示人为进行异常的抛出。如果异常类对象不希望由JVM产生而通过用户产生,就可以使用throw语句来完成。

    一般而言,throw和break,continue都要和if结合使用。

    • RuntimeException类(*****)

    先看一个例子

    这是parseInt的源码定义:

    public static int parseInt(String s) throws NumberFormatException;

    这个方法上已经明确抛出异常,但是在进行调用的时候发现,即使没有进行异常处理也可以正常执行。这个就属于
    RuntimeException的范畴。

    面试题请解释Exception与RuntimeException的区别,请列举几个常见的RuntimeException。

    区别:首先Exception类是RuntimeException类的父类。使用Exception定义的异常都要求必须使用异常处理(受查异常),而使用RuntimeException定义的异常可以由用户选择性的来进行异常处理(非受查异常)。

    常见RuntimeException:ClassCastException、NullPointerException等。

     

    • 自定义异常

    自定义异常类可以继承两种父类:Exception、RuntimeException。

    范例:实现自定义异常(当两数相加等于5时,抛出异常)

    展开全文
  • Python异常

    2019-10-30 19:19:25
    程序在运行过程中不可避免会出现一些错误,比如:使用了没有赋值过的变量 除0 使用了不存在的索引等这些错误在程序中我们称之为异常,程序在运行过程中,一旦出现异常会导致程序立即终止 ,异常后面的代码都不会...

    异常概述

    程序在运行过程中不可避免会出现一些错误,比如:使用了没有赋值过的变量 除0 使用了不存在的索引等这些错误在程序中我们就称之为异常,程序在运行过程中,一旦出现异常会导致程序立即终止 ,异常后面的代码都不会执行。
    在这里插入图片描述

    处理异常

    语法:
    try:
    代码块(可能出现错误的语句)
    except 异常类型1 as 异常名1:
    代码块(出现错误以后的处理方式)
    except 异常类型2 as 异常名2:
    代码块(出现错误以后的处理方式)

    else:
    代码块(没有错误的时候要执行的语句)
    finally:
    代码块(不管是否出现都会执行的语句)
    语法规则:
    执行try下的语句,如果引发异常,则执行过程会跳到第一个except语句;如果第一个except中定义的异常与引发的异常匹配,则执行该except中的语句;如果引发的异常不匹配第一个except,则会搜索第二个except(允许编写的except数量没有限制)。
    在这里插入图片描述

    异常的传播

    当在函数中出现异常时,如果在函数中对异常进行了处理,则异常不会再传播, 如果函数中没有对异常进行处理,则异常会继续像函数调用处传播,如果函数调用处处理了异常,则不再传播,如果没有处理则继续像调用处传播,直到传递到全局作用域,如果依然没有处理,则程序终止,并且显示异常信息。
    如:

    在这里插入图片描述

    自定义异常

    抛出异常,可以是用raise语句来抛出异常,raise语句后面需要跟一个异常类或者是异常的实例,抛出异常的目的,告诉调用者这里调用时可能出现问题,希望你自己处理下。
    在这里插入图片描述

    展开全文
  • 异常

    2019-05-02 18:09:43
    一旦遇到了程序出现了问题,会把问题的类名,错误原因,错误的位置等信息打印在控制台,以便我们纠错。同时JVM会自动从出现问题处将程序终止掉,导致程序无法继续向下执行。 eg: public class TestTryCatch { ...

    一、异常的分类

    在这里插入图片描述

    二、异常的处理

    针对异常,JVM的处理方式:
    一旦遇到了程序出现了问题,就会把问题的类名,错误原因,错误的位置等信息打印在控制台,以便我们纠错。同时JVM会自动从出现问题处将程序终止掉,导致程序无法继续向下执行。
    eg:

    public class TestTryCatch {
    	public static void main(String[] args) {
    		System.out.println("程序开始了");
    		String str = null;
    		System.out.println(str.length());
    		System.out.println("程序结束了");
    }
    }
    

    在这里插入图片描述

    为了让其他没问题的程序继续执行可以采用以下做法:
    使用try——catch语句对异常进行捕获

    public class TestTryCatch {
       public static void main(String[] args) {
       	System.out.println("程序开始了");
       	try{
       	String str = null;
       	System.out.println(str.length());
       	}catch(NullPointerException e){
       		System.out.println("出现了空指针");
       	}
       	System.out.println("程序结束了");
    }
    }
       
    

    在这里插入图片描述

    <2.1.1> java异常处理机制中的try——catch语法:

    • try{
    • 代码片段
    • }catch(xxxException e){
    • 捕获try代码片段中出现的xxxException
    • 后的处理手段
    • }

    注意事项了解一下:
    1.在try代码块中,发生异常语句后面的代码是不会被执行的。

    2.catch可以定义多个,针对不同的异常有不同的处理手段时,可以分别捕获这些异常。

    3.应当有一个好习惯,在最后一个catch中捕获Exception,尽量避免因为一个 未捕获的异常导致程序中断。捕获顺序应是子类型异常在上面先捕获,父类型异常在下后捕获。

    <2.1.2> finally

    在程序中,有时候我们希望有些语句无论程序是否发生异常都要执行,这时就可以在
    try-catch语句后加一个finally代码块。

    @Test
    	public void testFinallyDemo1(){
    		System.out.println("程序開始了");
    		try{
    			String str = null;
    			System.out.println(str.length());
    		}catch(Exception e){
    			System.out.println("程序出错了");
    		}finally{
    			System.out.println("finally中的代码运行了");
    		}
    		System.out.println("程序结束了");
    	}
    

    在这里插入图片描述
    finally中需要注意的:

    • finally块是异常捕获机制中的最后一块。
    • finally可以直接跟在try后面或者最后一个catch之后。
    • finally可以保证只要程序执行到try语句块中,无论try语句块中的代码是否抛出异常,finally块中的代码都必定执行。
    • 通常会将无论是否出现异常都要运行的代码放在finally中确保运行,比如IO操作中的关闭流。
    • 有一点需要注意一下,finally中的代码有一种情况下是不会执行的,那就是在
      try-catch中执行了System.exit(0)语句。System.exit(0)表示退出当前的Java虚拟机,Java虚拟机停止了,任何代码都不能再执行了。

    <2.1.3> throws

    如果调用自己的方法,我们很清楚该方法可能会发生的异常。试想一下,如果去调用一个别人写的方法时,是否能知道别人写的方法是否会有异常呢?这是很难做出判断的。针对这种情况,Java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常,这样调用者在调用时,就明确的知道方法有异常,并且需要调用者对异常进行处理,否则编译无法通过。
    eg:
    在这里插入图片描述
    从该例可以看出,当在方法声明抛出一个异常时,在主函数中调用时,必须对该异常进行处理,否则编译不会通过。一般在主函数调用声明异常的方法时,选择对其进行
    try-catch处理。
    在这里插入图片描述
    注意事项:
    派生类在继承超类时会重写其方法,那么在重写超类中含有throws声明异常抛出的方法时,对throws的重写规则:

    • 可以不再抛出任何异常
    • 可以仅抛出父类方法抛出的部分异常
    • 可以抛出父类方法抛出异常的子类型异常
    • 不允许抛出父类方法抛出异常的父类型异常
    • 不允许抛出额外异常
    public class ThrowsDemo {
        public void dosome() throws IOException,AWTException{
        	
        }
    class Son extends ThrowsDemo{
    //	public void dosome() throws IOException,AWTException{
    //		
    //	}
    	/*
    	 * 可以不再抛出任何异常
    	 */
    //	public void dosome(){
    //		
    //	}
    	/*
    	 * 可以仅抛出父类方法抛出的部分异常
    	 */
    //	public void dosome() throws IOException{
    //		
    //	}
    	/*
    	 * 可以抛出父类方法抛出异常的子类型异常
    	 */
    //	public void dosome() throws FileNotFoundException{
    //		
    //	}
    	/*
    	 * 不允许抛出额外异常
    	 */
    	//public void dosome() throws SQLException{}  SQLException并非继承自Throwable,而是继承自 java.lang.Exception。
    	/*
    	 * 不允许抛出父类方法抛出异常的父类型异常
    	 */
    //	public void dosome() throws Exception{}
    }
    

    <2.1.4> throw

    当不满足业务逻辑要求时,可以主动抛异常。当一个方法中使用throw抛出一个异常时,就应该在当前方法上使用throws声明该异常的抛出,通知调用者在调用当前方法时要处理异常(RuntimeException除外)否则编译不通过。
    eg:

    /*
     * 使用当前类测试异常的抛出 
     */
    public class Person {
         private  int age;
    
    	/**
    	 * @return the age
    	 */
    	public int getAge() {
    		return age;
    	}
    
    	/**
    	 * @param age the age to set
    	 */
    	public void setAge(int age) throws Exception{
    		if(age<0||age>100){
    			throw new Exception("年龄不合法");
    		}
    		this.age = age; 
    	}
    }
    
    
    @Test
    public void testThrowDemo(){
    	System.out.println("程序开始了");
    	Person p = new Person();
    
    		try {
    			p.setAge(100000);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	System.out.println("此人年龄:"+p.getAge());
    	System.out.println("程序结束了");
    }
    

    在这里插入图片描述

    三、自定义异常

    JDK中定义了大量的异常类,虽然这些异常类可以描述编程时出现的大部分异常情况,但是在程序开发中有时可能需要描述程序中特有的异常情况。为了解决这个问题,在java中允许用户自定义异常,但自定义异常必须继承自Exception类或其他子类。

    /**
     * 年龄不合法异常
     * 
     * 自定义异常通常用来说明某些业务逻辑错误
     */
    public class IllegalAgeException extends Exception{
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    
    	public IllegalAgeException() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    		super(message, cause, enableSuppression, writableStackTrace);
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(String message, Throwable cause) {
    		super(message, cause);
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(String message) {
    		super(message);
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(Throwable cause) {
    		super(cause);
    		// TODO Auto-generated constructor stub
    	}
        
    }
    注意:在实际开发中,如果没有特殊的要求,自定义的异常类只需继承Exception类
    ,在构造方法中使用supper()语句调用Exception的构造方法即可。
    
    

    既然自定义了异常,那么该如何使用呢?这时就需要用到throw关键字,throw关键字用于在方法中声明抛出异常的实例对象。

    • 语法格式:
    • throw Exception 异常对象
      eg:
    
    /*
     * 使用当前类测试异常的抛出 
     */
    public class Person {
         private  int age;
    
    	/**
    	 * @return the age
    	 */
    	public int getAge() {
    		return age;
    	}
    
    	/**
    	 * @param age the age to set
    	 */
    	public void setAge(int age) throws IllegalAgeException{
    		if(age<0||age>100){
    			throw new IllegalAgeException("年龄不合法");
    		}
    		this.age = age; 
    	}
    }
    

    测试异常的抛出:
    因为首先我们自定义了异常类,且在Person类中使用了throw关键字在方法中向调用者抛出了IllegalAgeException异常,所以在调用该方法p.setAge()时,调用者必须处理异常,否则编译不通过。

    
    /*
     * 测试异常的抛出
     */
    public class ThrowDemo {
    @Test
    public void testThrowDemo(){
    	System.out.println("程序开始了");
    	Person p = new Person();
    	
    		/*
    		 * 当调用一个含有throws声明异常抛出的方法时,编译器要求必须处理这个异常
    		 * 而处理方式有两种:
    		 * 1.使用try——catch处理该异常
    		 * 2.在当前方法上继续声明throws将该异常抛出
    		 * 具体如何处理,结合实际业务需求而定。
    		 */
    		try {
    			p.setAge(10);
    		} catch (IllegalAgeException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	System.out.println("此人年龄:"+p.getAge());
    	System.out.println("程序结束了");
    }
    }
    

    Tips

    finally和final的区别:
    final,最终的意思。可以修饰类,方法,变量。
    修饰类,类不能被继承,但可以继承别人。
    修饰方法,方法不能被重写。
    修饰变量,变量是常量。

    finally
    异常处理的一部分。被finally控制的代码块一定会执行。

    throw和throws的区别:
    throws:

    • 用在方法声明后面,跟的是异常类名
    • 可以跟多个异常类名,用逗号隔开
    • 表示抛出异常,由该方法的调用者来处理
    • throws表示出现异常的一种可能性,并不一定会发生这些异常。

    throw:

    • 用在方法体内,跟的是异常对象名
    • 只能抛出一个异常对象名
    • 表示抛出异常,由方法体内的语句处理
    • throw是抛出了异常,执行throw则一定抛出了某种异常
    • 如果throw的是编译时期异常,在方法声明上必须用throws进行标记
    • 如果throw的是运行时期异常,在方法声明上可以用throws进行标记,也可以不用。
    展开全文
  • Python异常和文件

    2020-08-09 11:48:23
    程序一旦出现异常,会导致程序立即终止。异常后面的代码都不会执行 处理异常 程序出现异常,目的并不是让我们的程序终止,而是希望我们在出现异常的时候,能够编写响应的代码来对异常进行处理 try 语句: 语法: ...
    1. 异常
      在程序运行的过程中,不可避免的会出现一些错误。比如 使用了不存的索引,引用了没有赋值的变量… 这些错误我们就称之为异常
      程序一旦出现异常,会导致程序立即终止。异常后面的代码都不会执行
    2. 处理异常
      程序出现异常,目的并不是让我们的程序终止,而是希望我们在出现异常的时候,能够编写响应的代码来对异常进行处理

    try 语句:
    语法:

    try:
        代码块(可能出现错误的语句)
    except 异常类型 as 异常名:
        代码块(出现错误以后的处理方式)
    except 异常类型 as 异常名:
        代码块(出现错误以后的处理方式)
    except 异常类型 as 异常名:
        代码块(出现错误以后的处理方式)
    else:
        代码块(没有出现错误的语句)
    finally:
        代码块(该代码总会执行)
    

    在未知错误类型的时候:

    try:
    	print(6/0)
    except:
    	print("语句错误")
    else:
    	print("执行完成")
    

    屏幕输出:除数不能为0


    在已知错误类型的时候:
    (如果出现的错误 跟 except中的错误不相同,则直接报错,不会执行except中的代码)

    try:
    	print(6/0)
    except ZeroDivisionError as a:
    	print(a)
    

    屏幕输出:division by zero
    (except如果指定异常 只会捕获指定的异常)


    在未知情况下,想知晓错误类型,和错误内容,此时可以用到一个关键字
    Exception

    try:
    	print(6/0)
    except Exception as a:
    	print(a,type(a))
    

    屏幕输出:division by zero <class 'ZeroDivisionError'>


    1. 异常的传播
      当函数中出现异常的时候,如果在函数中对异常进行了处理,则异常不会在继续传播,如果在函数中没有对异常进行处理,则异常会继续向函数调用处传播
    def fn():
    	print(6/0)
    fn()
    

    控制台显示:

    Traceback (most recent call last):
      File "......", line 3, in <module>
        fn()
      File "......", line 2, in fn
        print(6/0)
    ZeroDivisionError: division by zero
    

    1. 文件

    打开文件
    语法:open(文件路径)
    返回值:当前打开的文件作为对象返回
    例如打开一个位于C:\Users\xiao_weiyu\Desktop\资料.txt 的文本文档

    file_name = "C:\Users\xiao_weiyu\Desktop\资料.txt "
    file_one = open(file_name)
    

    关闭文件
    语法:文件对象.close( )
    (关闭文件,是为了节省空间,优化程序)

    file_name = "test.txt"
    file_one = open(file_name)
    file_one.close()
    

    这样关闭文件容易,当代码较多时容易遗漏close()
    更简洁的方式:
    with as
    语法:with open(文件路径) as 接收文件变量:

    file_name = "test.txt"
    with open(file_name) as file_one:
    	content = file_one.read()
    

    执行完代码块 程序会自动关闭文件


    文件写入
    open()函数来进行文件的操作(读 写 追加),如果不指定操作类型,则默认是读取文件
    w 表示是可写的。如果文件不存在,它会帮我们来创建一个文件并写入内容。如果文件存在则会覆盖原文件的内容
    a 表示追加内容

    例如在当前目录创建一个名为:test.txt 的文本文档,并写入内容:abc
    write( ) 方法 用来写入数据
    语法:文件对象.write(内容)

    file_name = "test.txt"
    with open(file_name,"w") as file_one:
    	file_one.write("abc")
    

    文件读取
    (open()函数 默认为读取操作 如不指定操作)
    调用open()来打开一个文件的时候,可以将文件分为两种类型
    第一种 是纯文本(使用utf-8等编写的文本文件)
    第二种 是二进制文件(音频、视频、图片…)
    open()函数它默认打开文件是以纯文本的形式

    例如读取一个名为:test.txt 文本文档 内容为:你好世界
    内容为中文,此时需要标明解码格式为:utf-8
    read( ) 方法 用来读取数据
    语法:文件对象.read(内容长度)     默认内容长度:-1    表示全部读取

    file_name = "test.txt"
    with open(file_name,encoding="utf-8") as file_one:
    	content = file_one.read()
    

    较大文件读取
    (如果一个文件内容过多,一次性读取完所有内容,很容易导致电脑死机)


    read( ) 可以接受一个size作为参数,该参数用来指定读取字符的数量
    默认值为-1 读取全部的内容
    例如先读100个字符(字符和中文都算作一个)

    file_name = "test.txt"
    with open(file_name,encoding="uft-8") as file_one:
    	file_one.read(100)
    

    readline( )
    作用:每次只读取一行
    如果想每次读取一行,直到读取完,才截止,可以这样写

    file_name = "test.txt"
    with open(file_name,encoding="utf-8") as file_one:
    	while True:
    		content = file_one.readline()
    		if not content:
    			break
    		else:
    			print(content,end="")
    

    readlines( )
    作用:读取整个文件所有行,保存在一个列表(list)变量中,每行作为一个元素,但读取大文件会比较占内存。
    (每行的\n也会被记录)

    文件内容:
    #你好世界
    #你好python
    #你好c语言
    #你好java
    
    file_name ="test.txt"
    with open(file_name,encoding="utf-8") as file_one:
    	content = file_one.readlines()
    

    此时content:['你好世界\n', '你好python\n', '你好c语言\n', '你好java']

    展开全文
  • 15-异常和文件

    2020-10-05 00:18:28
    程序在运行的过程中,一旦出现异常,将会导致程序立即终止,异常的代码不会执行了print('你好') print(10 / 0) print('hello') 只会显示你好,hello已经不显示了,在10/0的地方终止 2、处理异常 程序在...
  • 八、异常处理

    2019-10-29 23:16:25
    程序在运行过程中,一旦出现异常会导致程序立即终止,异常后面的代码都不会执行。 处理异常: 程序出现异常:目的并不是要程序立即终止; Python是希望在出现异常时,我们可以编写代码对异常进行处理。 ''' 语法: ...
  • python异常和文件

    2020-08-05 22:23:46
    程序一旦出现异常,会导致程序立即终止,异常后面的代码都不会执行 程序出现异常,目的并不是让我们的程序终止,而是希望我们在出现异常的时候,能够编写相应的代码来对异常进行处理 ''' try语句 try: 代码块...
  • 程序在运行过程中,一旦出现异常会导致程序立即终止 异常后面的代码都不会执行 print(b) #NameError: name 'b' is not defined 处理异常 程序出现异常,目的并不是要程序立即终止 Python是希望在出现异常时,...
  • 程序在运行过程中,一旦出现异常程序立即终止,异常后面的代码都不会执行 print(b) print(20/0) print(‘python’) print(20/0) print(‘hello’) 处理异常 程序执行过程出现异常目的并不是要程序立即终止...
  • 程序在运行过程中不可避免会出现一些错误,比如:使用了没有赋值过的变量、除0、使用了不存在的索引…这些错误在程序中我们称之为异常,程序在运行过程中,一旦出现异常会导致程序立即终止 异常后面的代码都不会...
  • Java异常: ①使用try-catch-finally处理异常; ②使用throw、throws抛出异常; ③上边为java异常处理5个关键字。...如果异常不被处理,程序就会被强制终止(终止出现异常的业务代码执行)。 在程序运行中...
  • 1.2 程序运行中,一旦出现异常,将导致程序立刻停止,发生异常之后的代码不会执行了。 1.3 处理异常: 程序运行时出现异常,目的并不是让我们的程序直接终止,Python 是希望在出现异常时,我们可以编写代码来对...
  • java:异常与捕获

    2019-04-12 15:15:38
      几乎所有的代码里面都会出现异常,为了保证程序出现异常之后可以正常执行完毕,需要进行异常处理。 看一下异常的继承类结构 所有的异常都是由Throwable继承而来 Error类描述了java运行时内部错误和资源耗尽...
  • 笔记(十五):异常

    2020-10-07 19:48:45
    异常什么是异常什么是异常处理为什么需要异常处理如何处理异常try-catch异常处理实例finally块finally...一旦发生异常,如果不处理,程序就终止 处理异常程序就继续运行,保证了程序的健壮性 如何处理异常 使用t
  • PYTHON-异常处理

    2021-02-07 16:38:01
    程序一旦出现错误,便会产生一个异常,若程序中没有处理它,会抛出该异常程序的运行也随之终止。 2、异常处理 为了保证程序的容错性与可靠性,即在遇到错误时有相应的处理机制不会任由程序崩溃掉,我们需要对...
  • Java 异常与捕获

    2019-03-25 00:24:00
    几乎所有的代码里面都会出现异常,为了保证程序出现异常之后可以正常执行完毕,需要进行异常处理。 先来看一下异常的继承类结构: 所有的异常都是由Throwable继承而来,我们来看他下面的两个子类Error和...
  • python中的异常处理

    2020-12-05 16:16:33
    一旦python脚本发生异常程序需要捕获并处理它,否则程序终止执行。异常处理使程序能够处理完异常后继续他的正常执行,不至于使程序异常导致退出或崩溃。捕捉异常可以使用try/except语句。 try/except语句用来...
  • [JavaSE]异常体系

    2019-05-02 13:33:34
    目录 1异常 1.1异常的理解 1.2调用栈e.printStackTrace(); 2异常体系 ...2.1异常的类继承关系: ...2.2异常处理(throw/throws) ...2.3自定义异常 ...1异常 ...一旦出现异常程序就终止异常...
  • Python学习--异常处理

    2019-10-05 04:56:13
    一般情况下,程序运行过程中会出现各种各样的错误就是我们看到的报错,一旦出错程序就终止运行。异常是Python对象,如果我们不在程序运行过程中捕获异常那么程序就有可能终止运行。 举个例子: def calc(a, b)...
  • 文章目录一、异常的概念1.1 了解异常二. 异常的对象2.1 语法2.2 处理异常2.3 捕获指定异常2.3.1 语法2.3.2 体验2.3.3 捕获多个指定异常2.3.4 捕获异常描述...程序在运行过程中,一旦出现异常会导致程序立即终止.在异
  • Python基础第15讲 - 异常、文件 一、异常的简介 ...程序在运行过程中,一旦出现异常会导致程序会立即终止,异常后面的代码都不会执行 print(20/0) # 异常 --> ZeroDivisionError: division by zero...
  • JavaSE之异常与捕获

    2018-11-14 10:10:14
    几乎所有的代码里面都会出现异常,为了保证程序出现异常之后可以正常执行完毕,需要进行异常处理。 先看一下异常的继承类结果: 所有的异常都是由Throwable继承而来,我们来看他下面的两个子类Error和...
  • Java 之 异常与捕获

    2019-03-31 10:29:55
    几乎所有的代码里面都会出现异常,为了保证程序出现异常之后可以正常执行完毕,需要进行异常处理。 1.异常的继承类结构: 所有的异常都是由Throwable继承而来,他的两个子类是 Error和Exception。 Error类描述了...
  • 异常,线程

    2018-08-17 17:42:21
    什么是“异常”:是指代码在执行过程中,出现了一些JVM无法处理的数据,一旦出现这种情况,JVM将会终止程序的执行(程序卡死,程序闪退),这种情况叫:异常。 public class Demo { public static void main(String[]...
  • java———异常与捕获

    2018-12-06 18:30:36
    几乎所有的代码里面都会出现异常,为了保证程序出现异常之后可以正常执行完毕,需要进行异常处理。 先来看一下异常的继承类结构 所有的异常都是由Throwable继承而来,我们来看他下面的两个子类Error和Exception....
  • java中的异常 代码正常运行不会出问题,...//当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例 System.out.println(1/0);//java.lang.ArithmeticException //当应用程序试图在...
  • 第15天复习(异常

    2019-08-22 14:48:03
    异常: 1、什么是异常 代码运行过程中,或者编译过程中...一旦代码出现了异常,程序就会被终止掉 5、java中处理异常的方法: 1、不处理 抛给调用者 2、使用try catch 语句块尝试着抓取异常 try: //可能出现异常...
  • 异常一旦出现了,程序就会退出JVM虚拟机而终止,开发异常是需要处理的。 研究异常并且避免异常,然后提前处理异常,体现的是程序的健壮性!!! Error : 错误的意思,严重错误Error,无法通过处理的错误,一旦出现,...
  • 第6章、异常

    2020-12-21 19:37:37
    遇到错误就终止程序的运行。 程序员在编写程序时,就考虑到错误的检测、错误消息的提示,以及错误的处理。 处理异常: Java中把不同的异常用不同的类表示,一旦发生某种异常,就通过创建该异常类型的对象,并且抛
  •  当程序运行的时候出现了异常,导致程序终止运行,为了解决这种情况,我们需要预先对可能出现的异常进行处理,一旦出现这种异常使用另一种方式解决问题,还有就是错误信息是使用者没有必要看到的,他们不需要...

空空如也

空空如也

1 2 3
收藏数 59
精华内容 23
关键字:

一旦出现异常程序就终止了