异常的概念，捕获，抛出

最新推荐文章于 2023-08-09 21:35:39 发布

且固执

最新推荐文章于 2023-08-09 21:35:39 发布

阅读量678

点赞数

分类专栏： java基础文章标签： java jvm 数据结构

本文链接：https://blog.csdn.net/weixin_52528062/article/details/127278038

版权

java基础专栏收录该内容

21 篇文章 2 订阅

订阅专栏

异常的概念

异常的英文单词是exception，字面翻译就是“意外、例外”的意思，也就是非正常情况。java异常是java提供的用于处理程序中错误的一种机制。所谓错误是指在程序运行的过程中发生的一些异常事件；事实上，异常本质上是程序上的错误。

10.2 异常的分类

异常主要分为运行时异常和非运行时异常：
运行时异常都是Unexceptionably类及其子类异常，如Interception、Unexceptionably等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是Unexceptionably以外的异常。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如Conception、Exceptional等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

10.3 异常体系结构

在这里插入图片描述
1.Error：称为错误，由Java虚拟机生成并抛出，包括动态链接失败，虚拟机错误等，程序对其不做处理。

2.Exception：所有异常类的父类，其子类对应了各种各样的可能出现的异常事件，一般需要用户显示的声明或捕获。

3.0Runtime Exception：一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）。

其实异常部分主要讲的就是五个关键字：try、catch、finally、throw、throws：

1.try语句：
try{……}语句制定了一段代码，这段代码就是一次捕获并处理例外的范围。在执行过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。如果没有例外发生，所有的catch代码段都被略过不执行。

2.catch语句：
在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
在catch中声明的异常对象（catch（Exception e））封装了异常事件发生的信息，在catch语句块中可以使用这个对象的一些方法获取这些信息。

3.finally语句：
finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够对程序的状态做统一的管理。
无论try所指定的程序块中是否抛出例外，finally所指定的代码都要执行。
通常在finally语句中可以进行资源的清除工作，如：
　　1）关闭打开的文件
　　2）删除临时文件
　　3）……
　　
**4.throws语句：
throws关键字的最大好处是：在方法中不处理任何的异常，而交给被调用处处理。

5.throw语句：
在程序中可以使用throw关键字人为的抛出一个异常。在异常处理中，实际上每次产生异常的时候都是产生了一个异常类的实例化对象。那么此时，也可以通过抛出异常对象的方式完成。**

10.4 常见的异常和解决方式

下面就看一下常见的一些异常和处理：
示例（封装类）：

package com.ambow.test;
/**
 * 玩家封装数据
 * 
 * */
public class Player {
	private int id;//表示玩家的编号
	private String loginname;//表示玩家用户名
	private String password;//表示密码
	private String nickname;//表示玩家昵称
	private String sex;//表示玩家性别
	private int age;//表示玩家年龄
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getLoginname() {
		return loginname;
	}
	public void setLoginname(String loginname) {
		this.loginname = loginname;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getNickname() {
		return nickname;
	}
	public void setNickname(String nickname) {
		this.nickname = nickname;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

示例：

package com.ambow.test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class ExceptionDemo {
	public void say(Player pla){
		
	}
	/*
	 *异常的概念：本质上就是程序的错误
	 *异常的分类：1.运行时异常 exception：程序运行时发生的异常，可以不处理，要尽量避免
	 *		  2.非运行时异常error：可以在编译期被检测到，必须要处理
	 * 常见的异常：
	 * 		1.数组下标越界异常
	 * 		2.空指针异常
	 * 		3.算术异常
	 * 		4.输入不匹配异常
	 * 		5.类型转换异常
	 * 		6.解析异常
	 * 		7.类路径丢失异常
	 * 		8.参数类型不匹配异常
	 * */
	public static void main(String[] args) throws ParseException, ClassNotFoundException {
		//java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常
		//解决方案：查看数组的下标是否有异常
		/*int[] ints=new int[10];
		ints[10]=5;*/
		
		//java.lang.NullPointerException：空指针异常
		//解决方案：查看你的赋值（引用，对象）或者传值（引用，对象）是否丢失
		/*Player pla=null;
		System.out.println(pla.getLoginname());*/
		
		//java.lang.ArithmeticException:算术异常
		//解决方案：说明的你的数学逻辑出问题，将其修改就可以
		//System.out.println(100/0);
		
		//java.util.InputMismatchException:输入不匹配异常
		//解决方案：使用异常的处理
		/*Scanner sc=new   Scanner(System.in);
		System.out.println("请输入一个数字：");
		sc.nextInt();*/
		
		//多态
		/*Object o=new Integer(5);
		System.out.println(o);
		//java.lang.ClassCastException:类型转换异常
		//解决方案：后面说。。。。
		String s=(String)o;
		System.out.println(s);*/
		
		/*SimpleDateFormat sf=new SimpleDateFormat("yyyy/MM/dd");
		//java.text.ParseException：解析异常
		//解决方案：查看解析的格式是否一致
		Date date=sf.parse("2018-07-16");
		System.out.println(date);*/
		
		//java.lang.ClassNotFoundException:类路径丢失异常
		//Class.forName("com/tjzs/a/ExceptionDemo.java");
		
		//java.lang.lllegalArgumentException:参数类型不匹配异常
		//解决方案：参看传递的参数是否与定义的参数一致
	}
}

10.5 异常的执行原理

执行try时，如果发生异常。JVM会自动创建一个相应类型的异常对象。然后catch块会检查异常的类型，如果发生的异常恰恰和catch观察的类型一样，则由相应的catch处理该异常。所以，catch块可以有多个，并且按照从前往后的顺序检查。一般把小的异常类型放在前面，大的类型（Exception）放到后面

10.6 异常的处理

异常的处理主要包括捕捉异常、程序流程的跳转和异常处理语句块的定义等。
在Java程序里，异常对象是依靠try/catch语句来捕捉和处理的。
try{
…… //try语句块，可能产生异常情况
}catch(异常类型异常对象){
…… //catch语句块，对异常进行处理
}finally{
… //无论是否有异常出现,都必须执行
}
在try块之后，可能有许多catch块，每一个都处理不同的异常.finally语句只用来控制从try—catch语句转移到另一部分前的一些必要的善后工作，这些工作包含了关闭文件或释放其他有关系统资源。finally语句执行的是一种强制的无条件执行，即无论在程序中是否出现异常，也不管出现的是哪一种异常，即使try代码块中包含有break、continue、return或者throw语句，都必须执行finally块中所包含的语句。

10.5.1 异常的捕获

异常捕获的基本思想：
当一个异常被抛出时，应该有专门的语句来捕获这个被抛出的异常对象，这个过程被称为捕捉异常。
Java的异常处理是通过3个关键词来实现的：try-catch-finally。用try来执行一段程序，如果出现异常，系统抛出（throws）一个异常，可以通过它的类型来捕捉（catch）并处理它，最后一步是通过finally语句为异常处理提供一个统一的出口，finally所指定的代码都要被执行（catch语句可有多条；finally语句最多只能有一条，根据自己的需要可要可不要）。
异常捕获的语法：
try{
可能出现异常的语句
}catch(异常类异常对象){
异常处理
}catch(异常类异常对象){
异常处理
}
…
finally{
异常的出口;
}
示例：

package com.ambow.test;
/**
 * 处理异常的方式：
 * 		1.try-catch模块（异常的处理）
 * 		2.通过throws关键字来抛出异常（异常的抛出）
 * */
public class ExcptionDemo2 {
	/*try-catch的语法格式：
	 * 一个try后面可以跟多个catch语句，也就是说一个try语句中可以捕获多个异常,
	 * 但是在具体执行时只会捕获出现的第一个异常
	 * try{
	 * 		//可能出现异常的语句
	 * 		retrun;
	 * 		}catch(Excption e1){
	 * 		//异常的信息    e.。。。。。
	 * 		//处理异常的代码
	 * 		}catch(Excption e2){
	 * 		//异常的信息    e.。。。。。
	 * 		//处理异常的代码
	 * 		}.....
	 * 		finally{
	 * 		//不管你有没有异常都会执行finally中的语句块，但是finally语句块不是必须的，可以不写
	 * 		**加了finally语句块，只要try开始执行，即使遇到retrun，finally仍然执行**
	 * 		}
	 * */
	public static void main(String[] args) {
		try{
			Player pla=null;
			System.out.println(pla.getLoginname());
			System.out.println(100/0);
			System.out.println("123");
			return;
		}catch(NullPointerException e){
			//用来告诉我们出现了什么异常，它是爆红的
			//e.printStackTrace();
			System.out.println("出现了空指针异常");
		}catch(ArithmeticException e){
			//用来告诉我们出现了什么异常，它是爆红的
			//e.printStackTrace();
			System.out.println("出现了算术异常");
		}finally{
			System.out.println("不管有没有异常我都会执行");
		}
}

10.5.2 异常的抛出

异常抛出的基本思想：
Java应用程序在运行时如果出现了一个可识别的错误，就会产生一个与该错误相对应的异常类的对象，这个对象包含了异常的类型和错误出现时程序所处的状态信息，这个异常对象首先被交给Java虚拟机，由虚拟机来寻找具体的异常处理者。在Java中把产生异常对象并将其交给Java虚机的过程称为称为异常的抛出。
异常抛出的方式：
1.throws：throws一般出现在方法声明上，代表方法可能出现的异常。throws只是一个声明，告诉方法的调用者，调用该方法时需要处理某种或某几种异常 。真的发生异常时，方法本身可以不处理，而是由方法的调用者处理。throws可以声明多种类型异常。

2.throw：我们只需要创建相应类型的异常对象，然后通过throw（抛出）异常，就能触发一个异常，该种抛出异常的方式比较直接。

示例（throws）：

package com.ambow.test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
 * 处理异常的方式：
 * 		1.try-catch模块（异常的处理）
 * 		2.通过throws关键字来抛出异常（异常的抛出）
 * 
 * */
public class ExcptionDemo2 {
	public static void main(String[] args) {
		SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
		try {
			sf.parse("2018/07/16");
		} catch (ParseException e) {
			// 提示我们异常出现在哪一行
			e.printStackTrace();
			System.out.println("出现了解析异常");
		}
		ExcptionDemo2 ee=new ExcptionDemo2();
		try {
			//调用将异常抛在方法上的方法时，需要抛异常，因为throws只是一个声明
			//throws声明告诉方法调用者，调用该方法是需要处理某种或者多种异常
			ee.method();
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	public void method() throws ParseException{
		SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
		sf.parse("2018/07/16");
	}
}

示例（throw）：

if(age < 0){
throw new Exceptional("年龄不能为负数！");
}

10.5.3 throw和throws的区别

1.throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在住函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。
2.throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通常throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要抛出的异常；如果要捕获throw抛出的异常，则必须使用try{}catch{}语句。

10.5.4 自定义异常

可以通过继承Exception类，创建自定义的异常类型。自定义异常，可以用来处理业务逻辑上的错误，重写getMessage或者其它方法，来设置message属性值，从而设置自定义异常的输出信息。
示例（自定义异常类）：

package com.ambow.test;
/**
 * 1.自定义异常类
 * 2.继承Exception类
 * 3.创建有参构造函数并且调用父类中的有参构造函数
 * */
public class BankException extends Exception {
	public BankException(String message){
		super(message);
	}
}

示例（使用）：

package com.ambow.test;
public class Bank {
	//定义银行卡的余额
	private double blance;
	public double getBlance() {
		return blance;
	}
	public void setBlance(double blance) {
		this.blance = blance;
	}
	//存款方法
	public double add(double money){	
		return this.blance+=money;
	}
	//取款方法
	public double sub(double money) throws BankException{
		if(this.blance-money>=0){
			this.blance-=money;
		}else{
			throw new BankException("余额不足");
		}
		return this.blance;
		
	}
}

示例（测试）：

package com.ambow.test;
public class Test {
	public static void main(String[] args) throws BankException {
		Bank b=new Bank();
		b.setBlance(5000);
		double d=b.add(3000);
		System.out.println("存入3000元以后的余额为："+d);
		d=b.sub(9000);
		System.out.println("取入9000元以后的余额为："+d);
	}
}

示例结果：

说明：通过throw在方法内部抛出一个自定义异常。显示信息，就是Message的内容；方法内部抛出异常后，本身不处理，通过throws声明。方法调用者，同时处理方法的异常

异常
异常的分类
常见异常
异常的处理方式：
捕获 try-catch-finally
抛出 throws
自定义异常 throw

且固执

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
异常的概念，捕获，抛出

可以通过继承Exception类，创建自定义的异常类型。自定义异常，可以用来处理业务逻辑上的错误，重写getMessage或者其它方法，来设置message属性值，从而设置自定义异常的输出信息。/*** 1.自定义异常类* 2.继承Exception类* 3.创建有参构造函数并且调用父类中的有参构造函数} }
复制链接

扫一扫