JAVA异常
第10章异常处理
本章介绍Java的异常处理机制。异常(exception)是在运行时代码序列中产生一种异常情况。换句话说，异常是一个运行时错误。在不支持异常处理的计算机语言中，错误必须被手工的检查和处理——典型的是通过错误代码的运用等等。这种方法既很笨拙也很麻烦。Java的异常处理避免了这些问题，而且在处理过程中，把运行时错误的管理带到了面向对象的世界。
10.1 异常处理基础
Java异常是一个描述在代码段中发生的异常（也就是出错）情况的对象。当异常情况发生，一个代表该异常的对象被创建并且在导致该错误的方法中被引发（throw）。该方法可以选择自己处理异常或传递该异常。两种情况下，该异常被捕获（caught）并处理。异常可能是由Java运行时系统产生，或者是由你的手工代码产生。被Java引发的异常与违反语言规范或超出Java执行环境限制的基本错误有关。手工编码产生的异常基本上用于报告方法调用程序的出错状况。
Java异常处理通过5个关键字控制：try、catch、throw、throws和 finally。下面讲述它们如何工作的。程序声明了你想要的异常监控包含在一个try块中。如果在try块中发生异常，它被抛出。你的代码可以捕捉这个异常（用catch）并且用某种合理的方法处理该异常。系统产生的异常被Java运行时系统自动引发。手动引发一个异常，用关键字throw。任何被引发方法的异常都必须通过throws子句定义。任何在方法返回前绝对被执行的代码被放置在finally块中。
下面是一个异常处理块的通常形式：
try {
// block of code to monitor for errors
}
catch (ExceptionType1 exOb) {
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb) {
// exception handler for ExceptionType2
}
// ...
finally {
// block of code to be executed before try block ends
}
这里，ExceptionType 是发生异常的类型。下面将介绍怎样应用这个框架。
第10章异常处理 177
10.2 异常类型
所有异常类型都是内置类Throwable的子类。因此，Throwable在异常类层次结构的顶
层。紧接着Throwable下面的是两个把异常分成两个不同分支的子类。一个分支是Exception。
该类用于用户程序可能捕捉的异常情况。它也是你可以用来创建你自己用户异常类型子类
的类。在Exception分支中有一个重要子类RuntimeException。该类型的异常自动为你所编写
的程序定义并且包括被零除和非法数组索引这样的错误。
另一类分支由Error作为顶层，Error定义了在通常环境下不希望被程序捕获的异常。
Error类型的异常用于Java运行时系统来显示与运行时系统本身有关的错误。堆栈溢出是这
种错误的一例。本章将不讨论关于Error类型的异常处理，因为它们通常是灾难性的致命错
误，不是你的程序可以控制的。
10.3 未被捕获的异常
在你学习在程序中处理异常之前，看一看如果你不处理它们会有什么情况发生是很有
好处的。下面的小程序包括一个故意导致被零除错误的表达式。
class Exc0 {
public static void main(String args[]) {
int d = 0;
int a = 42 / d;
}
}
当Java运行时系统检查到被零除的情况，它构造一个新的异常对象然后引发该异常。
这导致Exc0的执行停止，因为一旦一个异常被引发，它必须被一个异常处理程序捕获并且
被立即处理。该例中，我们没有提供任何我们自己的异常处理程序，所以异常被Java运行
时系统的默认处理程序捕获。任何不是被你程序捕获的异常最终都会被该默认处理程序处
理。默认处理程序显示一个描述异常的字符串，打印异常发生处的堆栈轨迹并且终止程序。
下面是由标准javaJDK运行时解释器执行该程序所产生的输出：
https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero
at Exc0.main(Exc0.java:4)
注意，类名Exc0，方法名main，文件名Exc0.java和行数4是怎样被包括在一个简单的堆
栈使用轨迹中的。还有，注意引发的异常类型是Exception的一个名为ArithmeticException
的子类，该子类更明确的描述了何种类型的错误方法。本章后面部分将讨论，Java提供多
个内置的与可能产生的不同种类运行时错误相匹配的异常类型。
堆栈轨迹将显示导致错误产生的方法调用序列。例如，下面是前面程序的另一个版本，
它介绍了相同的错误，但是错误是在main( )方法之外的另一个方法中产生的：
class Exc1 {
178 第1部分 Java语言
static void subroutine() {
int d = 0;
int a = 10 / d;
}
public static void main(String args[]) {
Exc1.subroutine();
}
}
默认异常处理器的堆栈轨迹结果表明了整个调用栈是怎样显示的：
https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero
at Exc1.subroutine(Exc1.java:4)
at Exc1.main(Exc1.java:7)
如你所见，栈底是main的第7行，该行调用了subroutine( )方法。该方法在第4行导致了异常。调用堆栈对于调试来说是很重要的，因为它查明了导致错误的精确的步骤。
10.4 使用try和catch
尽管由Java运行时系统提供的默认异常处理程序对于调试是很有用的，但通常你希望自己处理异常。这样做有两个好处。第一，它允许你修正错误。第二，它防止程序自动终止。大多数用户对于在程序终止运行和在无论何时错误发生都会打印堆栈轨迹感到很烦恼（至少可以这么说）。幸运的是，这很容易避免。
为防止和处理一个运行时错误，只需要把你所要监控的代码放进一个try块就可以了。紧跟着try块的，包括一个说明你希望捕获的错误类型的catch子句。完成这个任务很简单，下面的程序包含一个处理因为被零除而产生的ArithmeticException 异常的try块和一个catch 子句。
class Exc2 {
public static void main(String args[]) {
int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e) { // catch divide-by-zero error
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
}
该程序输出如下：
Division by zero.
After catch statement.
注意在try块中的对println( )的调用是永远不会执行的。一旦异常被引发，程序控制由try
第10章异常处理 179
块转到catch块。执行永远不会从catch块“返回”到try块。因此，“This will not be printed。”
将不会被显示。一旦执行了catch语句，程序控制从整个try/catch机制的下面一行继续。
一个try和它的catch语句形成了一个单元。catch子句的范围限制于try语句前面所定义的
语句。一个catch语句不能捕获另一个try声明所引发的异常（除非是嵌套的try语句情况）。
被try保护的语句声明必须在一个大括号之内（也就是说，它们必须在一个块中）。你不能
单独使用try。
构造catch子句的目的是解决异常情况并且像错误没有发生一样继续运行。例如，下面
的程序中，每一个for循环的反复得到两个随机整数。这两个整数分别被对方除，结果用来
除12345。最后的结果存在a中。如果一个除法操作导致被零除错误，它将被捕获，a的值设
为零，程序继续运行。
// Handle an exception and move on.
import java.util.Random;
class HandleError {
public static void main(String args[]) {
int a=0, b=0, c=0;
Random r = new Random();
for(int i=0; i<32000; i++) {
try {
b = r.nextInt();
c = r.nextInt();
a = 12345 / (b/c);
} catch (ArithmeticException e) {
System.out.println("Division by zero.");
a = 0; // set a to zero and continue
}
System.out.println("a: " + a);
}
}
}
10.4.1 显示一个异常的描述
Throwable重载toString( )方法（由Object定义），所以它返回一个包含异常描述的字符
串。你可以通过在println( )中传给异常一个参数来显示该异常的描述。例如，前面程序的
catch块可以被重写成
catch (ArithmeticException e) {
System.out.println("Exception: " + e);
a = 0; // set a to zero and continue
}
当这个版本代替原程序中的版本，程序在标准javaJDK解释器下运行，每一个被零除错
误显示下面的消息：
Exception: https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero
尽管在上下文中没有特殊的值，显示一个异常描述的能力在其他情况下是很有价值的
180 第1部分 Java语言
——特别是当你对异常进行实验和调试时。
10.5 使用多重catch 语句
某些情况，由单个代码段可能引起多个异常。处理这种情况，你可以定义两个或更多的catch子句，每个子句捕获一种类型的异常。当异常被引发时，每一个catch子句被依次检查，第一个匹配异常类型的子句执行。当一个catch语句执行以后，其他的子句被旁路，执行从try/catch块以后的代码开始继续。下面的例子设计了两种不同的异常类型：
// Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[]) {
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
int c[] = { 1 };
c[42] = 99;
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}
该程序在没有命令行参数的起始条件下运行导致被零除异常，因为a为0。如果你提供一个命令行参数，它将幸免于难，把a设成大于零的数值。但是它将导致ArrayIndexOutOf BoundsException异常，因为整型数组c的长度为1，而程序试图给c[42]赋值。
下面是运行在两种不同情况下程序的输出：
C:\>java MultiCatch
a = 0
Divide by 0: https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero
After try/catch blocks.
C:\>java MultiCatch TestArg
a = 1
Array index oob: https://www.wendangku.net/doc/ef3700725.html,ng.ArrayIndexOutOfBoundsException
After try/catch blocks.
当你用多catch语句时，记住异常子类必须在它们任何父类之前使用是很重要的。这是因为运用父类的catch语句将捕获该类型及其所有子类类型的异常。这样，如果子类在父类后面，子类将永远不会到达。而且，Java中不能到达的代码是一个错误。例如，考虑下面的程序：
/* This program contains an error.
A subclass must come before its superclass in
第10章异常处理 181
a series of catch statements. If not,
unreachable code will be created and a
compile-time error will result.
*/
class SuperSubCatch {
public static void main(String args[]) {
try {
int a = 0;
int b = 42 / a;
} catch(Exception e) {
System.out.println("Generic Exception catch.");
}
/* This catch is never reached because
ArithmeticException is a subclass of Exception. */
catch(ArithmeticException e) { // ERROR - unreachable
System.out.println("This is never reached.");
}
}
}
如果你试着编译该程序，你会收到一个错误消息，该错误消息说明第二个catch语句不
会到达，因为该异常已经被捕获。因为ArithmeticException 是Exception的子类，第一个catch
语句将处理所有的面向Exception的错误，包括ArithmeticException。这意味着第二个catch
语句永远不会执行。为修改程序，颠倒两个catch语句的次序。
10.6 嵌套try语句
Try语句可以被嵌套。也就是说，一个try语句可以在另一个try块内部。每次进入try语
句，异常的前后关系都会被推入堆栈。如果一个内部的try语句不含特殊异常的catch处理程
序，堆栈将弹出，下一个try语句的catch处理程序将检查是否与之匹配。这个过程将继续直
到一个catch语句匹配成功，或者是直到所有的嵌套try语句被检查耗尽。如果没有catch语句
匹配，Java的运行时系统将处理这个异常。下面是运用嵌套try语句的一个例子：
// An example of nested try statements.
class NestTry {
public static void main(String args[]) {
try {
int a = args.length;
/* If no command-line args are present,
the following statement will generate
a divide-by-zero exception. */
int b = 42 / a;
System.out.println("a = " + a);
try { // nested try block
182 第1部分 Java语言
/* If one command-line arg is used,
then a divide-by-zero exception
will be generated by the following code. */
if(a==1) a = a/(a-a); // division by zero
/* If two command-line args are used,
then generate an out-of-bounds exception. */
if(a==2) {
int c[] = { 1 };
c[42] = 99; // generate an out-of-bounds exception
}
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out-of-bounds: " + e);
}
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}
如你所见，该程序在一个try块中嵌套了另一个try块。程序工作如下：当你在没有命令行参数的情况下执行该程序，外面的try块将产生一个被零除的异常。程序在有一个命令行参数条件下执行，由嵌套的try块产生一个被零除的错误。因为内部的块不匹配这个异常，它将把异常传给外部的try块，在那里异常被处理。如果你在具有两个命令行参数的条件下执行该程序，由内部try块产生一个数组边界异常。下面的结果阐述了每一种情况：
C:\>java NestTry
Divide by 0: https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero
C:\>java NestTry One
a = 1
Divide by 0: https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero
C:\>java NestTry One Two
a = 2
Array index out-of-bounds: https://www.wendangku.net/doc/ef3700725.html,ng.ArrayIndexOutOfBoundsException
当有方法调用时，try语句的嵌套可以很隐蔽的发生。例如，你可以把对方法的调用放在一个try块中。在该方法内部，有另一个try语句。这种情况下，方法内部的try仍然是嵌套在外部调用该方法的try块中的。下面是前面例子的修改，嵌套的try块移到了方法nesttry( )的内部：
/* Try statements can be implicitly nested via
calls to methods. */
class MethNestTry {
static void nesttry(int a) {
try { // nested try block
/* If one command-line arg is used,
第10章异常处理 183
then a divide-by-zero exception
will be generated by the following code. */
if(a==1) a = a/(a-a); // division by zero
/* If two command-line args are used,
then generate an out-of-bounds exception. */
if(a==2) {
int c[] = { 1 };
c[42] = 99; // generate an out-of-bounds exception
}
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out-of-bounds: " + e);
}
}
public static void main(String args[]) {
try {
int a = args.length;
/* If no command-line args are present,
the following statement will generate
a divide-by-zero exception. */
int b = 42 / a;
System.out.println("a = " + a);
nesttry(a);
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}
该程序的输出与前面的例子相同。
10.7 引发（throw）
到目前为止，你只是获取了被Java运行时系统引发的异常。然而，程序可以用throw语
句引发明确的异常。Throw语句的通常形式如下：
throw ThrowableInstance;
这里，ThrowableInstance一定是Throwable类类型或Throwable子类类型的一个对象。简
单类型，例如int或char，以及非Throwable类，例如String或Object，不能用作异常。有两种
可以获得Throwable对象的方法：在catch子句中使用参数或者用new操作符创建。
184 第1部分 Java语言
程序执行在throw语句之后立即停止；后面的任何语句不被执行。最紧紧包围的try块用来检查它是否含有一个与异常类型匹配的catch语句。如果发现了匹配的块，控制转向该语句；如果没有发现，次包围的try块来检查，以此类推。如果没有发现匹配的catch块，默认异常处理程序中断程序的执行并且打印堆栈轨迹。
下面是一个创建并引发异常的例子程序，与异常匹配的处理程序再把它引发给外层的处理程序。
// Demonstrate throw.
class ThrowDemo {
static void demoproc() {
try {
throw new NullPointerException("demo");
} catch(NullPointerException e) {
System.out.println("Caught inside demoproc.");
throw e; // rethrow the exception
}
}
public static void main(String args[]) {
try {
demoproc();
} catch(NullPointerException e) {
System.out.println("Recaught: " + e);
}
}
}
该程序有两个机会处理相同的错误。首先，main（）设立了一个异常关系然后调用demoproc( )。demoproc( )方法然后设立了另一个异常处理关系并且立即引发一个新的NullPointerException实例，NullPointerException在下一行被捕获。异常于是被再次引发。下面是输出结果：
Caught inside demoproc.
Recaught: https://www.wendangku.net/doc/ef3700725.html,ng.NullPointerException: demo
该程序还阐述了怎样创建Java的标准异常对象，特别注意下面这一行：
throw new NullPointerException("demo");
这里，new用来构造一个NullPointerException实例。所有的Java内置的运行时异常有两个构造函数：一个没有参数，一个带有一个字符串参数。当用到第二种形式时，参数指定描述异常的字符串。如果对象用作 print( )或println( )的参数时，该字符串被显示。这同样可以通过调用getMessage( )来实现，getMessage( )是由Throwable定义的。
10.8 throws
如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常。做到这点你可以在方法声明中包含一个throws子句。一
第10章异常处理 185
个throws子句列举了一个方法可能引发的所有异常类型。这对于除Error 或
RuntimeException及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他
类型的异常必须在throws子句中声明。如果不这样做，将会导致编译错误。
下面是包含一个throws子句的方法声明的通用形式：
type method-name(parameter-list) throws exception-list
{
// body of method
}
这里，exception-list是该方法可以引发的以有逗号分割的异常列表。
下面是一个不正确的例子。该例试图引发一个它不能捕获的异常。因为程序没有指定
一个throws子句来声明这一事实，程序将不会编译。
// This program contains an error and will not compile.
class ThrowsDemo {
static void throwOne() {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) {
throwOne();
}
}
为编译该程序，需要改变两个地方。第一，需要声明throwOne( )引发IllegalAccess
Exception异常。第二，main( )必须定义一个try/catch 语句来捕获该异常。
正确的例子如下:
// This is now correct.
class ThrowsDemo {
static void throwOne() throws IllegalAccessException {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) {
try {
throwOne();
} catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}
}
}
下面是例题的输出结果：
inside throwOne
caught https://www.wendangku.net/doc/ef3700725.html,ng.IllegalAccessException: demo
186 第1部分 Java语言
10.9 finally
当异常被引发，通常方法的执行将作一个陡峭的非线性的转向。依赖于方法是怎样编码的，异常甚至可以导致方法过早返回。这在一些方法中是一个问题。例如，如果一个方法打开一个文件项并关闭，然后退出，你不希望关闭文件的代码被异常处理机制旁路。finally 关键字为处理这种意外而设计。
finally创建一个代码块。该代码块在一个try/catch 块完成之后另一个try/catch出现之前执行。finally块无论有没有异常引发都会执行。如果异常被引发，finally甚至是在没有与该异常相匹配的catch子句情况下也将执行。一个方法将从一个try/catch块返回到调用程序的任何时候，经过一个未捕获的异常或者是一个明确的返回语句，finally子句在方法返回之前仍将执行。这在关闭文件句柄和释放任何在方法开始时被分配的其他资源是很有用的。finally 子句是可选项，可以有也可以无。然而每一个try语句至少需要一个catch或finally子句。
下面的例子显示了3种不同的退出方法。每一个都执行了finally子句：
// Demonstrate finally.
class FinallyDemo {
// Through an exception out of the method.
static void procA() {
try {
System.out.println("inside procA");
throw new RuntimeException("demo");
} finally {
System.out.println("procA's finally");
}
}
// Return from within a try block.
static void procB() {
try {
System.out.println("inside procB");
return;
} finally {
System.out.println("procB's finally");
}
}
// Execute a try block normally.
static void procC() {
try {
System.out.println("inside procC");
} finally {
System.out.println("procC's finally");
}
第10章异常处理 187 }
public static void main(String args[]) {
try {
procA();
} catch (Exception e) {
System.out.println("Exception caught");
}
procB();
procC();
}
}
该例中，procA( )过早地通过引发一个异常中断了try。Finally子句在退出时执行。procB( )
的try语句通过一个return语句退出。在procB( )返回之前finally子句执行。在procC（）中，
try语句正常执行，没有错误。然而，finally块仍将执行。
注意：如果finally块与一个try联合使用，finally块将在try 结束之前执行。
下面是上述程序产生的输出：
inside procA
procA’s finally
Exception caught
inside procB
procB’s finally
inside procC
procC’s finally
10.10 Java的内置异常
在标准包https://www.wendangku.net/doc/ef3700725.html,ng中，Java定义了若干个异常类。前面的例子曾用到其中一些。这些异
常一般是标准类RuntimeException的子类。因为https://www.wendangku.net/doc/ef3700725.html,ng实际上被所有的Java程序引入，多
数从RuntimeException派生的异常都自动可用。而且，它们不需要被包含在任何方法的
throws列表中。Java语言中，这被叫做未经检查的异常（unchecked exceptions ）。因为编
译器不检查它来看一个方法是否处理或引发了这些异常。 https://www.wendangku.net/doc/ef3700725.html,ng中定义的未经检查的异
常列于表10-1。表10-2列出了由 https://www.wendangku.net/doc/ef3700725.html,ng定义的必须在方法的throws列表中包括的异常，如
果这些方法能产生其中的某个异常但是不能自己处理它。这些叫做受检查的异常（checked
exceptions）。Java定义了几种与不同类库相关的其他的异常类型。
表10-1 Java的https://www.wendangku.net/doc/ef3700725.html,ng中定义的未检查异常子类
异常说明
ArithmeticException算术错误，如被0除
ArrayIndexOutOfBoundsException 数组下标出界
188 第1部分 Java语言
续表异常说明
ArrayStoreException 数组元素赋值类型不兼容
ClassCastException 非法强制转换类型
IllegalArgumentException 调用方法的参数非法IllegalMonitorStateException 非法监控操作，如等待一个未锁定线程IllegalStateException 环境或应用状态不正确IllegalThreadStateException 请求操作与当前线程状态不兼容IndexOutOfBoundsException 某些类型索引越界
NullPointerException 非法使用空引用
NumberFormatException 字符串到数字格式非法转换
SecurityException 试图违反安全性
StringIndexOutOfBounds 试图在字符串边界之外索引UnsupportedOperationException 遇到不支持的操作
表10-2 https://www.wendangku.net/doc/ef3700725.html,ng中定义的检查异常
异常意义
ClassNotFoundException 找不到类
CloneNotSupportedException 试图克隆一个不能实现Cloneable接口的对象IllegalAccessException 对一个类的访问被拒绝
InstantiationException 试图创建一个抽象类或者抽象接口的对象InterruptedException 一个线程被另一个线程中断NoSuchFieldException 请求的字段不存在
NoSuchMethodException 请求的方法不存在
10.11 创建自己的异常子类
尽管Java的内置异常处理大多数常见错误，你也许希望建立你自己的异常类型来处理你所应用的特殊情况。这是非常简单的：只要定义Exception的一个子类就可以了（Exception 当然是Throwable的一个子类）。你的子类不需要实际执行什么——它们在类型系统中的存在允许你把它们当成异常使用。
Exception类自己没有定义任何方法。当然，它继承了Throwable提供的一些方法。因此，所有异常，包括你创建的，都可以获得Throwable定义的方法。这些方法显示在表10-3中。你还可以在你创建的异常类中覆盖一个或多个这样的方法。
表10-3 Throwable定义的方法
方法描述
Throwable fillInStackTrace( )返回一个包含完整堆栈轨迹的Throwable对象，该对象可能
被再次引发
第10章异常处理 189
续表
方法描述
String getLocalizedMessage( ) 返回一个异常的局部描述
String getMessage( ) 返回一个异常的描述
void printStackTrace( ) 显示堆栈轨迹
void printStackTrace(PrintStreamstream) 把堆栈轨迹送到指定的流
void printStackTrace(PrintWriterstream) 把堆栈轨迹送到指定的流
String toString( ) 返回一个包含异常描述的String对象。当输出一个Throwable
对象时，该方法被println( )调用
下面的例子声明了Exception的一个新子类，然后该子类当作方法中出错情形的信号。
它重载了toString( )方法，这样可以用println( )显示异常的描述。
// This program creates a custom exception type.
class MyException extends Exception {
private int detail;
MyException(int a) {
detail = a;
}
public String toString() {
return "MyException[" + detail + "]";
}
}
class ExceptionDemo {
static void compute(int a) throws MyException {
System.out.println("Called compute(" + a + ")");
if(a > 10)
throw new MyException(a);
System.out.println("Normal exit");
}
public static void main(String args[]) {
try {
compute(1);
compute(20);
} catch (MyException e) {
System.out.println("Caught " + e);
}
}
}
该例题定义了Exception的一个子类MyException。该子类非常简单：它只含有一个构造
函数和一个重载的显示异常值的toString( )方法。ExceptionDemo类定义了一个compute( )方
法。该方法引发一个MyException对象。当compute( )的整型参数比10大时该异常被引发。
main( )方法为MyException设立了一个异常处理程序，然后用一个合法的值和不合法的值调
用compute( )来显示执行经过代码的不同路径。下面是结果：
190 第1部分 Java语言
Called compute(1)
Normal exit
Called compute(20)
Caught MyException[20]
10.12 使用异常
异常处理为控制具有很多动态运行时特性的复杂程序提供了一个强大的机制。把try，throw，和catch当成处理错误简洁及程序逻辑上的反常边界条件是很重要的。如果你像多数程序员一样，那么你可能习惯于在方法失败时返回一个错误代码。在你用Java编程时，你应该打破这个习惯。当方法可能失败时，引发一个异常。这是处理失败模式的一个更简洁的方法。
最后说明一点：Java的异常处理语句不应该被当作是一个非本地分支的通常机制，如果你这样认为，它将困扰你的代码并使代码难于维护。
Java-异常(习题)
java异常（习题） 练习 1. 填空 Java 中所有的错误都继承自______类；在该类的子类中， _______类表示严重的底层错误，对于这类错误一般处理的方式是___________； _______类表示例外、异常。 2. 查api，填空 异常类java.rmi.AlreadyBoundException，从分类上说，该类属于__________（已检查| 未检查）异常，从处理方式上说，对这种异常___________________； 异常类java.util.regex.PatternSyntaxException，从分类上说，该类属于_________（已检查|未检查）异常，从处理方式上说，对这种异常__________________。 4. （try-catch-finally）有如下代码：
问：当读入的n 分别为1，2，3，4，5 时，输出的结果分别是什么？
5. （自定义异常）创建两个自定义异常类MyException1 和MyException2。 要求： 1) MyException1 为已检查异常，MyException2 为未检查异常 2) 这两个异常均具有两个构造函数，一个无参，另一个带字符串参数，参数表示产生异常的详细信息。
问： 在//1 处，填入以下________代码可以编译通过，在//2 处，填入_________代码可以编译通过。 A. throws java.io.IOException B. throws java.io., java.io.EOFException C. throws java.sql.SQLException D. 不能抛出任何异常。
Java语言提供两种异常处理机制
得到一个异常对象是，它将会沿着方法的调用栈逐层回溯，寻找处理这一异常的代码。找到能够处理这种类型异常的方法后，运行时系统把当前异常交给这个方法处理；如果找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出。捕获异常是通过try-catch-finally语句实现的。语法为：try{ ... }catch(ExceptionName1 e){ ... }catch(ExceptionName2 e){ ... } ... }finally{ ... } 2)声明抛弃异常：当Java 程序运行时系统得到一个异常对象时，如果一个方法并不知道如何处理所出现的异常，则可在方法声明时，声明抛弃异常。声明抛弃异常是在一个方法声明中的throws子句中指明的。如：public int read() throws IOException{ ... } 其中throws IOException就是声明抛弃异常，throws后可以跟多个异常类型。 1. https://www.wendangku.net/doc/ef3700725.html,ng.nullpointerexception 这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话） 2. https://www.wendangku.net/doc/ef3700725.html,ng.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。 3. https://www.wendangku.net/doc/ef3700725.html,ng.arithmeticexception 这个异常的 好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。 4. 是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。 5. https://www.wendangku.net/doc/ef3700725.html,ng.illegalargumentexception 这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。 6. https://www.wendangku.net/doc/ef3700725.html,ng.illegalaccessexception 这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。算术异常类：ArithmeticExecption 空指针异常类：NullPointerException 类型强制转换异常：ClassCastException 数组负下标异常：NegativeArrayException 数组下标越界异常：ArrayIndexOutOfBoundsException 违背安全原则异常：SecturityException 文件已结束异常：EOFException 文件未找到异常：FileNotFoundException 字符串转换为数字异常：NumberFormatException 操作数据库异常：SQLException 输入输出异常：IOException 方法未找到异常：NoSuchMethodException https://www.wendangku.net/doc/ef3700725.html,ng.AbstractMethodError 抽象方法错误。当应用试图调用抽象方法时抛出。https://www.wendangku.net/doc/ef3700725.html,ng.AssertionError 断言错。用来指示一个断言失败的情况。https://www.wendangku.net/doc/ef3700725.html,ng.ClassCircularityError 类循环依赖错误。在初始化一个类时， 个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。https://www.wendangku.net/doc/ef3700725.html,ng.Error 错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。https://www.wendangku.net/doc/ef3700725.html,ng.ExceptionInInitializerError 初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异
JAVA中常用类的常用方法
JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“ 克隆” 的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内 容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法 返回该对象的哈希码值。 5、notify()方法 唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法 唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比 较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar)
java异常分类
Java中的异常类型 1. https://www.wendangku.net/doc/ef3700725.html,ng.nullpointerexception 这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话） 2. https://www.wendangku.net/doc/ef3700725.html,ng.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。 3. https://www.wendangku.net/doc/ef3700725.html,ng.arithmeticexception 这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。 4. https://www.wendangku.net/doc/ef3700725.html,ng.arrayindexoutofboundsexception 这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。 5. https://www.wendangku.net/doc/ef3700725.html,ng.illegalargumentexception 这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
java异常处理例题代码
App9_1.java：输出一个数组的所有元素，捕获数组下标越界异常和除娄为0异常。public class App9_1{ public static void main(String args[]){ int i; int[] a={1,2,3,4}; for(i=0;i<5;i++) System.out.println(" a["+i+"]="+a[i]); System.out.println("5/0"+(5/0)); } } App9_2.java：使用try-catch-finall语句对程序中的异常进行捕获与处理。 public class App9_2{ public static void main(String args[]){ int i; int a[]={1,2,3,4}; for (i=0;i<5;i++){ try{ System.out.print("a["+i+"]/"+i+"="+(a[i]/i)); } catch(ArrayIndexOutOfBoundsException e){ System.out.print("捕获到了数组下标越界异常"); } catch(ArithmeticException e){ System.out.print("异常类名称是："+e); //显示异常信息 } catch(Exception e){ System.out.println("捕获"+e.getMessage()+"异常！"); //显示异常信息 } finally{ System.out.println(" finally i="+i); } } System.out.println("继续！！"); } } App9_3.java：使用throw语句在方法中抛出异常。 public class App9_3{ public static void main(String args[]){ int a=5,b=0; try{ if (b==0) throw new ArithmeticException(); //抛出异常，不是必须的 else System.out.println(a+"/"+b+"="+a/b); //若不抛出异常，则运行此行
JAVA中常用类的常用方法
JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.wendangku.net/doc/ef3700725.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法 当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返 回该对象的哈希码值。 5、notify〇方法 唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法 唤醒在此对象监视器上等待的所有线程= 7、toString()方法 返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法 在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。 二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字
典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字 符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符 串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。
Java 异常
1．异常处理的关键字有哪些？ 2．在Java中，throw与throws有什么区别？他们各自用在什么地方？ 3．如何处理一个已抛出的异常？ 4．try中如果有return语句，则finally语句是否被执行? 5．try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行? 6．以下关于异常的说法正确的是：（） Ａ）一旦出现异常，整个应用程序运行就终止了。 Ｂ）如果一个方法申明将抛出某个异常，它就必须真的抛出那个异常。 Ｃ）在catch子句中匹配异常是一种精确匹配。 Ｄ）可能抛出RuntimeException异常的方法是不需要声明异常的。 7．假设下列try-catch块中的statement2引起一个异常： try { statement1 statement2 statement3 } catch(Exception1 ex1) {} catch(Exception2 ex2) {} statement4 回答下面的问题： 1）statement3会执行吗？ 2）如果异常未被捕获，statement4会执行吗？ 3）如果catch子句捕获了异常，statement4会执行吗？ 4）如果异常传递给了调用者，statement4会执行吗？ 8．运行下面的程序时，控制台上会显示什么？ class Test{ public static void main(String args[]) { try { System.out.println("Welcome to Java"); int i=0; int y=2/i; System.out.println("Welcome to Java"); } finally{ System.out.println("End of the block”); } } System.out.println("End of main”); }
JAVA实验四异常处理
实验四异常处理 实验目的 1、掌握异常的概念和Java 异常处理机制。 2、掌握异常的定义、抛出和捕捉处理。 实验内容与要求 1、仔细读下面的JAVA语言源程序，自己给出程序的运行结果 import java.io.*; public class Ch31 { public static void main(String args[])throws IOException { int[] ko=new int[15]; int n,a; String x; BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); System.out.print("Enter an integer:"); x=keyin.readLine(); n=Integer.parseInt(x); try { a=110/n; ko[15]=100; System.out.println("此描述无法执行！"); } catch(ArithmeticException e){ System.out.println("除数为0的错误"); } catch(ArrayIndexOutOfBoundsException f) { System.out.println("数组索引值大于数组长度的错误!"); } System.out.println("执行完catch的描述!!!"); } } 2．运行下面的程序，自己给出程序的运行结果。 import java.io.*; public class Ch32{ public Ch32(){ try{ int a[] = new int[2]; a[4] = 3; System.out.println("After handling exception return here?"); }catch(IndexOutOfBoundsException e){ System.err.println("exception msg:" + e.getMessage()); System.err.println("exception string:" + e.toString()); e.printStackTrace(); }finally{
java异常处理试题及答案
异常处理练习题 一、选择题 1.java中用来抛出异常的关键字是 (C) A、try B、catch C、throw D、finally 2.关于异常，下列说法正确的是(A) A、异常是一种对象 B、一旦程序运行，异常将被创建 C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都丌对 3.（A）类是所有异常类的父类。 A、Throwable B、Error C、Exception D、AWTError 4.java语言中，下列哪一子句是异常处理的出口(C) A、try{…}子句 B、catch{…}子句 C、finally{…}子句 D、以上说法都丌对 5.下列程序的执行，说法错误的是 (C) public class MultiCatch { public static void main(String args[]) { try { int a=args.length; int b=42/a; int c[]={1}; c[42]=99; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越边界异常：”+e); } } } A、程序将输出第15行的异常信息 B、程序第10行出错 C、程序将输出“b=42”
D、程序将输出第15和19行的异常信息 6.下列程序的执行，说法正确的是（D） class ExMulti { static void procedure() { try { int c[]={1}; c[42]=99; } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越界限异常：”+e); } } public static void main(String args[]) { try { procedure(); int a=args.length; int b=42/a; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } } } A、程序只输出第12行的异常信息 B、程序只输出第26行的异常信息 C、程序将不输出异常信息 D、程序将输出第12行和第26行的异常信息 7.下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。class TrowsDemo { static void procedure() throws IllegalAccessExcepton { System.out.println(“inside procedure”); throw__new_____IllegalAccessException(“demo”);
JAVA中常用类的常用方法
JAVA中常用类的常用方法 一、https://www.wendangku.net/doc/ef3700725.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.wendangku.net/doc/ef3700725.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开
Java中常见异常类型及分析
Java常见异常类型及原因分析 这里介绍几种常见的异常并对原因进行分析，包括： ●NullPointException异常； ● ClassCastException异常； ● ArrayIndexOutOfBoundsException异常； ●UnsupportedClassVersionError错误； ●NumberFormatExceptio异常 ●堆栈溢出和内存溢出。 1 NullPointException异常 顾名思义，NullPointerException是空指针异常。但是在Java中没有指针，怎么会有空指针异常呢？ 在C++中，声明的指针需要指向一个实例（通过new方法构造），这个指针可以理解为地址。 在Java中，虽然没有指针，但是有引用（通常称为对象引用，一般直接说对象），引用也是要指向一个实例对象（通过new方法构造）的，从这种意义上说，Java中的引用与C++中的指针没有本质的区别，不同的是，处于安全的目的，在Java中不能对引用进行操作，而在C++中可以直接进行指针的运算，例如book++等。 所以这里的NullPointerException虽然不是真正的空指针异常，但本质上差不多，是因为引用没有指向具体的实例，所以当访问这个引用的方法的时候就会产生这种异常。例如下面的代码： String str = "这是一个测试用的字符串！"; System.out.println(str.length()); 这段代码没有问题，但是如果改成下面的代码： String str ; System.out.println(str.length()); 就会产生NullPointerException异常了，当然一般人不会犯这样低级的错误。 那这种异常通常是如何产生的呢？比较多见的是下面的两种情况： 1）把调用某个方法的返回值直接赋值给某个引用，然后调用这个引用的方法。在这种情况下，如果返回的值是null，必然会产生NullPointerException异常。例如： String userName=request.getParameter("userName"); if(userName.length()==0) ...... else ...... 如果request.getParameter("userName")的结果为null，则这里就会产生这种异常。 2）在方法体中调用参数的方法。这种情况下，如果调用方法的时候传递进来的值是null，也要产生NullPointerException异常。 要解决这种异常，只需要检查异常出现在第几行（通常在集成开发环境中会提示用户错误发生在第几行），然后查看调用了哪个对象的方法，然后检查这个对象为什么没有赋值成
第九章-Java异常处理练习Word版
第九章异常 在Java应用程序中，异常处理是保证程序正常、可靠运行的一个重要方面，在前边已经遇到了简单的异常处理。本章实验将主要针对程序中常用的异常的处理及异常的应用。 9.1 实验一：异常处理及应用 实验目的 (1). 了解异常的基本概念、异常的的产生和异常处理的过程。 (2). 基本掌握异常在应用程序中的应用。 实验要求 编写应用程序，在程序中对常见的异常进行捕捉并作相应的处理。 实验内容 实验示例9.1.1 在上一章8.2.1的实验示例测试中，若没有输入答案或输入非数字字符，则在处理过程中会出现数据格式异常，修改实验示例8.2.1创建的Exercises类，添加捕获并处理异常的程序代码。 实现该示例的步骤如下： ⑴简要分析 根据题意，首先需要确定会产生异常的程序段，然后使用try~catch结构进行捕捉和处理异常地处理。由于主要处理数据格式异常，它由输入时的错误引起，所以，在处理异常时，就是返回到输入处，重新输入数据。 ⑵根据上述简要分析，给出如下修改后的参考程序代码(Exercise.java)： /*这是一个小学生综合训练题测试的应用程序 *程序的名称:Exercise.java *程序中捕捉处理数据格式异常(NumberFormatException) */ import java.awt.*; import java.awt.event.*; import java.util.*; import javax.swing.*; public class Exercises extends StudentScreen implements ActionListener,KeyListener { int count = 0; int n1=0,n2=0; int total=0; int right=0; long timenum=0; Random rand=new Random();
Java中异常处理
第13章异常课堂练习（2理论+2习题课+2上机） 【教学目标】 ?了解异常和异常处理的概貌（第13.2节）。 ?探究使用异常处理的优点（第13.3节）。 ?区别异常的类型：Error (致命的) 和Exception (非致命的), 以及必检和免检异常（第13.4节）。 ?在方法头中声明异常（第13.5.1节）。 ?在方法中抛出异常（第13.5.2节）。 ?编写try-catch 块处理异常（第13.5.3节）。 ?解释异常是如何传播的（第13.5.3节）。 ?在try-catch块中使用finally子句（第13.6节）。 ?只为非预期错误使用异常（第13.7节）。 ?在catch 块中重新抛出异常（第13.8节）。 ?创建链式异常（第13.9节）。 ?定义自定制的异常类（第13.10节）。 【教学重点】 ?了解异常的处理机制 ?异常的解决方法 ?Exception类的作用及其使用方法 ?必检异常、免检异常的特点 【基本知识点】 1、常见异常演示 （1）算数异常：https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException 在算术运算中，0作为除数时，系统将产生该异常，示例： public static void main(String[] args) { int x=10; int y=0; int m=x/y; } Exception in thread "main" https://www.wendangku.net/doc/ef3700725.html,ng.ArithmeticException: / by zero at exception.NotChecketException.main(NotChecketException.java:7)（2）数组越界异常：https://www.wendangku.net/doc/ef3700725.html,ng.ArrayInd exOutOfBoundsException 在数组下标越界时，将产生该异常，示例：
java常用词汇
Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。 Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。 Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。 Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿名类。 Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。 API 应用程序接口:提供特定功能的一组相关的类和方法的集合。 Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。在Java中作为对象处理。 Automatic variables 自动变量:也称为方法局部变量method local variables，即声明在方法体中的变量。 Base class 基类:即被扩展继承的类。HP0-538 Blocked state 阻塞状态:当一个线程等待资源的时候即处于阻塞状态。阻塞状态不使用处理器资源 Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。 Casting 类型转换 :即一个类型到另一个类型的转换，可以是基本数据类型的转换，也可以是对象类型的转换。 char 字符:容纳单字符的一种基本数据类型。 Child class 子类:见继承类Derived class Class 类:面向对象中的最基本、最重要的定义类型。350-018 Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。 Class methods 类方法:类方法通常是指的静态方法，即不需要实例化类就可以直接访问使用的方法。 Class variable 类变量:见静态变量Static variable
Java作业实验六---异常处理
提交方式： 把文件名改为学号姓名，提交文档和源码(只需提交最顶层包文件夹） 实验六异常处理 一、实验目的 1.学会利用Try-catch-finally语句来捕获和处理异常； 2.掌握自定义异常类的方法。 二、实验要求 1.通过编程理解系统异常处理的机制和创建自定义异常的方法。 2.掌握基础类。 三、实验内容 （一）异常处理机制 1. 编写使用try…catch 语句处理异常的程序文件Demo4_1.java，
编译并运行程序，并把运行结果复制在下面 。 注意：如果在catch 语句中声明的异常类是Exception，catch 语句也能正确地捕获，这是因为Exception是ArithmeticException的父类。如果不能确定会发生哪种情况的异常，那么最好指定catch的参数为Exception，即说明异常的类型为Exception。 2、源文件是Demo3_2.java。要捕捉的异常是除数为零和数组下标越界。通过修改a和c[]下标值体验程序。 【思考】 ①先运行上面程序，观察运行结果。 ②按下条件分别修改数据，编译后运行，观察输出结果，分析在try…catch块里那些语句没有被执行，为什么? 块外那些语句可被执行到，为什么? 修改a=0，保持c[2]=200； 保持a=10，修改c[3]=200， 修改a=0，修改c[3]=200； ③再添加一个catch{Exception e}{ },位置在最前面，观察编译信息，说明什么？ 3、编写Demo3_3.java 程序，计算两数相除并输出结果。使用两个catch子句，分别捕捉除数为0的异常和参数输入有误异常。源代码如下：
最新java异常处理作业(1113132845)
Java异常处理作业 孙月巧 1、参考下面的程序，试修改程序，捕获相关异常，使得程序能正常运行。【提示：用错误数据测试，即可得到异常类名，运行时主方法参数输入abc 测试】 package November; import java.util.Scanner; public class StringIndexOutOf{ public static void main(String args[]){ System.out.println("请输入一个字符串："); try{ Scanner reader=new Scanner(System.in); String str = reader.nextLine(); System.out.println("第四个字符为 " + str.charAt(3)); int aa = Integer.parseInt(str); System.out.println("平方为 " + aa * aa); } catch(StringIndexOutOfBoundsException e){ System.out.println("您输入的数值下标越界"); } catch(NumberFormatException nfe){ System.out.println("您输入的不是数字"); } } } 2、从命令行得到5个整数，放入一整型数组，然后打印输出，要求：如果输入数据不为整数，要捕获Integer.parseInt()产生的异常，显示“请输入整数”，捕获输入参数不足5个的异常(数组越界)，显示“请输入至少5个整数”。 package November; public class Test2 { public static void main(String[] args) { System.out.println("请输入五个整数："); try {
JAVA中常用的类
public static void main(String[] args) { String str1; str1 = "你好"; // 使用字符串常量构造一个字符串 String str2 = new String("你好"); // String类中重写了父类Object类的equals方法 // String类中的equals方法比较的是字符串的内容 // 使用String类中的equals方法时，建议将字符串常量写在前面 String str3 = null; System.out.println("你好".equals(str3));//正确写法 //System.out.println(str3.equals("你好"));//错误写法 // 使用equals方法 System.out.println(str1.equals(str2));//true System.out.println(str1 == str2);//false
// 使用char数组构造一个字符串 char [] ch1 = {'a', 'b', 'c'}; String str4 = new String(ch1); System.out.println("str4: " + str4); char [] ch2 = {'a', 'b', 'c', 'd', 'e', 'f'}; String str5 = new String(ch2, 2, 2); System.out.println("str5: " + str5); // 使用byte数组构造一个字符串 //byte [] by1 = {-50, 3, 100}; byte [] by1 = "测试".getBytes(); String str6 = new String(by1); System.out.println("str6: " + str6); // String类中的equals方法和等号String str7 = "西安网星"; String str8 = "西安网星"; System.out.println(str7.equals(str8));//true
java异常试题
异常作业 一．填空题填空题 1．一个try语句块后必须跟（ catch ）语句块，（ finally ）语句块可以没有2．自定义异常类必须继承（）类及其子类 3．异常处理机制允许根据具体的情况选择在何处处理异常，可以在（）捕获并处理，也可以用throws子句把他交给（）处理 二．选择题二．选择题 1. finally语句块中的代码（） A．总是被执行 B．当try语句块后面没有catch时，finally中的代码才会执行 C．异常发生时才执行 D．异常没有发生时才被执行 2. 抛出异常应该使用的关键字是（） A．throw B．catch C．finally D．throws 3. 自定义异常类时，可以继承的类是（） A．Error B．Applet C．Exception及其子类 D．AssertionError 4. 在异常处理中，将可能抛出异常的方法放在（）语句块中 A．throws B．catch C．try D．finally 5. 对于try{……}catch子句的排列方式，下列正确的一项是（） A．子类异常在前，父类异常在后 B．父类异常在前，子类异常在后 C．只能有子类异常 D．父类异常与子类异常不能同时出现 6. 使用catch(Exception e)的好处是（） A．只会捕获个别类型的异常 B．捕获try语句块中产生的所有类型的异常 C．忽略一些异常 D．执行一些程序 三．简答题三．简答题 1. try/catch/finally如何使用？ 2. throw/throws有什么联系和区别？ 3. 如何自定义异常类？ 4. 谈谈final、finally的区别和作用 5. 如果try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行？