JavaSE（基础篇）——异常机制

最新推荐文章于 2024-05-19 18:51:10 发布

2401_84103844

最新推荐文章于 2024-05-19 18:51:10 发布

阅读量258

点赞数 4

分类专栏：程序员文章标签： java 开发语言

本文链接：https://blog.csdn.net/2401_84103844/article/details/138296906

版权

程序员专栏收录该内容

223 篇文章 0 订阅

订阅专栏

int a = 1; int b = 0;

try {

// try监控区域

if (b == 0) throw new ArithmeticException();

// 通过throw语句抛出异常

System.out.println(“a/b的值是：” + a / b);

System.out.println(“this will not be printed!”);

}catch (ArithmeticException e) {

// catch捕捉异常

System.out.println(“程序出现异常，变量b不能为0！”);

}

System.out.println(“程序正常结束。”);

}

//输出

程序出现异常，变量b不能为0！

程序正常结束。

注意：显示一个异常的描述， Throwable 重载了 toString() 方法（由 Object 定义），所以它将返回一个包含异常描述的字符串。例如，将前面的 catch 块重写成：

catch (ArithmeticException e) {

// catch捕捉异常

System.out.println(“程序出现异常”+e);

}

//输出程序出现异常java.lang.ArithmeticException

程序正常结束。

算数异常属于运行时异常，因而实际上该异常不需要程序抛出，运行时系统自动抛出。如果不用try-catch程序就不会往下执行了。

public class TestException {

public static void main(String[] args) {

int a = 1; int b = 0;

System.out.println(“a/b的值是：” + a / b);

System.out.println(“this will not be printed!”);

}

结果： Exception in thread “main” java.lang.ArithmeticException: / by zero

at TestException.main(TestException.java:7)

使用多重的catch****语句：很多情况下，由单个的代码段可能引起多个异常。处理这种情况，我们需要定义两个或者更多的 catch 子句，每个子句捕获一种类型的异常，当异常被引发时，每个 catch 子句被依次检查，第一个匹配异常类型的子句执行，当一个 catch 子句执行以后，其他的子句将被旁路。

编写多重catch语句块注意事项：

**顺序问题：**先小后大，即先子类后父类

注意：

Java通过异常类描述异常类型。对于有多个 catch 子句的异常程序而言，应该尽量将捕获底层异常类的 catch 子句放在前面，同时尽量将捕获相对高层的异常类的 catch 子句放在后面。否则，捕获底层异常类的 catch 子句将可能会被屏蔽。

**嵌套 try 语句：**try 语句可以被嵌套。也就是说，一个 try 语句可以在另一个 try 块的内部。每次进入 try 语句，异常的前后关系都会被推入堆栈。如果一个内部的 try 语句不含特殊异常的catch 处理程序，堆栈将弹出，下一个 try 语句的 catch 处理程序将检查是否与之匹配。这个过程将继续直到一个 catch 语句被匹配成功，或者是直到所有的嵌套 try 语句被检查完毕。如果没有 catch 语句匹配，Java运行时系统将处理这个异常。

class NestTry{

public static void main(String[] args){

try{

int a = args.length;

int b = 42 / a;

System.out.println("a = "+ a);

try{if(a == 1){

a = a/(a-a);

}

if(a == 2){

int c[] = {1};

c[42] =99;

}

}catch(ArrayIndexOutOfBoundsException e){

System.out.println(“ArrayIndexOutOfBounds :”+e);

}

}catch(ArithmeticException e){

System.out.println(“Divide by 0”+ e);

}

//分析运行：

D:\java>java NestTry one

a = 1

Divide by 0java.lang.ArithmeticException: / by zero D:\java>java NestTry one two

a = 2

ArrayIndexOutOfBounds :java.lang.ArrayIndexOutOfBoundsException: 42

分析：正如程序中所显示的，该程序在一个try块中嵌套了另一个 try 块。程序工作如下：当你在没有命令行参数的情况下执行该程序，外面的 try 块将产生一个被0除的异常。

程序在有一个命令行参数条件下执行，由嵌套的 try 块产生一个被0除的异常，由于内部的 catch 块不匹配这个异常，它将把异常传给外部的 try 块，在外部异常被处理。如果你在具有两个命令行参数的条件下执行该程序，将由内部 try 块产生一个数组边界异常。

注意：当有方法调用时， try 语句的嵌套可以很隐蔽的发生。例如，我们可以将对方法的调用放在一个 try 块中。在该方法的内部，有另一个 try 语句。

在这种情况下，方法内部的 try 仍然是嵌套在外部调用该方法的 try 块中的。下面我们将对上述例子进行修改，嵌套的 try 块移到方法nesttry()的内部：结果依旧相同！

class NestTry{

static void nesttry(int a){

try{if(a == 1){

a = a/(a-a);

}

if(a == 2){

int c[] = {1};

c[42] =99;

}

}catch(ArrayIndexOutOfBoundsException e){

System.out.println(“ArrayIndexOutOfBounds :”+e);

}

public static void main(String[] args){

try{

int a = args.length;

int b = 42 / a;

System.out.println("a = "+ a);

nesttry(a); }catch(ArithmeticException e){

System.out.println(“Divide by 0”+ e);

}

2.throw

到目前为止，我们只是获取了被Java运行时系统引发的异常。然而，我们还可以用 throw 语句抛出明确的异常。

语法形式：

throw ThrowableInstance;

这里的ThrowableInstance一定是 Throwable 类类型或者 Throwable 子类类型的一个对象。简单的数据类型，例如 int ， char ,以及非 Throwable 类，例如 String 或 Object ，不能用作异常。

有两种方法可以获取 Throwable 对象：在 catch 子句中使用参数或者使用 new 操作符创建。程序执行完 throw 语句之后立即停止； throw 后面的任何语句不被执行，最邻近的 try 块用来检查它是否含有一个与异常类型匹配的 catch 语句。

如果发现了匹配的块，控制转向该语句；如果没有发现，次包围的 try 块来检查，以此类推。如果没有发现匹配的 catch 块，默认异常处理程序中断程序的执行并且打印堆栈轨迹。

class TestThrow{

static void proc(){

try{

throw new NullPointerException(“demo”);

}catch(NullPointerException e){

System.out.println(“Caught inside proc”);

throw e;

}

public static void main(String [] args){

try{proc();

}catch(NullPointerException e){

System.out.println("Recaught: "+e);

}

该程序两次处理相同的错误，首先， main() 方法设立了一个异常关系然后调用proc()。proc()方法设立了另一个异常处理关系并且立即抛出一个 NullPointerException 实例，NullPointerException 在 main() 中被再次捕获。

该程序阐述了怎样创建Java的标准异常对象，特别注意这一行：

throw new NullPointerException(“demo”);

分析：此处 new 用来构造一个 NullPointerException 实例，所有的Java内置的运行时异常有两

个构造方法：一个没有参数，一个带有一个字符串参数。

当用第二种形式时，参数指定描述异常的字符串。如果对象用作 print() 或者 println() 的参数时，该字符串被显示。这同样可以通过调用getMessage()来实现，getMessage()是由 Throwable 定义的。

3.throws

如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常。要做到这点，我们可以在方法声明中包含一个 throws 子句。

一个throws 子句列举了一个方法可能引发的所有异常类型。这对于除了 Error 或RuntimeException 及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他类型的异常必须在 throws 子句中声明，否则会导致编译错误。

public void info() throws Exception {

//body of method

}

Exception是该方法可能引发的所有的异常,也可以是异常列表，中间以逗号隔开。

【例子】

class TestThrows{

static void throw1(){

System.out.println("Inside throw1 . ");

throw new IllegalAccessException(“demo”);

}

public static void main(String[] args){ throw1();

}

该例子中存在两个错误，首先，throw1()方法不想处理所导致的异常，因而它必须声明 throws 子句来列举可能引发的异常即 IllegalAccessException ；其次， main() 方法必须定义try/catch 语句来捕获该异常。

正确例子如下：

class TestThrows{

static void throw1() throws IllegalAccessException {

System.out.println("Inside throw1 . ");

throw new IllegalAccessException(“demo”);

}

public static void main(String[] args){

try {

throw1();

}catch(IllegalAccessException e ){

System.out.println("Caught " + e);

}

throws抛出异常规则

1.如果是不受检查异常（ unchecked exception ），即 Error 、 RuntimeException 或它们的子类，那么可以不使用 throws 关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

2.必须声明方法可抛出的任何检查异常（ checked exception ）。即如果一个方法可能出现受可查异常，要么用 try-catch 语句捕获，要么用 throws 子句声明将它抛出，否则会导致编译错误。

3.仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

4.调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

4.finally

当异常发生时，通常方法的执行将做一个陡峭的非线性的转向，它甚至会过早的导致方法返回。例如，如果一个方法打开了一个文件并关闭，然后退出，你不希望关闭文件的代码被异常处理机制旁路。finally 关键字为处理这种意外而设计。

finally创建的代码块在 try/catch 块完成之后另一个 try/catch 出现之前执行。

finally块无论有没有异常抛出都会执行。如果抛出异常，即使没有 catch 子句匹配，finally 也会执行。

一个方法将从一个 try/catch 块返回到调用程序的任何时候，经过一个未捕获的异常或者是一个明确的返回语句， finally 子句在方法返回之前仍将执行。这在关闭文件句柄和释放任何在方法开始时被分配的其他资源是很有用。

注意：finally 子句是可选项，可以有也可以无，但是每个 try 语句至少需要一个 catch 或者 finally 子句。

【例子】

class TestFinally{

static void proc1(){

try{System.out.println(“inside proc1”);

throw new RuntimeException(“demo”);

}finally{

System.out.println(“proc1’s finally”);

}

static void proc2(){

try{System.out.println(“inside proc2”);

return ;

} finally{

System.out.println(“proc2’s finally”);

}

static void proc3(){

try{

System.out.println(“inside proc3”);

}finally{

System.out.println(“proc3’s finally”);

}

public static void main(String [] args){

try{

proc1();

}catch(Exception e){

System.out.println(“Exception caught”);

}

proc2();

proc3();

}

最后我们该如何学习？

1、看视频进行系统学习

这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。

另外，我自己也珍藏了好几套视频资料躺在网盘里，有需要的我也可以分享给你：