疯狂Java讲义_Chapter10异常处理

最新推荐文章于 2023-12-28 10:30:10 发布
最新推荐文章于 2023-12-28 10:30:10 发布
阅读量146 收藏
点赞数
分类专栏： JavaBasic笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39919527/article/details/111509253
版权

1.异常概述

  • Java的异常机制主要依赖于try, catch, finally, throw, throws五个关键字；
  • try块中放置可能引发异常的代码；
  • catch块中放置处理异常的代码；
  • finally块用于回收在try块中打开的物理资源，异常机制保证finally块总被执行；
  • throws用于声明该方法可能抛出的异常；
  • throw用于抛出一个实际异常；

2.异常处理机制

1.使用try-catch捕获异常

  • 异常处理过程：
  1. 抛出异常：try块中的代码出现异常，系统生成异常对象；
  2. 捕获异常：Java环境收到异常对象，在catch中寻找对应对象的解决办法；

import java.io.*;

public class Gobang
{
	// 定义一个二维数组来充当棋盘
	private String[][] board;
	// 定义棋盘的大小
	private static int BOARD_SIZE = 15;
	public void initBoard()
	{
		// 初始化棋盘数组
		board = new String[BOARD_SIZE][BOARD_SIZE];
		// 把每个元素赋为"╋"，用于在控制台画出棋盘
		for (var i = 0; i < BOARD_SIZE; i++)
		{
			for (var j = 0; j < BOARD_SIZE; j++)
			{
				board[i][j] = "╋";
			}
		}
	}
	// 在控制台输出棋盘的方法
	public void printBoard()
	{
		// 打印每个数组元素
		for (var i = 0; i < BOARD_SIZE; i++)
		{
			for (var j = 0; j < BOARD_SIZE; j++)
			{
				// 打印数组元素后不换行
				System.out.print(board[i][j]);
			}
			// 每打印完一行数组元素后输出一个换行符
			System.out.print("\n");
		}
	}
	public static void main(String[] args) throws Exception
	{
		var gb = new Gobang();
		gb.initBoard();
		gb.printBoard();
		// 这是用于获取键盘输入的方法
		var br = new BufferedReader(
			new InputStreamReader(System.in));
		String inputStr = null;
		// br.readLine()：每当在键盘上输入一行内容按回车，
		// 用户刚刚输入的内容将被br读取到。
		while ((inputStr = br.readLine()) != null)
		{
			try
			{
				// 将用户输入的字符串以逗号作为分隔符，分解成2个字符串
				String[] posStrArr = inputStr.split(",");
				// 将2个字符串转换成用户下棋的坐标
				var xPos = Integer.parseInt(posStrArr[0]);
				var yPos = Integer.parseInt(posStrArr[1]);
				// 把对应的数组元素赋为"●"。
				if (!gb.board[xPos - 1][yPos - 1].equals("╋"))
				{
					System.out.println("您输入的坐标点已有棋子了，"
						+ "请重新输入");
					continue;
				}
				gb.board[xPos - 1][yPos - 1] = "●";
			}
			catch (Exception e)
			{
				System.out.println("您输入的坐标不合法，请重新输入，"
					+ "下棋坐标应以x,y的格式");
				continue;
			}

			gb.printBoard();
			System.out.println("请输入您下棋的坐标，应以x,y的格式：");
		}
	}
}
  •  try块一般放在方法体里面，保证方法执行过程中的容错性；

2.异常类的继承体系

  • try-catch块的｛｝不可省略；
  • Java的异常类的总接口为Throwable，Error类和Exception类实现了这一接口；
  • error一般是虚拟机错误、系统崩溃等问题，不需要程序捕获；
  • 不同exception子类对应的try-catch
public class DivTest
{
	public static void main(String[] args)
	{
		try
		{
			var a = Integer.parseInt(args[0]);
			var b = Integer.parseInt(args[1]);
			var c = a / b;
			System.out.println("您输入的两个数相除的结果是：" + c );
		}
		catch (IndexOutOfBoundsException ie)
		{
			System.out.println("数组越界：运行程序时输入的参数个数不够");
		}
		catch (NumberFormatException ne)
		{
			System.out.println("数字格式异常：程序只能接受整数参数");
		}
		catch (ArithmeticException ae)
		{
			System.out.println("算术异常");
		}
		catch (Exception e)
		{
			System.out.println("未知异常");
		}
	}
}


import java.util.*;

public class NullTest
{
	public static void main(String[] args)
	{
		Date d = null;
		try
		{
			System.out.println(d.after(new Date()));
		}
		catch (NullPointerException ne)
		{
			System.out.println("空指针异常");
		}
		catch (Exception e)
		{
			System.out.println("未知异常");
		}
	}
}
  •  一般要把小异常放在前面，exception异常放在最后，这是因为程序要先处理对应的小异常，没有办法了才用exception对象处理；
try
{....}
catch
{IOException e1}
catch
{Exception e2}

3.多异常捕获

  • 从Java7开始，一个catch块可以捕获多种类型的异常；

public class MultiExceptionTest
{
	public static void main(String[] args)
	{
		try
		{
			var a = Integer.parseInt(args[0]);
			var b = Integer.parseInt(args[1]);
			var c = a / b;
			System.out.println("您输入的两个数相除的结果是：" + c );
		}
		catch (IndexOutOfBoundsException|NumberFormatException
			|ArithmeticException ie)
		{
			System.out.println("程序发生了数组越界、数字格式异常、算术异常之一");
			// 捕捉多异常时，异常变量默认有final修饰，
			// 所以下面代码有错：
//			ie = new ArithmeticException("test");  // ①
		}
		catch (Exception e)
		{
			System.out.println("未知异常");
			// 捕捉一个类型的异常时，异常变量没有final修饰
			// 所以下面代码完全正确。
			e = new RuntimeException("test");    // ②
		}
	}
}

4.访问异常信息

  • 访问catch块中的异常信息的方法：
  1. getMessage()：返回该异常的详细描述字符串；
  2. printStackTrace()：将该异常的跟踪栈信息输出到标准错误输出；
  3. printStackTrace(PrintStream p)：将异常跟踪信息输出到指定流；
  4. getStackTrace()：返回该异常的跟踪栈信息；

import java.io.*;

public class AccessExceptionMsg
{
	public static void main(String[] args)
	{
		try
		{
			var fis = new FileInputStream("a.txt");
		}
		catch (IOException ioe)
		{
			System.out.println(ioe.getMessage());
			ioe.printStackTrace();
		}
	}
}

5.使用finally回收资源

  • Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只能回收堆内存中对象所占用的内存；
  • finally块的作用就是回收物理资源的，不论try块中的代码是否出错，finally块总会执行；
  • catch块和finally块至少出现其一；

import java.io.*;

public class FinallyTest
{
	public static void main(String[] args)
	{
		FileInputStream fis = null;
		try
		{
			fis = new FileInputStream("a.txt");
		}
		catch (IOException ioe)
		{
			System.out.println(ioe.getMessage());
			// return语句强制方法返回
			return;       // ①
			// 使用exit来退出虚拟机
			// System.exit(1);     // ②
		}
		finally
		{
			// 关闭磁盘文件，回收资源
			if (fis != null)
			{
				try
				{
					fis.close();
				}
				catch (IOException ioe)
				{
					ioe.printStackTrace();
				}
			}
			System.out.println("执行finally块里的资源回收!");
		}
	}
}

 

6.异常处理的嵌套

7.Java9增强的自动关闭资源的try块

  • java7增强了try语句的功能——它允许在try关键字后紧跟一对圆括号，圆括号内可以初始化一个或多个资源（物理资源），try语句在该语句结束时自动关闭资源；
  • 自动关闭资源的try语句相当于包含了隐式的finally块，因此这个语句可以没有catch和finally；
  • Java7把所有的资源类都进行了改写，改写后的资源类都实现了AutoCloseable或者Closeable接口；
import java.io.*;

public class AutoCloseTest2
{
	public static void main(String[] args)
		throws IOException
	{
		// 有final修饰的资源
		final var br = new BufferedReader(
			new FileReader("AutoCloseTest.java"));
		// 没有显式使用final修饰，但只要不对该变量重新赋值，按该变量就是有效的final
		var ps = new PrintStream(new
			FileOutputStream("a.txt"));
		// 只要将两个资源放在try后的圆括号内即可
		try (br; ps)
		{
			// 使用两个资源
			System.out.println(br.readLine());
			ps.println("庄生晓梦迷蝴蝶");
		}
	}
}

 

3.Checked异常和Runtime异常

  • java的异常分为checked异常和Runtime异常，其中checked异常必须显式指定解决办法；
  • checked异常的解决方法：
  1. 使用try-catch块解决；
  2. 如果不知道如何解决，就只能声明抛出异常；
  • throws将异常抛出给上一级处理，上一级无法处理的话交给JVM处理，一般出现要抛出的异常，程序就会终止，并在JVM中打印出异常信息；

4.使用throw抛出异常

1.抛出异常

  • 如果程序中的数据、执行与既定的业务需求不符，这就是一种异常；由于业务抛出的异常，必须由程序员自行决定是否抛出；
  • throw抛出的不是异常类，是异常实例
public class ThrowTest
{
	public static void main(String[] args)
	{
		try
		{
			// 调用声明抛出Checked异常的方法，要么显式捕获该异常
			// 要么在main方法中再次声明抛出
			throwChecked(-3);
		}
		catch (Exception e)
		{
			System.out.println(e.getMessage());
		}
		// 调用声明抛出Runtime异常的方法既可以显式捕获该异常，
		// 也可不理会该异常
		throwRuntime(3);
	}
	public static void throwChecked(int a) throws Exception
	{
		if (a > 0)
		{
			// 自行抛出Exception异常
			// 该代码必须处于try块里，或处于带throws声明的方法中
			throw new Exception("a的值大于0，不符合要求");
		}
	}
	public static void throwRuntime(int a)
	{
		if (a > 0)
		{
			// 自行抛出RuntimeException异常，既可以显式捕获该异常
			// 也可完全不理会该异常，把该异常交给该方法调用者处理
			throw new RuntimeException("a的值大于0，不符合要求");
		}
	}
}

 

2.自定义异常类

  • 用户自定义异常都应该继承Exception基类；定义异常类要提供两个构造器：1是无参构造器；2是带一个字符串参数的构造器，该字符串将作为该异常对象的描述信息：

public class AuctionException extends Exception
{
	// 无参数的构造器
	public AuctionException(){}       // ①
	// 带一个字符串参数的构造器
	public AuctionException(String msg)    // ②
	{
		super(msg);
	}
}

3.catch和throw同时使用

  • catch和throw同时使用程序：
public class AuctionTest
{
	private double initPrice = 30.0;
	// 因为该方法中显式抛出了AuctionException异常，
	// 所以此处需要声明抛出AuctionException异常
	public void bid(String bidPrice)
		throws AuctionException
	{
		var d = 0.0;
		try
		{
			d = Double.parseDouble(bidPrice);
		}
		catch (Exception e)
		{
			// 此处完成本方法中可以对异常执行的修复处理，
			// 此处仅仅是在控制台打印异常跟踪栈信息。
			e.printStackTrace();
			// 再次抛出自定义异常
			throw new AuctionException("竞拍价必须是数值，"
				+ "不能包含其他字符！");
		}
		if (initPrice > d)
		{
			throw new AuctionException("竞拍价比起拍价低，"
				+ "不允许竞拍！");
		}
		initPrice = d;
	}
	public static void main(String[] args)
	{
		var at = new AuctionTest();
		try
		{
			at.bid("df");
		}
		catch (AuctionException ae)
		{
			// 再次捕捉到bid方法中的异常。并对该异常进行处理
			System.err.println(ae.getMessage());
		}
	}
}

 

4.使用throw语句抛出异常​​​​​​​（387）

5.异常链

  • 异常转译：程序捕获原始异常，抛出一个业务异常，其中包含了对异常的提示信息；这种行为也被称为异常链：
public static void main(String[] args)
{
    try
     {
        ...
         }
    catch
     {
        ...//原始异常信息
        throw new SalException("自定义异常");    //向客户展示的是无关于系统的异常
        }
  }
public class SalException extends Exception
{
	public SalException(){}
	public SalException(String msg)
	{
		super(msg);
	}
	
}

 

5.Java的异常跟踪栈

  • 异常对象的printStackTrace()用于打印异常的跟踪信息

6.异常处理规则​​​​​​​(391)

  1. 不要使用过于庞大的try块；
  2. 不要忽略捕获的异常；
  3. 不要过度使用异常；

​​​​​​​

 

工程师学徒AYG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JAVA 自定义异常 Exception
09-07
Exception JAVA 自定义异常 Exception JAVA 自定义异常 Exception
Controller 层返回值的公共包装类-避免每次都包装一次返回-InitializingBean增强
热门推荐
hu10131013的博客
09-07 10万+
场景：在微服务中，一般返回数据都会有个返回码、返回信息和返回消息体，但是每次返回时候调用或者是封装，太过麻烦，有没有什么办法不用每次都封装呢？ 答案是有的。 返回值对象 package com.study.auth.comm; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.annotation.JSONField; import com.alibaba.fastjson.serializer.Serialize..
【Java异常体系】（一）异常体系之SQLException解析...
Technology changes the world of life
05-24 7778
Java异常体系详解之SQLException
python try catch
weixin_45959515的博客
07-22 3万+
try : print(1 / 0) except Exception as e : print(e) finally : print('最后执行')
异常
weixin_44772874的博客
10-06 265
异常 异常指的就是程序在运行时出现错误时通知调用者的一种机制（运行时指的是程序已经编译通过得到 class 文件了，再由 JVM 执行过程中出现的错误） try{ 有可能出现异常的语句； // 发生异常的代码，之后的代码是不会执行的 }[catch(异常类型 异常对象){ 出现异常后的处理行为； //e.printStackTrace(); 打印异常的信息 }][finally{ 异常的出口（用于处理善后工作, 会在最后执行(无论是否存在异常, finally中的代码一定都会执行到)） //
codes_java_疯狂java讲义源码_principler6q_elevenfza_
09-29
疯狂java讲义源码，解压即用，各个章节的都有，注意编码格式，否则乱码。
疯狂JAVA讲义_.pdf
07-02
疯狂JAVA讲义_part pdf
疯狂java讲义_第2版
07-11
第2 版的Java讲义和第三版也差不多，用来入门的学习已经很不错啦，分享给大家
疯狂JAVA讲义光盘资料.zip
03-05
疯狂JAVA讲义光盘资料.zip
疯狂Java讲义_示例代码
10-26
疯狂Java讲义_示例代码
SQLException（SQL异常）可能的原因和解决方法
最新发布
Java开源程序猿
12-28 7426
时，可以根据具体情况选择合适的处理方式，可能包括记录错误日志、回滚事务、重新尝试操作等。对于连接、事务和资源的管理要及时释放以避免资源泄漏。确保在数据库操作中进行适当的异常处理，根据异常的类型采取相应的处理措施。详细的错误日志和异常堆栈信息对于定位和解决问题非常有帮助。是在 Java 中处理数据库操作过程中可能发生的异常，通常是由于底层数据库操作错误或违反了数据库规则而引起的。
【Java】异常 try-catch throw 详解
这很宇航的博客
06-05 2198
【Java】异常 try-catch throw 详解
C++异常(try、throw、catch) 快速掌握
qq_33269219的博客
12-27 1103
一文快速掌握C++异常机制（try throw catch noexcept）
【已解决】：java.sql.SQLException 问题
04-21 4万+
【已完美解决】：java.sql.SQLException 问题
chatgpt赋能python：Python主动抛出异常详解：了解如何正确地处理异常
laingziwei的博客
06-10 1330
在Python中，异常是一个事件，它在程序执行期间发生，中断了正常的程序流程。异常通常表示错误或者不期望的结果，比如除以零、打开不存在的文件等。当Python解释器遇到异常时，会尝试寻找相应的异常处理代码并执行，如果找不到，程序将会终止。在Python中，所有的异常都是从Exception类派生而来的。我们可以根据自己的需求定义新的异常类，并且使用raise语句手动抛出异常。除了标准异常类型，我们也可以定义自己的异常类型。我们可以通过继承Exception类来创建我们自己的异常类。
异常处理（throw、throws、try-catch）
wardo_l的博客
02-25 1382
Java异常处理的五个关键字try、catch、finally、throw、throws 1.抛出异常throw 在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接收参数。那么，当调用方法使用接收到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。 在Java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？ 1.创建一个异常对象，封装一些
try,catch,throw
ayw_hehe的专栏
09-26 1182
<br />转自http://hi.baidu.com/sicceer/blog/item/866f867eb19bce340cd7dac0.html<br />要防止因为异常产生的内存泄漏，可以使用智能指针，也可以用 <br />__try <br />{ <br />} <br />__finally <br />{ <br />} <br />《Windows核心编程》一书第23~25章是很好的参考资料。<br />-------------------------------------------
Python 异常捕获
weixin_64476458的博客
02-19 6816
python 的异常捕获通常用 try…except…结构 把可能发生错误的语句放在 try 模块里，用 except 来处理异常，会让系统不会直接报错，而是给你具体另一种选项吧。 举个例子 首先将try注释并执行 然后我在输入数字：你好 正常情况下，系统就会自动报错， 提示传入无效的参数 而当我使用try异常捕获时 他就会在错误时给你另一个结果 提示你请输入正确的数字 注意代码格式 try: # 提示用户输入一个数字 # 不能确定正确执行的代码 ...
java疯狂讲义 第三版
08-31
此外，还探讨了Java中的异常处理、线程编程、集合框架以及IO操作等高级主题。 《Java疯狂讲义》第三版的特点是内容简明扼要，通俗易懂，适合初学者入门。书中的示例代码丰富，有助于读者通过实践加深对Java编程的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值