Java异常处理
异常处理
●概念
●异常处理
●激发异常
●创建自己的异常
●示例
Java语言的设计从根本上便于我们写出整洁、设计良好的代码；尽管如此，在程序运行中仍可能有各种各样的错误出现。
1、概念
采用新的异常处理机制
在以往的程序开发过程中，常常采用返回值进行处理。例如，在编写一个方法，可以返回一个状态代码，调用者根据状态代码判断出错与否。若状态代码表示一个错误，则调用这进行相应的处理，或显示一个错误页面或错误信息。通过返回值进行处理的方法是有效的，但是有它的许多不足之处。
1、程序复杂
2、可靠性差
3、返回信息有限
4、返回代码标准化困难
采用错误代码和异常处理相结合的方式的优越性：
1、把错误代码与常规代码分开
2、可以在catch中传播错误信息
3、可以对错误类型分组
4、方便定位错误，维护
2、异常处理
Java的异常是面向对象的。一个Java的Exception是一个描述异常情况的对象.当出现异常
情况时，一个Exception对象就产生了,并放到异常的成员函数里。
Java的异常处理是通过5个关键词来实现的：try,catch,throw,throws和finally。在Java语言的错误处理结构由try，catch，finally三个块组成。其中try块存放将可能发生异常的Java 语言，并管理相关的异常指针；catch块紧跟在try块后面，用来激发被捕获的异常；finally 块包含清除程序没有释放的资源，句柄等。不管try块中的代码如何退出，都将执行finally 块。
try…catch…块
可以采用try来指定一块预防所有异常的程序。紧跟在try程序块后面，应包含一个
或多个catch子句来指定你想要捕获的异常类型：try catch的格式一般为：
try{
/**do something*/
}catch(…){
…
}catch(…){
…
}
例如：
try{
int a= 100/0
}catch(Exception e){
System.out.println(e.getMessage());
}
每当Java程序激发一个异常时，它实际上是激发了一个对象，而只有其超类为Throwable 类的对象才能被激发。Throwable类中的提供了一些方法。如：其中的getMessage()方法打印出异常对应信息。
Catch子句的目标是解决异常情况，把变量设到合理的状态，并象没有出错一样继续运行。如果一个子程序不处理没个异常，则返回到上一级处理，如此可以不断的递归向上直到最外一级。
finally 块
finally 关键字是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用finally 可以维护对象的内部状态，并可以清理非内存资源。如果没有finally，您的代码就会很费解。例如，下面的代码说明，在不使用finally 的情况下您必须如何编写代码来释放非内存资源：
import https://www.doczj.com/doc/4111880957.html,.*;import java.io.*;
class WithoutFinally{
public void foo() throws IOException { //在任一个空闲的端口上创建一个套接字ServerSocket ss = new ServerSocket(0);
try {
Socket socket = ss.accept();
//此处的其他代码...
}catch (IOException e) {
ss.close();
//1
throw e;
} //... ss.close(); //2 }}这段代码创建了一个套接字，并调用accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在//2 处调用close，它是该方法的最后一条语句。但是，如果try 块中发生一个异常会怎么样呢？在这种情况下，//2 处的close 调用永远不会发生。因此，您必须捕获这个异常，并在重新发出这个异常之前在//1 处插入对close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。
这样编写代码既麻烦又易于出错，但在没有finally 的情况下这是必不可少的。不幸的是，在没有finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。Java 中的finally 子句解决了这个问题。有了finally，前面的代码就可以重写为以下的形式：
import https://www.doczj.com/doc/4111880957.html,.*;import java.io.*;
class WithFinally{
public void foo2() throws IOException { //在任一个空闲的端口上创建一个套接字ServerSocket ss = new ServerSocket(0);
try {
Socket socket = ss.accept();
//此处的其他代码... }finally {
ss.close();
}
}
}finally 块确保close 方法总被执行，而不管try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个catch 块。在第一个示例中提供catch 块只是为了关闭套接字，现在这是通过finally 关闭的。如果您确实提供了一个catch 块，则finally 块中的代码在catch 块完成以后执行。
finally 块必须与try 或try/catch 块配合使用。此外，不可能退出try 块而不执行其finally 块。如果finally 块存在，则它总会执行。（无论从那点看，这个陈述都是正确的。有一种方法可以退出try 块而不执行finally 块。如果代码在try 内部执行一条System.exit(0); 语句，则应用程序终止而不会执行finally 执行。另一方面，如果您在try 块执行期间拨掉电源，finally 也不会执行。）
try…catch…finally 块
最好采用此结构处理异常.在catch中捕获异常,在finally块中清除不需要的资源,这样程序结构将会更完善,健壮.例如:
try{
/**to do */
}
catch(Exception ex){
System.out.println(ex.getMessage());
}
finally{
clearUpAll()
}
3、激发异常
Java语言可以不在方法中直接捕获，而用throw语句将异常抛给上层的调用者。Throw语句就是来明确地抛出一个异常；首先你必需得到一个Throwable的实例句柄，通过参数传到catch中，或者采用new操作符来创建一个。
格式：throw new WhcaException(e.getMessage);
程序会在throw语句后立即终止，它后面的语句都不执行，然后在包含它的所有try块中从里到外寻找含有与其匹配的catch.
声明异常类
当throw语句被用在方法说明中时，throw有用throws代替。关键字throws用来标明一个方法可能抛出的各种异常。对大多数Exception子类来说，Java编译器会强迫你声明在一个方法中抛出的异常的类型。如下：
格式：type method_name(arg_list) throws WhcaException{
……
}
例如：public void execute(String str,int index) throws WhcaException{
try{
}
catch(Exception e){
throw new WhcaException(“JB: M:”+e.getMessage);
}
}
4、创建自己的异常类
当程序员为提供一些特定的功能用Java类时，往往需要保证类之间有良好的关系，而且类之间的接口易于理解和实现，这是定义一个新的异常类。建议创建自己的异常类，便于维护，管理。
定义一个新的异常类
通常采用Exception作为异常类的超类，如：
package https://www.doczj.com/doc/4111880957.html,mon;
public class WhcaException extends Exception{
public WhcaException(){
}
public WhcaException(String s){
super(s);
}
}
5、示例
下面是示例：TestServlet 调用TestDB和TestPsi，（附代码）如果发生异常怎样最快解决程序发生的异常错误。
在整个项目的开发过程中，指定错误代码表，并分类。如PSI类，数据库异常类代码，应用异常类代码，XML异常，网络通讯异常等等；
采用自己的异常类，当遇到异常是，激发的异常携带错误类或异常方法的路径：
如：setFlag(“PSI001”);
throw new WhcaException(“JB:TestA M:exe1 ”+e.getMessage);
这里：PSI001为错误代码，“JB:TestA M:exe1”为异常链，e.getMessage为异常信息。
例如：遇到错误信息列表为：JB:TestB M:exe2 JB:TestA M:exe1 java.sql.SQLException,说明TestB 的方法exe2调用TestA的方法exe1发生了操作数据库异常。则可以迅速，准确的定位到那个类那个方法发生了异常。
注：（简写）JB：JavaBean M：Method
访问数据库类
//Class: TestDB
package corbaidl;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2000
* Company:
* @author
* @version 1.0
*/
import java.io.*;
import java.sql.*;
import https://www.doczj.com/doc/4111880957.html,mon.WhcaException;
public class TestDB {
private PreparedStatement pstmt =null;
private Connection conn = null;
private String flag;
public TestDB() {
}
public void CreateSysMan() throws WhcaException{
try {
/**@todo: CreateSysMan method*/
}
catch (Exception ex) {
setFlag("ORA004");
throw new WhcaException("JB:TestDB M:CreateSysMan ERR="+ex.getMessage());
}
finally {
cleanUpAll();
}
}
public void PublishCert() throws WhcaException{
try {
/**@todo: PublishCert method*/
}
catch (Exception ex) {
setFlag("ORA005");
throw new WhcaException("JB:TestDB M:PublishCert ERR="+ex.getMessage()); }
finally {
cleanUpAll();
}
}
public void cleanUpAll() throws WhcaException {
try {
if (pstmt != null)
pstmt.close();
if (conn != null)
conn.close();
} catch (Exception e) {
throw new WhcaException("JB:RootCaDB M:cleanUpAll Exception" + e.getMessage());
}
}
public void setFlag(String flag) {
this.flag = flag;
}
public String getFlag() {
return flag;
}
}
Psi调用公共类
//Class: TestPsi
package corbaidl;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2000
* Company:
* @author
* @version 1.0
*/
import psi.*;
import https://www.doczj.com/doc/4111880957.html,mon.WhcaException;
public class TestPsi {
private PSIJni psijni;
private String flag;
private int exeHandle=0;
public TestPsi() {
}
public int exePsiInit() throws WhcaException {
try {
//Step 1:psijni init
int ret;
int handle;
psijni = new PSIJni();
ret = psijni.pkiInit();
if (ret != 0) {
setFlag("PSI001");
throw new WhcaException("Initialize library environment failed!");
}
//Step 2:psijni getHandle
handle = psijni.getHandle();
if (handle < 0) {
setFlag("PSI002");
throw new WhcaException("Get handle error");
}
return handle;
} catch (Exception ex) {
throw new WhcaException(ex.getMessage());
}
}
public void exePsiEnd(int handle) throws WhcaException {
try {
psijni.destroyHandle(handle);
psijni.pkiEnd();
} catch (Exception ex) {
throw new WhcaException(ex.getMessage());
}
}
public void exeGetCert(String tcCert) throws WhcaException {
try {
PKI_DATA inData;
PKI_CERTINFO certInfo;
//Step 1:psijni init
int exeHandle = exePsiInit();
//Step 2:ReadLable
inData = new PKI_DATA();
int ret = psijni.pkiReadLabel(exeHandle, tcCert, LABEL_TYPE.LBL_CERT, inData);
if (ret != 0) {
setFlag("PSI003");
throw new WhcaException("ReadLabel Error");
}
byte[] cert_temp = inData.getValue();
} catch (Exception ex) {
throw new WhcaException("JB:RootCaPsi M:exeCertSN Exception" + ex.getMessage());
} finally{
//一定要执行的关闭PSI
exePsiEnd(exeHandle);
}
}
public void setFlag(String flag) {
this.flag = flag;
}
public String getFlag() {
return flag;
}
}
JavaServlet处理类
//Class:TestServlet
Servlet调用TestDB,TestPsi,将错误异常都抛给Catch处理
package corbaidl;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.sql.*;
import https://www.doczj.com/doc/4111880957.html,mon.*;
public class TestServlet extends HttpServlet {
private static final String CONTENT_TYPE = "text/html; charset=GBK"; private WhcaLog whcalog = new WhcaLog();
private Connection conn =null;
private String TmpErr="";
private String outpage="";
private String SuccPage="";
private String FailPage="";
/**Initialize global variables*/
public void init() throws ServletException {
}
/**Process the HTTP Get request*/
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
try {
PerformTask(request,response);
}
catch (Exception ex) {
whcalog.log(whcalog.REN_ZHIGUO,ex.getMessage());
}
}
/**Process the HTTP Put request*/
public void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
try {
PerformTask(request,response);
}
catch (Exception ex) {
whcalog.log(whcalog.REN_ZHIGUO,ex.getMessage());
}
}
/**PerformTask*/
public void PerformTask(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException,WhcaException {
try {
//Step 1:
SuccPage = "/CaApp/subca/initial/disa/DiSAInit.jsp";
FailPage = "/CaApp/subca/yhgl/error.jsp";
//Step 2:
DB_Connection ds = new DB_Connection();
try {
conn = ds.subca();
}
catch (Exception ex) {
TmpErr="ORA001";
throw new WhcaException("连接数据库失败"+ex.getMessage());
}
//Step 3:
TestDB testdb = new TestDB();
try {
testdb.CreateSysMan();
}
catch (Exception ex) {
TmpErr=testdb.getFlag();
throw new WhcaException("创建系统管理员失败"+ex.getMessage()); }
//Step 4:psi
TestPsi testpsi = new TestPsi();
try {
testpsi.exeGetCert("ROOTCA_CERT");
}
catch (Exception ex) {
TmpErr=testdb.getFlag();
throw new WhcaException("取根证书信息失败"+ex.getMessage()); }
//Step 5:
outpage=SuccPage;
invokejsp(request,response,"成功");
}
catch (Exception ex) {
whcalog.log(whcalog.REN_ZHIGUO,ex.getMessage());
outpage=FailPage;
invokejsp(request,response,ErrorMsg(TmpErr));
}
finally{
cleanUpAll();
}
}
/**Clean up resources*/
public void destroy() {
}
public void cleanUpAll() throws WhcaException {
try {
if (conn != null)
conn.close();
} catch (Exception e) {
throw new WhcaException("Servlet:TestServlet M:cleanUpAll Exception" + e.getMessage());
}
}
public void invokejsp(HttpServletRequest req, HttpServletResponse res, String msg) throws ServletException {
try {
req.setAttribute("Msg", msg);
RequestDispatcher rd = getServletContext().getRequestDispatcher(outpage);
rd.forward(req, res);
} catch (IOException ex) {
/**可能会发生网页错误*/
whcalog.log(whcalog.REN_ZHIGUO,"invokejsp"+ex.getMessage());
}
}
public String ErrorMsg(String msg) throws WhcaException {
try {
WhcaErrorCode ErrorCode = new WhcaErrorCode();
return ErrorCode.exeErrorCode(conn, msg,0);
} catch (Exception ex) {
/**可能会发生数据库连接失败*/
whcalog.log(whcalog.REN_ZHIGUO,"ErrorMsg"+ex.getMessage());
throw new WhcaException("ErrorMsg Error"+ex.getMessage());
}
}
}
得到一个异常对象是，它将会沿着方法的调用栈逐层回溯，寻找处理这一异常的代码。找到能够处理这种类型异常的方法后，运行时系统把当前异常交给这个方法处理；如果找不到可以捕获异常的方法，则运行时系统将终止，相应的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.doczj.com/doc/4111880957.html,ng.nullpointerexception 这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话） 2. https://www.doczj.com/doc/4111880957.html,ng.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。 3. https://www.doczj.com/doc/4111880957.html,ng.arithmeticexception 这个异常的 好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。 4. 是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。 5. https://www.doczj.com/doc/4111880957.html,ng.illegalargumentexception 这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。 6. https://www.doczj.com/doc/4111880957.html,ng.illegalaccessexception 这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。算术异常类：ArithmeticExecption 空指针异常类：NullPointerException 类型强制转换异常：ClassCastException 数组负下标异常：NegativeArrayException 数组下标越界异常：ArrayIndexOutOfBoundsException 违背安全原则异常：SecturityException 文件已结束异常：EOFException 文件未找到异常：FileNotFoundException 字符串转换为数字异常：NumberFormatException 操作数据库异常：SQLException 输入输出异常：IOException 方法未找到异常：NoSuchMethodException https://www.doczj.com/doc/4111880957.html,ng.AbstractMethodError 抽象方法错误。当应用试图调用抽象方法时抛出。https://www.doczj.com/doc/4111880957.html,ng.AssertionError 断言错。用来指示一个断言失败的情况。https://www.doczj.com/doc/4111880957.html,ng.ClassCircularityError 类循环依赖错误。在初始化一个类时， 个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。https://www.doczj.com/doc/4111880957.html,ng.Error 错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。https://www.doczj.com/doc/4111880957.html,ng.ExceptionInInitializerError 初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异
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); //若不抛出异常，则运行此行
异常处理练习题 一、选择题 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语言中的异常处理机制，欢迎大家阅读! 1概述 在应用程序运行的过程中，经常会出现这样一些现象：用户不按照要求输入、需要进行处理的文件丢失、分母为零、数组下标超出预定范围、网络中断等，我们把这种现象称为异常。由于异常情况总是难免的，所以一个好的应用程序不仅要满足用户的基本需求，还要具备处理有可能出现的异常情况的能力，即程序必须具备较强的容错能力，把这种对异常进行处理的机制称为异常处理。对异常处理有两种常见方法：计算机系统遇到错误，给出出错信息并结束正在运行的程序;由程序员在程序中加入异常处理的功能。早期的程序设计语言没有提供专门进行异常处理的功能，程序员在编写程序的过程中，进行处理异常的代码往往和正常的代码混杂在一起，导致程序的可维护性和可读性下降。Java语言采取了异常处理机制，其方式为“抛出-捕获”，一个异常一旦产生，Java语言采取相应的机制来处理它，避免出现死循环、死机以及其他更大的危害，尽可能预防错误代码带来的不可预期的后果，整个程序的安全性得到了极大的提高。 2Java语言中的异常概述 Java语言提供了功能强大的异常处理机制，将所有处理异常的代码集中放置，以保证正常功能代码和处理异常的代码分开。在Java
程序设计语言中，采用了大量的异常类来进行处理，这些异常类可分为两大类：https://www.doczj.com/doc/4111880957.html,ng.Exception和https://www.doczj.com/doc/4111880957.html,ng.Error。Exception 类解决由程序本身及环境所产生的异常。而Error类则处理较少发生的内部系统错误。Exception类异常可以捕获并进行相应处理，而Error类异常，则是由用户按照系统提示关闭程序。常见的异常类如下表所示： 在以上常见的Java异常类中，每个异常类反映一类异常错误，其中包含了异常错误信息和处理方法。当程序运行过程中，出现一种异常现象，产生一个相应的异常类对象，再由相应的异常类进行处理，从而避免对系统产生更大的危害，以保证程序的正常运行。 3常见的异常处理方法 常见的异常处理方法有两种：一种处理异常是在产生异常的方法中，使用try…catch…finally结构;还有一种是进行异常的移交，使用关键字throws和throw交给上层方法去处理异常。 在该案例中，对三种异常进行了捕获，分别是数组下标越界、输入数据格式不正确和Exception异常，当触发某种异常，则对相应的异常异常进行处理。Exception异常类是所有异常的基类，当出现catch块没有进行捕获的异常，则采用Exception异常类进行异常处理。 异常的移交： 实例分析：初始化参数x使用了-2，将触发NegativeArraySizeException异常，但在Sum方法中不对该异常进
第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.doczj.com/doc/4111880957.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.doczj.com/doc/4111880957.html,ng.ArithmeticException: / by zero at exception.NotChecketException.main(NotChecketException.java:7)（2）数组越界异常：https://www.doczj.com/doc/4111880957.html,ng.ArrayInd exOutOfBoundsException 在数组下标越界时，将产生该异常，示例：
异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C开始，你也许已经知道如何用if...else...来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！Java 语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java语言设计者的高明之处，也是Java语言中的一个难点，下面是我对Java异常知识的一个总结，也算是资源回收一下。 一、Java异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误https://www.doczj.com/doc/4111880957.html,ng.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出https://www.doczj.com/doc/4111880957.html,ng.ArithmeticException的异常。 有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。 天有不测风云，人有旦夕祸福，Java的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java语言本身定义的一些基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。Exception 类及其子类是Throwable的一种形式，它指出了合理的应用程序想要捕获的条件。 异常的对象从哪里来呢？有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw 关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。 异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。 Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行，一般结构如下： try{ 程序代码 }catch(异常类型1 异常的变量名1){ 程序代码 }catch(异常类型2 异常的变量名2){ 程序代码 }finally{ 程序代码 } catch语句可以有多个，用来匹配多个异常，匹配上多个中一个后，执行catch语句块时候仅仅执行匹配上的异常。catch的类型是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异常处理作业 孙月巧 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 {
第6章异常处理机制 一、选择题 1．下列关于异常的说法正确的是（B）。 A．异常是编译时的错误 B．异常是运行时出现的错误 C．异常就是程序错误，程序错误就是异常 D．以上都不对 2．下列哪个类是异常类的父类（根类）（A）。 A．Exception B．ArithmeticException C．NullPointerException D．ArrayIndexOutofBoundException 3．有关下列异常处理机制叙述正确的是（C）。 try{ 可能产生异常的语句块; }catch(exceptiontype1 e){ 处理异常e的语句块; }catch(exceptiontype2 e){ 处理异常e的语句块; } …… finally{ 最终处理语句块; } A．try子句可能有多个，catch子句可能有多个，finally子句必须有。 B．多个catch参数中的异常类可以有父子关系，但父类异常的catch子句应该在子类异常的catch子句前面。 C．如果try子句没有抛出任何异常，则跳过catch子句，转移到finally子句继续执行。 D．当try子句监视的语句块抛出异常时，运行时系统会根据catch子句的顺序，从第一个开始，逐个查找能够捕获该异常的catch子句并执行catch子句内的语句块以完成对异常的处理，然后继续执行后面的catch子句，最后转移到finally子句，执行该子句中的语句块。4．有关throw和throws的说法中不正确的是（C）。 A．throw的作用是抛出异常，后面加的是异常类的对象。 B．throws的作用是向外抛出异常即声明要产生的若干异常，后面加的是异常类的类名。 C．throws只能声明要产生的自定义异常，也就是后面只能加自定义异常类。 D．以上都不对。 5．下列程序运行结果是（C）。 public class E { public static void main(String argv[]){ E m = new E(); System.out.println(m.amethod()); } public int amethod(){
实验四异常处理 实验目的 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 异常处理总结 找到一个关于异常总结的很详细的文章, 分享下. 异常在我们编程中很重，在适当的位置，合理的处理或者抛出异常，对程序来说至关重要。转：异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C 开始，你也许已经知道如何用if...else... 来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！ Java 语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java 语言设计者的高明之处，也是Java 语言中的一个难点，下面是我对Java 异常知识的一个总结，也算是资源回收一下。 一、Java 异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误https://www.doczj.com/doc/4111880957.html,ng.Error ；如果你用System.out.println(11/0，那么你是因为你用0做了除数，会抛出https://www.doczj.com/doc/4111880957.html,ng.ArithmeticException 的异常。有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。天有不测风云，人有旦夕祸福，Java 的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。 Java 中的异常用对象来表示。Java 对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class ），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java 语言本身定义的一些基本异常类型，二是用户通过继承Exception 类或者其子类自己定义的异常。Exception 类及其
Date、String、Calendar类型之间的转化 1.Calendar 转化String //获取当前时间的具体情况,如年,月,日,week,date,分,秒等Calendar calendat = Calendar.getInstance(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); String dateStr = sdf.format(calendar.getTime()); 2.String 转化Calendar String str="2010-5-27"; SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd"); Date date =sdf.parse(str); Calendar calendar = Calendar.getInstance(); calendar.setTime(date); 3.Date 转化String SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd"); String dateStr=sdf.format(new Date()); 4.String 转化Date String str="2010-5-27"; SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd"); Date birthday = sdf.parse(str); 5.Date 转化Calendar Calendar calendar = Calendar.getInstance(); calendar.setTime(new java.util.Date()); 6.Calendar转化Date Calendar calendar = Calendar.getInstance(); java.util.Date date =calendar.getTime();
中南财经政法大学武汉学院实验报告 实验课名称：__JAVA语言____ 学生姓名：_______ 专业班级：__网络工程1104 学号：11071125__ 开课时间：___2013年2月26日_ 教务处制
《Java程序设计基础》实验报告 实验序号：05实验项目名称:异常处理 学号11071125姓名专业、班级 实验地点计-202指导教师时间2013-5-14一、实验目的及要求 了解异常处理机制； 了解异常的概念； 掌握抛出异常、捕获异常和异常处理的方法； 了解自定义异常类的定义和使用方法。 二、实验设备（环境）及要求 1、Windows-XP操作系统 2、Eclipse应用程序 三、实验内容与步骤 编写一个类ExceptionTest1，在main方法中使用try、catch、finally： ①在try块中，编写被0除的代码。 ②在catch块中，捕获被0除所产生的异常，并且打印异常信息。 ③在finally块中，打印一条语句。 四、实验结果与数据处理 import java.util.*; public class ExceptionTest1{ public static void main(String[]args){ Scanner in=new Scanner(System.in); try{ System.out.print("请输入被除数："); double beichushu=in.nextDouble(); System.out.print("请输入除数："); double chushu=in.nextDouble(); if(chushu==0) throw new ArithmeticException("请输入不为0的数字！"); double i=(beichushu/chushu); System.out.println("二者的商为："+i);}catch(InputMismatchException e1){ System.out.println("请输入数字！");
java异常（习题） 练习 1. 填空 Java 中所有的错误都继承自______类；在该类的子类中， _______类表示严重的底层错误，对于这类错误一般处理的方式是___________；_______类表示例外、异常。 2. 查api，填空 异常类，从分类上说，该类属于__________（已检查| 未检查）异常，从处理方式上说，对这种异常___________________； 异常类，从分类上说，该类属于_________（已检 查|未检查）异常，从处理方式上说，对这种异常__________________。 （try-catch-finally）有如下代码：
要求： 1) MyException1 为已检查异常，MyException2 为未检查异常 2) 这两个异常均具有两个构造函数，一个无参，另一个带字符串参数，参数表示产生异常的详细信息。 6. （自定义异常）在上一题的基础上，把下面代码补充完整。
throws B. throws C. throws D. 不能抛出任何异常。 选择正确答案： A．编译不通过 B．编译通过，输出No Exception C．编译通过，输出ex1 D．编译通过，输出ex2 E．编译通过，输出ex3
10. *（try-catch，局部变量）有如下代码 选择正确答案： A. 编译不通过 B. 编译通过，输出-1 C. 编译通过，输出0 11. *（try-catch-finally）有如下代码
class MySuper { public void m() throws IOException { } } class MySub extends MySuper { public void m() throws EOFException { } } class MySub2 extends MySub { public void m() throws FileNotFoundException { } } 以上代码是否能编译通过如果不能，应该如何修改 14. *（自定义异常）完成某个计费系统的用户登录和注册模块，要求如下： 1）创建一个User 类，包括：用户登录名（username）、密码（password）、用户真实姓 名（name）、电子邮件地址（email）属性和相应的构造方法及set/get 方法。 2）创建两个自定义异常类，一个LoginException，表示登录异常。一个RegisterException，表示注册异常。自定义的两个异常，都要求有一个接受字符串类型参数的构造方法。 3）创建一个UserBiz 接口，该接口中定义两个方法： void register(String username, String password, String password2, String name, String email) throws RegisterException **（异常的捕获和抛出）有以下代码：
异常跟普通的警告等有一定的区别。当应用程序发生异常时，会中断正在执行的程序的正常指令流。也就是说，发生异常后面的代码将得不到正确的执行。甚至还会触发数据库的回退操作。 在Java的常见异常中，异常包括预定义异常与自定义异常。这两种异常的类型互为补充。作为一个合格的程序开发人员，要善于在应用程序中使用异常。这可以提高应用程序的交互性。同时，也是保证应用程序正常运行的前提。故异常的处理对于开发一个优秀的应用程序来说非常的重要。为此笔者认为程序开发人员应该对Java应用程序的常见异常有一个深入的了解。只有在了解这些常见异常的情况下，才能够做好自定义异常的处理。 一、Java常见异常的类型与原因。 对于Java应用程序的常见异常，笔者认为程序开发人员要从两个方面去了解。一是要知道有哪些常见的Java应用程序异常，二是需要知道哪些原因可能会造成这个异常。这不仅需要程序管理人员在日常工作中要注意积累，在必要的情况下还需要去从其它渠道收集资料。笔者对此就进行一个分析，希望能够对各位程序开发人员有一定的帮助。 1、 SQLException：操作数据库异常类。 现在的Java应用程序大部分都是依赖于数据库运行的。当Java应用程序与数据库进行沟通时如果产生了错误，就会触发这个类。同时会将数据库的错误信息通过这个类显示给用户。也就是说，这个操作数据库异常类是数据库与用户之间异常信息传递的桥梁。如现在用户往系统中插入数据，而在数据库中规定某个字段必须唯一。当用户插入数据的时候，如果这个字段的值跟现有的纪录重复了，违反了数据库的唯一性约束，此时数据库就会跑出一个异常信息。这个信息一般用户可能看不到，因为其发生在数据库层面的。此时这个操作数据库异常类就会捕捉到数据库的这个异常信息，并将这个异常信息传递到前台。如此的话，前台用户就可以根据这个异常信息来分析发生错误的原因。这就是这个操作数据库异常类的主要用途。在Java应用程序中，所有数据库操作发生异常时，都会触发这一个类。所有此时Java 应用程序本身的提示信息往往过于笼统，只是说与数据库交互出现错误，没有多大的参考价值。此时反而是数据库的提示信息更加有使用价值。 2、 ClassCastException：数据类型转换异常。 在Java应用程序中，有时候需要对数据类型进行转换。这个转换包括显示的转换与隐式的转换。不过无论怎么转换，都必须要符合一个前提的条件，即数据类型的兼容性。如果在数据转换的过程中，违反了这个原则，那么就会触发数据类型转换异常。如现在在应用程序中，开发人员需要将一个字符型的日期数据转换为数据库所能够接受的日期型数据，此时只需要在前台应用程序中进行控制，一般不会有问题。但是，如果前台应用程序缺乏相关的控制，如用户在输入日期的时候只输入月、日信息，而没有年份的信息。此时应用程序在进行数据类型转换的时候，就会出现异常。根据笔者的经验，数据类型转换异常在应用程序开发中使一个出现的比较多的异常，也是一个比较低级的异常。因为大部分情况下，都可以在应用程序窗口中对数据类型进行一些强制的控制。即在数据类型进行转换之前，就保证数据类型的兼容性。如此的话，就不容易造成数据类型的转换异常。如在只允许数值类型的字段中，可以设置不允许用户输入数值以外的字符。虽然说有了异常处理机制，可以保证应用程序不会被错误的运行。但是在实际开发中，还是要尽可能多的预见错误发生的原因，尽量避免异常的发生。 3、NumberFormatException：字符串转换为数字类型时抛出的异常。 在数据类型转换过程中，如果是字符型转换为数字型过程中出现的问题，对于这个异常在Java程序中采用了一个独立的异常，即NumberFormatException.如现在讲字符型的数据“123456”转换为数值型数据时，是允许的。但是如果字符型数据中包含了非数字型的字符，如123#56，此时转换为数值型时就会出现异常。系统就会捕捉到这个异常，并进行处理。
基于语言的异常处理机制的研究 摘要：是一种面向对象的程序设计语言，其异常处理机制是语言的一大特色。本文讨论了的异常处理机制，并指出了异常处理机制使用中的常见错误模式及注意事项，以便更好的利用解决实际问题。 关键字：; 异常; 异常处理机制; 错误模式 引言：异常是一个运行时错误。在不支持异常处理的计算机语言中，错误必须被手工检查和处理——典型的是通过错误代码的运用等等，这种方法既笨重又麻烦。的异常处理机制避免了这些问题，采用面向对象的方法来管理运行时错误。 1、异常处理思想的由来 异常即程序运行时出现的非正常情况。在程序的运行过程中随时都有可能发生错误的可能。这些错误可能是由于包含不合法的输入数据所造成的，或者是数组越界存取，还可能是因为试图使用空引用来引用对象。当这些错误发生时，通常希望程序能够智能化地处理，而不会导致系统的崩溃或数据的丢失。错误处理的终极任务就是将错误从发生地传递到能够处理它的地方。 图、传统的错误处理方式 在传统的非面向对象的编程语言中，错误处理的任务全落在程序员身上，这样做有两个去缺点，一是程序员的负担过重，二是出错处理不规范，不利于程序员之间的协作沟通，而且降低了程序的可读性。在中使用异常为程序提供了一种有效的错误处理方式,使得方法的异常中止和错误处理有了一个清晰的接口：当一个方法引发一个异常之后，可以将异常抛出，由该方法的直接或间接调用者处理这个异常。这就是常说的 (捕获抛出)方式。这种处理方式使得错误的处理规范化，程序员可以用一致的方式来处理错误。 2、的异常处理机制 异常处理机制基于三中操作：声明异常、抛出异常和捕获异常。具体见图。 声明异常告诉编译程序哪里可能出错。当一个语句引起错误时，含有这个语句的方法就 会创建一个异常对象并将它传递给系统。异常对象包含有关异常的信息，包括它的类型和出错时程序的状态。一个方法抛出异常后，运行系统开始寻找用来处理错误的代码。处理错误的代码称为异常处理器，从当前的方法开始，通过方法调用链向后搜索，查找这一代码。处理器必须与抛出的异常类型相匹配，如果未发现异常处理器，程序就会中止。任何不是被你程序捕获的异常最终都会被系统提供的默认处理程序处理。默认处理程序显示一个描述异常的字符串，打印异常发生处的堆栈轨迹并且终止程序。 3、异常处理机制的规则 具体而言的异常处理通过个关键字控制：、、、和。想要进行异常监控的代码被包含在一个块中。如果在“”块中发生异常，它被抛出。程序代码可以捕捉这个异常（用）并且用某种合理的方法处理该异常。系统产生的异常在运行时被系统自动引发。手动引发一个异常，用关键字。任何被引发方法的异常都必须通过子句定义。任何在方法返回前绝对被执行的代码都被放置在块中。下面是一个异常处理的通常形式： { } ( ) { } ( ) { }