Java异常架构与异常关键字

Java异常简介

Java异常是Java提供的一种识别及响应错误的一致性机制。

Java异常机制可以使程序中异常处理代码和正常业务代码分离,保证程序代码更加优雅,并提高程序健壮性。在有效使用异常的情况下,异常能清晰的回答what, where, why这3个问题:异常类型回答了“什么”被抛出,异常堆栈跟踪回答了“在哪”抛出,异常信息回答了“为什么”会抛出。

Java异常关键字

• try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。

• catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。

• finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。

• throw – 用于抛出异常。

• throws – 用在方法签名中,用于声明该方法可能抛出的异常。

下面通过几个示例对这几个关键字进行简单了解。

示例一: 了解try和catch基本用法

public class Demo1 {

public static void main(String[] args) {

try {

int i = 10/0;

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

} catch (ArithmeticException e) {

System.out.println("Caught Exception");

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

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

System.out.println("e.printStackTrace():");

e.printStackTrace();

}

}

}

运行结果:

Caught Exception

e.getMessage(): / by zero

e.toString(): java.lang.ArithmeticException: / by zero

e.printStackTrace():

java.lang.ArithmeticException: / by zero

at Demo1.main(Demo1.java:6)

结果说明:在try语句块中有除数为0的操作,该操作会抛出java.lang.ArithmeticException异常。通过catch,对该异常进行捕获。

观察结果我们发现,并没有执行System.out.println(“i=”+i)。这说明try语句块发生异常之后,try语句块中的剩余内容就不会再被执行了。

示例二: 了解finally的基本用法

在"示例一"的基础上,我们添加finally语句。

public class Demo2 {

public static void main(String[] args) {

try {

int i = 10/0;

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

} catch (ArithmeticException e) {

System.out.println("Caught Exception");

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

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

System.out.println("e.printStackTrace():");

e.printStackTrace();

} finally {

System.out.println("run finally");

}

}

}

运行结果:

Caught Exception

e.getMessage(): / by zero

e.toString(): java.lang.ArithmeticException: / by zero

e.printStackTrace():

java.lang.ArithmeticException: / by zero

at Demo2.main(Demo2.java:6)

run finally

结果说明:最终执行了finally语句块。

示例三: 了解throws和throw的基本用法

throws是用于在方法声明抛出的异常,而throw是用于抛出异常。

class MyException extends Exception {

public MyException() {}

public MyException(String msg) {

super(msg);

}

}

public class Demo3 {

public static void main(String[] args) {

try {

test();

} catch (MyException e) {

System.out.println("Catch My Exception");

e.printStackTrace();

}

}

public static void test() throws MyException{

try {

int i = 10/0;

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

} catch (ArithmeticException e) {

throw new MyException("This is MyException");

}

}

}

运行结果:

Catch My Exception

MyException: This is MyException

at Demo3.test(Demo3.java:24)

at Demo3.main(Demo3.java:13)

结果说明:

  MyException是继承于Exception的子类。test()的try语句块中产生ArithmeticException异常(除数为0),并在catch中捕获该异常,接着抛出MyException异常。main()方法对test()中抛出的MyException进行捕获处理。

Java异常架构

1. Throwable

Throwable 是 Java 语言中所有错误与异常的超类。

Throwable 包含两个子类: Error(错误)和 Exception(异常)它们通常用于指示发生了异常情况。

Throwable 包含了其线程创建时线程执行堆栈的快照,它提供了 printStackTrace() 等接口用于获取堆栈跟踪数据等信息。

2. Error(错误)

定义:Error 类及其子类。程序中无法处理的错误,表示运行应用程序中出现了严重的错误。

特点:此类错误一般表示代码运行时 JVM 出现问题。通常有 Virtual MachineError(虚拟机运行错误)、NoClassDefFoundError(类定义错误)等。比如 OutOfMemoryError:内存不足错误;StackOverflowError:栈溢出错误。此类错误发生时,JVM 将终止线程。

这些错误是不受检异常,非代码性错误。因此,当此类错误发生时,应用程序不应该去处理此类错误。按照Java惯例,我们是不应该是实现任何新的Error子类的!

3. Exception(异常)

程序本身可以捕获并且可以处理的异常。Exception 这种异常又分为两类:运行时异常和编译时异常。

3.1 运行时异常

定义:RuntimeException 类极其子类,表示 JVM 在运行期间可能出现的错误。

特点:Java 编译器不会检查它。也就是说,当程序中可能出现这类异常时,倘若既"没有通过throws声明抛出它",也"没有用try-catch语句捕获它",还是会编译通过。比如NullPointerException空指针异常、ArrayIndexOutBoundException数组下标越界异常、ClassCastException类型转换异常、ArithmeticExecption算术异常。此类异常属于不受检异常,一般是由程序逻辑错误引起的,在程序中可以选择捕获处理,也可以不处理。虽然 Java 编译器不会检查运行时异常,但是我们也可以通过 throws 进行声明抛出,也可以通过 try-catch 对它进行捕获处理。如果产生运行时异常,则需要通过修改代码来进行避免。例如,若会发生除数为零的情况,则需要通过代码避免该情况的发生!

RuntimeException 异常会由 Java 虚拟机自动抛出并自动捕获(就算我们没写异常捕获语句运行时也会抛出错误!!),此类异常的出现绝大数情况是代码本身有问题应该从逻辑上去解决并改进代码。

3.2 编译时异常

定义: Exception 中除 RuntimeException 极其子类之外的异常。

特点: Java 编译器会检查它。如果程序中出现此类异常,比如 ClassNotFoundException(没有找到指定的类异常),IOException(IO流异常),要么通过throws进行声明抛出,要么通过try-catch进行捕获处理,否则不能通过编译。在程序中,通常不会自定义该类异常,而是直接使用系统提供的异常类。该异常我们必须手动在代码里添加捕获语句来处理该异常。

4. 受检异常与非受检异常

Java 的所有异常可以分为受检异常(checked exception)和非受检异常(unchecked exception)。

4.1 受检异常

编译器要求必须处理的异常。正确的程序在运行过程中,经常容易出现的、符合预期的异常情况。一旦发生此类异常,就必须采用某种方式进行处理。除 RuntimeException 及其子类外,其他的 Exception 异常都属于受检异常。编译器会检查此类异常,也就是说当编译器检查到应用中的某处可能会此类异常时,将会提示你处理本异常——要么使用try-catch捕获,要么使用方法签名中用 throws 关键字抛出,否则编译不通过。

4.2 非受检异常

编译器不会进行检查并且不要求必须处理的异常,也就说当程序中出现此类异常时,即使我们没有try-catch捕获它,也没有使用throws抛出该异常,编译也会正常通过。该类异常包括运行时异常(RuntimeException极其子类)和错误(Error)。

Throwable:Java中所有的异常都有共同的MT4下载教程父类Throwable(可抛出)。它有两个重要的子类Error(错误)和Exception(异常),这两个子类也包含大量的子类。

Error(错误):是程序代码无法处理的错误。大多数是java运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果出现了这样的错误,除了告知用户,剩下的就是尽力使程序安全的终止。

Exception(异常):是程序代码本身可以处理的异常,对异常处理以后代码不会终止运行。

*  运行异常:都是RuntimeException类及其子类,如NullPointerException(空指针异常),IndexOutOfBoundsException(数组下标越界异常)

该异常特点是Java并不会检查这类异常,就算没有捕捉处理(try catch)或者抛出异常(throws),编译依旧会通过。

*  非运行时异常(编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。这是必须要处理的异常,如果不处理无法通过编译,比如一些强制异常,线程中的异常处理、IO流中的异常处理。

异常处理的关键字:

*    try:里面是可能出现异常的语句或者代码块。后面可以跟一个或多个catch代码段。出现异常,终止try代码段的执行,根据错误的类型找到对应的catch执行。

1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块,但至少有一个块。

2) 必须遵循块顺序:若代码同时使用 catch 和 finally 块,则必须将 catch 块放在 try 块之后。

3) catch 块与相应的异常类的类型相关。

*    catch:出现异常该怎么办 (拿到异常一定做出至少一种处理)

try {

Thread.sleep(1000);

} catch (Exception ef) {

system.out.println("这里最好至少有一种处理方法");

}

*    finally:无论是否产生异常都会执行。一般用于资源的清除工作,比如io流的关闭,jdbc的驱动关闭。

InputStream in = null;

try {

in = new FileInputStream("文件绝对路径");

byte[] bt = new byte[in.available()];

String str = new String(bt);

System.out.print(str);

} catch (FileNotFoundException e) {

e.printStackTrace();

}

catch (IOException e) {

e.printStackTrace();

}finally {

try {

// 关闭流,释放资源

in.close();

} catch (IOException e) {

e.printStackTrace();

}

}

*    throws:用于方法声明时出抛出

*    throw:用于实际手动抛出

如果程序代码try catch处理不了某种异常(比如异常并不是该代码块产生,只有抛出)、不知道如何处理该异常、不想try catch,都可以使用抛出。但是,只要程序不停的调用这个方法,就要不停的抛出。

public static void main(String[] args) throws Exception {

new Test2().demo();

}

public void demo() throws Exception{

int x = 1;

if(x == 1)

throw new Exception("手动抛出异常");

}

自定义异常类:

1.通过继承Exception类声明自己的异常类

2.在方法适当的位置,生成自定义异常的实例,并用throw抛出

3.在方法声明部分用throws语句声明该方法可能抛出异常

public class MyException extends Exception{

public MyException() {

System.out.println("我的异常类");

}

}

---------------------------------------------------

public class MyException2 {

static int a;

public static void main(String[] args) throws MyException {

a = 4;

new MyException2().test();

}

public void test() throws MyException{

if(a<10)

throw new MyException();

}

}

原文地址:https://www.cnblogs.com/benming/p/11611989.html

时间: 2024-10-12 17:23:34

Java异常架构与异常关键字的相关文章

java异常架构图 和几个面试题

1.java异常架构图 粉红色的是受检查的异常(checked exceptions),其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.受检查的异常必须在编译时被捕捉处理,命名为 CHecked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守.绿色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如 空指针,被0除...而声明为Error的,则属于严

JAVA异常架构图及面试题

红色为检查异常,就是eclipse要提示你是try catch 还是throws. 非检查异常,就是/0,nullpointexception,数据越界访问indexOfOutBounds 异常 错误: 最常见的oom错误,还有classnotFoundeError,StackOverflowError : java异常处理面试题归纳 1.error和exception有什么区别 error表示系统级的错误,是java运行环境内部错误或者硬件问题,不能指望程序来处理这样的问题,除了退出运行外别无

JAVA异常架构图及常见面试题

红色为检查异常,就是eclipse要提示你是try catch 还是throws. 非检查异常,就是/0,nullpointexception,数据越界访问indexOfOutBounds 异常 错误: 最常见的oom错误,还有classnotFoundeError,StackOverflowError : java异常处理面试题归纳 1.error和exception有什么区别 error表示系统级的错误,是java运行环境内部错误或者硬件问题,不能指望程序来处理这样的问题,除了退出运行外别无

Java核心API -- 9(异常)

异常处理 异常结构中的父类Throwable类,其下子类Exceptionlei类和Error类.我们在程序中可以捕获的是Exception的子类异常. Error系统级别的错误:Java运行时环境出现的错误,我们不可控. Exception是程序级别的错误:我们可控. 1)捕获异常两种方式: 一是添加try-catch捕获该异常,二是在我们的方法中声明出也追加这种异常的抛出(继续往外抛). 2)异常处理语句:try-catch,如果try块捕获到异常,则到catch块中处理,否则跳过忽略cat

java的两种异常runtimeException和checkedException

java异常处理机制主要依赖于try,catch,finally,throw,throws五个关键字. try 关键字后紧跟一个花括号括起来的代码块,简称try块.同理:下面的也被称为相应的块. 它里面可置引发异常的代码.catch后对应异常类型和一个代码块,用于表明catch块用于处理这种类型的代码块.后还可以跟一个finally块,finally块用于回收在try块里打开的物理资源,异常机制会保证finally块总被执行.throws关键字主要在方法签名中使用,用于声明该方法可能抛出的异常,

java学习中,异常和错误的简介、捕获异常、抛出异常、自定义异常(java 学习中的小记录)

java学习中,异常和错误的简介.捕获异常.抛出异常.自定义异常(java 学习中的小记录)作者:王可利(Star·星星) 异常:(API 的 java.lang 有一个异常,有很多很多) 在Java程序中也会程序出现不正常的情况,这个就叫异常.     Java是面向对象的语言,任何事物都可以用类来描述,同样的异常也是一种事物.Java中提供了很多的异常类.     多个异常堆积起来,就是一个异常体系.   Throwable:是异常类的父类,超类.Exception 异常.error错误.

【Java基础】05_异常&amp;File

一.异常引言 程序出现的不正常的情况.异常就是Java程序在运行过程中出现的错误. 问题也是现实生活中一个具体事物,也可以通过java 的类的形式进行描述,并封装成对象.其实异常就是Java对不正常情况进行描述后的对象体现. 二.异常继承体系图解 三.异常的体系 java.lang.Throwable类 |--Error    严重问题,我们不处理.要改正代码. 通常出现重大问题如:运行的类不存在或者内存溢出等.是不需要增加代码处理(try...catch)的.代码本身有问题. 一般这种情况是需

Java学习笔记之异常

//概述 /* 异常: 是在运行时期发生的不正常情况.. 在java中用类的形式对不正常情况进行了描述和封装对象. 描述不正常的情况的类, 就称为异常类. 以前正常流程代码和问题处理代码相结合, 现在将正常流程代码和问题处理代码分离, 提高阅读性. 其实异常就是java通过面向对象的思想将问题封装成了对象. 用异常类对其进行描述. 不同的问题用不同的类进行具体的描述. 问题很多, 意味着描述的类也很多. 将其共性进行向上抽取,形成了异常体系. 最终问题(不正常情况)就分成了两大类 Throwab

Java深入理解之异常

Java的基本理念是"结构不佳的代码不能运行" 为什么要使用异常? 首先我们可以明确一点就是异常的处理机制可以确保我们程序的健壮性,提高系统可用率 .异常不是程序语法错误,异常,就是在正常语法的代码运行过程中出现如 一楼所说的情况,如果不进行异常处理,那程序直接结束了,之所以捕获异常,是让你可以有发生错误补救的机会. 异常定义:异常情形是指阻止当前方法或者作用域继续执行的问题.在这里一定要明确一点:异常代码某种程度的错误,尽管Java有异常处理机制,但是我们不能以"正常&qu