通过异常处理错误
1、基本异常
（1）普通问题：在当前的环境下能够得到足够的信息，总可以处理该错误；
（2）异常情形（execptional condition）：是指阻止当前方法或作用域继续执行的问题，在当前的环境下无法获取必要的信息来解决问题，必须从当前环境跳出，并将问题提交给上一级环境，这是抛出异常发生的事情；
（3）在Java中，
Throwable是所有异常类的基类，Throwable对象可以分为两类：
①Error：表示编译时和系统错误（一般不需要客户端程序员关心）；
②Exception：可以被抛出的异常类型；
※RunTimeException是一个特殊的Exception，如果这个类型
的异常没有被捕获而直达main（），那么程序在退出前将自动调用异常的printStackTrace()方法；
※可以把异常看成一种内建的恢复（undo）系统，在程序中可以拥有各种不同的恢复点，当程序某部分运行失败时，异常将“恢复”到程序已知的某个稳定点上；
2、异常参数
一般Java的异常类由两种构造器：
默认构造器、接收解释性字符串参数的构造器；
3、捕获异常
（1）监控区域（guarded region）：一段可能产生异常的代码，并且后面要跟随处理这些异常的代码；
（2）Java使用try{ }块放置异常可能抛出异常的代码，并使用catch块捕获try块所有抛出的异常，使用finally块进行清除；
try{ statments；}
catch（Exception ex）{ statements； }
finally{ dispose statments；}
（3）finally子句
①对于没有垃圾回收和析构函数自动调用机制的语言而言，finally子句非常重要，它能使程序员保证：
无论try发生什么，内存总是能够得带释放；
②对于Java，finally适用于内存回收之外的情况，即在程序结束，在垃圾回收器回收垃圾之前，要完成的动作；
③在Java中，finally比较大应用为：把除了内存之外的资源恢复到他们的初始状态，比如：比如已经打开的文件或网咯连接，再屏幕上画入队图形，甚至是外部世界的某个开关；
④因为finally总是会被执行，所以在一个方法中，可以使用return从多个点返回：
- void count(int num){
- try{
- System.out.println(”count 1”);
- if(num == 1) return;
- System.out.println(”count 2”);
- if(num == 2) return;
- System..out.println(”count 3”);
- }finally{
- System.out.println(”All count!”);
- }
- }
void count(int num){
try{
System.out.println("count 1");
if(num == 1) return;
System.out.println("count 2");
if(num == 2) return;
System..out.println("count 3");
}finally{
System.out.println("All count!");
}
}
4、终止和恢复
异常处理理论上有两种模型：终止模型和恢复模型；
（1）终止模型：Java和C++都支持终止模型，基于某种错误假设，程序午饭返回到异常发生的地方继续执行；
（2）恢复模型：异常处理程序的工作是修正错误，然后重新调用方法来修正错误，并认为第二次可能成功；
使用Java实现恢复模型，有2中方法：
①在遇见错误时不能抛出异常，而是调用方法来修正该错误；
②将try块放在while循环中，这样就可以不断进入try块，直到满意结果；
- int[ ] list =new int[3];
- int index = 5;
- whlie(true){
- try{
- list[index] = 1024; //list[5] = 1024 抛出异常，并被下面catch捕获，每次抛出异常，重新进入try块
- break; //当上面try的代码不抛出异常时，跳出while（true）循环；
- }catch(ArrayIndexOutOfBoundsException ex){
- ex.printStackTrace(System.err);
- }finally{
- System.out.println(”Ready insert array”);
- }
- }
int[ ] list =new int[3];
int index = 5;
whlie(true){
try{
list[index] = 1024; //list[5] = 1024 抛出异常，并被下面catch捕获，每次抛出异常，重新进入try块
break; //当上面try的代码不抛出异常时，跳出while（true）循环；
}catch(ArrayIndexOutOfBoundsException ex){
ex.printStackTrace(System.err);
}finally{
System.out.println("Ready insert array");
}
}
5、
自定义异常：
必须从已有的异常类继承，一般选择意思相近的异常类继承，然后直接使用默认构造器或字符串构造器，就基本足够需求了；
6、异常的输出流比较：
（1）
catch(Exception ex){ e.printStackTrace(System.out); }
写入
标准输出流，但是System.out可能会被重定向到文件输出流、IO输出流中；
（2）
catch(Exception ex){ e.printStackTrace(); }
写入
标准错误流，不会被重定向，Java中装门用于输出异常信息；
7、异常和记录日志
可以使用java.util.logging日志和记录工具来见输出记录到日志中：
- import java.util.logging.*;
- import java.io.*;
- //构建可写入日志的异常类
- public class LoggingException extends Exception{
- private static Logger logger = Logger.getLogger(“LoggingException”); //构建Logger日志对象
- public LoggingException(){
- StringWriter trace = new StringWriter(); //回收字符缓冲区中的输出来构造字符串字符流；
- //printStackTrace(new PrintWriter(trace)); //将该字符串流格式加入到栈轨迹后，写入标准输出流；
- logger.severe(trace.toString()); //通过logger发送一条指定内容的severe到标准输出；
- }
- }
import java.util.logging.*;
import java.io.*;
//构建可写入日志的异常类
public class LoggingException extends Exception{
private static Logger logger = Logger.getLogger("LoggingException"); //构建Logger日志对象
public LoggingException(){
StringWriter trace = new StringWriter(); //回收字符缓冲区中的输出来构造字符串字符流；
//printStackTrace(new PrintWriter(trace)); //将该字符串流格式加入到栈轨迹后，写入标准输出流；
logger.severe(trace.toString()); //通过logger发送一条指定内容的severe到标准输出；
}
}
//测试异常类
- public class LoggingExceptions {
- public static void main(String[] args){
- try{
- throw new LoggingException();
- }catch(LoggingException ex){
- System.err.println(”Caught ”+ex);
- }
- }
- }
public class LoggingExceptions {
public static void main(String[] args){
try{
throw new LoggingException();
}catch(LoggingException ex){
System.err.println("Caught "+ex);
}
}
}
8、异常说明：throws关键字
（1）如果提供了源代码，客户端程序员可以在源代码中查找throw语句来获知相关信息，但是一般程序不会和源代码一起发布；
（2）为了解决这个问题，
java提供了throws语法，并且强制使用，告知客户端程序员某个方法可能抛出的异常；
void method（） throws Exception1,Exception2…(异常列表) { }
（3）
可以声明方法将抛出异常，实际上却不抛出，编译器会强制用户抛出该异常并对其进行捕获处理，这样能使该类的派生类或接口能抛出该种异常，并重用代码；
9、捕获所用异常
（1）
Throwable是Java所有异常和错误的基类（Exception，Error），
Exception是所有编程异常类的基类；
①Exception继承自Throwable的方法：
String getMessage( )：获取详细信息；
String getLocalizedMessage( )：用本地语言表示的详细信息；
String toString( )：返回对Throwable的简单描述（包含详细信息）；
②Exception继承自Object方法：
getClass( )：获取表示此类对象类型的对象
getName( )：返回该Class包含信息的名称；
getSimpleName( ): 返回Class类名；
③Exception自身方法：
void printStackTrace( )：打印Throwab和Throwabl的调用轨迹；
void printStackTrace(PrintStream)：
void printStackTrace(java.io.PrintWriter)：
Throwable fillInStackTrace（）：同于在Thowable对象的内部记录栈帧的当前状态；
（2）栈轨迹
getStackTrace( )返回一个有栈轨迹中的元素（StackTraceElement）所构成的数组，其中的每一个元素都表示一帧，元素0是栈顶元素（调用序列的最后一个方法抛出的，该Throwable被创建和抛出之处）；
（3）重新抛出异常
重抛异常会把
异常重新抛给上一级环境中的异常处理程序，同一个try中的后续catch子句会被忽略，同时异常对象的所有信息都会被保存；
①直接将异常对象重新抛出，使用printStackTrace（）显示将是原来异常抛出点的的调用栈信息；
②使用抛出 Throwable fillInStackTrace（）可以更新抛出点，（栈轨迹会从重新抛出点开始）；
- public class Rethrowing {
- public static void srcMethod() throws Exception{
- throw new Exception(“throw from srcMethod;”);
- }
- //直接抛出
- public static void a() throws Exception{
- try{ srcMethod();
- }catch(Exception ex){
- ex.printStackTrace(); //用作抛出前后栈轨迹的对比；
- throw ex;
- }
- }
- //用fillInStackTrace（）对抛出位置进行更新后(更新栈底)，再抛出
- public static void b() throws Exception{
- try{ srcMethod();
- }catch(Exception ex){
- ex.printStackTrace(); //用作抛出前后栈轨迹的对比；
- throw (Exception)ex.fillInStackTrace();
- }
- }
- //测试两种抛出方式的区别
- public static void main(String[] args){
- //测试a（）
- try{ a();}
- catch(Exceptionex){ ex.printStackTrace(); }
- //测试b（）
- try{ b(;}
- catch(Exceptionex){ ex.printStackTrace(); }
- }
- }
public class Rethrowing {
public static void srcMethod() throws Exception{
throw new Exception("throw from srcMethod;");
}
//直接抛出
public static void a() throws Exception{
try{ srcMethod();
}catch(Exception ex){
ex.printStackTrace(); //用作抛出前后栈轨迹的对比；
throw ex;
}
}
//用fillInStackTrace（）对抛出位置进行更新后(更新栈底)，再抛出
public static void b() throws Exception{
try{ srcMethod();
}catch(Exception ex){
ex.printStackTrace(); //用作抛出前后栈轨迹的对比；
throw (Exception)ex.fillInStackTrace();
}
}
//测试两种抛出方式的区别
public static void main(String[] args){
//测试a（）
try{ a();}
catch(Exceptionex){ ex.printStackTrace(); }
//测试b（）
try{ b(;}
catch(Exceptionex){ ex.printStackTrace(); }
}
}
（4）异常链
①异常链：在捕获一个异常对象后再抛出一个异常对象啊，并且希望把原始异常的信息保存下来，使用Throwable类中的cause（因由）参数表示原始异常，于是可以
通过Throwable中的cause参数追踪到异常最初发生的位置；
②cause赋值：
a.通过Throwable带cause参数的构造器创建，在Java中只有Error，Exception，RuntimeException可以使用该方式；
b.使用Throwable的initCause（）方法；
- public class ExceptionCause{
- private static void test1(){ throw new NullPointerException( ); }
- private static void test2(){
- try{ test1(); }
- catch(NullPointerException ex){
- //①使用指定的cause参数构造Exception;
- throw new Exception(ex);
- //②使用initCause（）方法指定Throwable的cause参数；
- /*Exception bussinessEx = new Exception ();
- bussinessEx.initCause(ex);
- throw bussinessEx; */
- //③使用fillInStackTrace方法更新抛出点，不可能通过编译，因为Throwable的cause不能使它自身；
- /*throw (Exception)ex.fillInStackTrace().initCause(ex); */
- ex.printStackTrace();
- }
- }
- public static void main(String[] args){
- test2();
- }
- }
public class ExceptionCause{
private static void test1(){ throw new NullPointerException( ); }
private static void test2(){
try{ test1(); }
catch(NullPointerException ex){
//①使用指定的cause参数构造Exception;
throw new Exception(ex);
//②使用initCause（）方法指定Throwable的cause参数；
/*Exception bussinessEx = new Exception ();
bussinessEx.initCause(ex);
throw bussinessEx; */
//③使用fillInStackTrace方法更新抛出点，不可能通过编译，因为Throwable的cause不能使它自身；
/*throw (Exception)ex.fillInStackTrace().initCause(ex); */
ex.printStackTrace();
}
}
public static void main(String[] args){
test2();
}
}
10、异常的限制
当覆盖方法时，只能抛出基类方法的异常说明里列出的那些异常，这意味着，当基类的代码应用到其派生对象时，也可以正常工作（保证向上转型）；
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
