Java 异常处理

一、异常基本结构

在处理方法时有两种选项
要么就try-catch-finally捕获异常(handle),要么就声明异常抛出(declare).

try-catch-finally 规则:catch 与特定异常类的类型相关

一个try 可能有多个catch 块，但是只将执行一个处理块，法则：要按从最具体到最一般的顺序组织处理块。
除如下情况，总将执行finally 块作为结束
    JVM 过早终止，(System.exit(int));
    finally 块中抛出一个未处理的异常
    计算机断电，失火，或者遭遇病毒攻击
特别注意，try-catch-finally 和return 在一起的用法
在return 语句执行的时候，必定要先去执行finally 块中的代码。

public class HelloWorld {
 public static void main(String []args){
  try {
   return ;
  } catch (Exception ex){
   ex.printStackTrace();
   System.out.println("++++"+ex.getMessage());
  } finally{
   System.out.println("output:AAAA");
  }
 }
}

output:AAAA
虽然方法做了返回，但是finally 块中的语句还是要执行的。

声明异常
声明异常传给方法调用者，也通知编译器，该方法的任何调用者必须遵守处理或声明规则。
声明规则
必须声明方法可能抛出的任何可检查异常(checked Exception)。
非检查异常(unchecked Exception)不是必须的，可声明可不声明。
调用方法必须遵守任何可检查异常的处理或者声明规则，若覆盖一个方法，则不能声明和覆盖方法不同的异常，声明的任何异常
必须都是被覆盖方法的同类或者子类。

二、异常处理技术和实践
那么是选择处理异常，还是选择抛出呢？
一搬原则：尽可能的处理异常，如果没有能力处理则选择抛出。
但是缺少通用性，比如客户端调用服务器程序，如果断网了，抛出IOException，不能连接到服务器，可以有多种方式来处理
等一会再连接
尝试连接同一服务器的不同端口
显示一条消息，提示连接失败。等等
此时，如果把异常处理信息写在服务器端。缺少通用性，只能满足特定的客户端请求。如果把这个异常抛出，让客户端自己
负责选择正确的方法处理。
异常处理的一般原则：
  (1) 尽可能的处理异常
  (2) 具体问题具体分析，为了特定类型问题构建特定的处理块
  (3) 记录可能影响应用程序运行的异常，把异常写入日志
处理异常是忌讳的事情
  (1) 不要忽视异常
  (2) 不要使用覆盖式异常处理块
      try{
         //
      } catch(Exception ex){
         //
      }
     覆盖式异常处理，如果抛出的是预期中的异常，则一切正常，如果抛出的是未预料的异常，则无法看到要采取的操作。当
    覆盖式异常在处理千遍一律的任务时，只能间接看到异常处理结果。
  (3) 一搬不要将特定异常转换为更通用的异常
     try {
        //
     } catch(IOException ex){
      throw Exception();
     }
     这将取消异常起初抛出时产生的上下文，将异常传到系统的其他位置上去。在这里抛出通用异常，对开发者没有任何帮助作用
     都不知道恢复那种操作，一般而言如果要重新抛出异常，要有三个理由
     1，重新抛出同一个异常，以采取一些操作，然后传递异常，做下一步处理
     2，包装或者重新抛出更具体的异常类型，以缩小后继处理器的问题类型
     3，包装或者抛出不同类型的异常，转换为适当的上下文，提供不同应用程序子系统处理器，转换为异常业务时，一般这样做
   
   (4) 不要处理能避免的异常
      为不可避免的错误使用异常，若能避免则可不使用异常。通常RuntimeException 属于此范畴。比如空指针和数组索引问题
      这些问题都可以提前采取预防措施进行处理
      if(ref!=mull){
            //code work
      }
    
  三，高级异常处理概念
   (1) 如何创建自定义异常,自定义异常将自动继承Throwable 的错误消息和栈跟踪
     

public class CustExitException extends Exception {
	public CustExitException() {
	}

	public CustExitException(String message) {
		super(message);
	}
}

   (2) 异常链表
 在应用程序中设置异常之间的起因关系，如果捕获的一个异常，并且抛出一个与错误异常相对应的自定义异常。一般而言会
 失去原始异常的所有信息。或者需要添加附件信息来存储。通过链表异常则可以把原始信息和自定义信息关联起来。

 //定义异常类

class ConnectionExitException extends Exception {
	// 方法(1)
	public ConnectionExitException(String message) {
		super(message);
	}
	
	// 方法(2)
	public ConnectionExitException(Throwable cause) {
		super.initCause(cause);
	}
}

//主调方法

public class HelloWorld {
	public static void main(String[] args) throws ConnectionExitException {
		try {
			Object o = null;
			o.toString();
		} catch (Exception ex) {
			throw new ConnectionExitException("对象不能null"); // 在这一步，如果调用自定义异常的第一个构造方法，使用额外信息才能找到原始异常
			// throw new ConnectionExitException(ex);
			// //如果调用这一步，调用第二个方法，在设置了起因以后，创建的异常对象将会在剩余的生命周期里面存储相同的起因。
		} finally {

		}
	}
}

 //out put   调用方法(1)的输出
 Exception in thread "main" cn.com.chenlly.ConnectionExitException: 对象不能null
 at cn.com.chenlly.HelloWorld.main(HelloWorld.java:8)
 
 //out put 调用方法(2) 的输出，Caused by：后面的值就是原始异常的信息.
 Exception in thread "main" cn.com.chenlly.ConnectionExitException
 at cn.com.chenlly.HelloWorld.main(HelloWorld.java:9)
 Caused by: java.lang.NullPointerException
  at cn.com.chenlly.HelloWorld.main(HelloWorld.java:6)

 

四、异常结构图

   异常结构图(1)

     

 

    异常结构图(2)

   

五、异常案例分析 

public static void main(String[] args) {
		try { //(5)
			OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(
					new File("E\\1.txt")));
			Class.forName("");
			Connection conn = DriverManager.getConnection("", "", "");
			Statement stat = conn.createStatement();
			ResultSet rs = stat.executeQuery("select uid, name from user");
			while (rs.next()) {
				out.write("ID：" + rs.getString("uid") + ",姓名："
						+ rs.getString("name")); // (6)
			}
			conn.close(); // ⑶
			out.close();
		} catch (Exception ex) { // ⑵
			ex.printStackTrace(); // ⑴，⑷
		}
	}

存在的问题以及总结：

(1)、丢弃异常
代码捕获了异常却不作任何处理。调用一下printStackTrace算不上"处理异常"。不错，调用printStackTrace对调试程序有帮助
但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责任了。 应该怎样改正呢？主要有四个选择：
    1、处理异常。针对该异常采取一些行动
例如修正问题、提醒某个人、输出日志或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经"处理好了异常"。
2、重新抛出异常。
    结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。 
(2)、不指定具体的异常
用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exception ex)语句
    结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch。不要试图处理所有可能出现的异常。 
(3)、占用资源不释放 
异常改变了程序正常的执行流程。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。
    结论三：保证所有资源都被正确释放。充分运用finally关键词。
(4)、不说明异常的详细信息 
如果循环内部出现了异常,我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。
    结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。 
(5)、过于庞大的try块 ，经常可以看到有人把大量的代码放入单个try块，做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出
结论五：尽量减小try块的体积。 
(6)、输出数据不完整
考虑一下如果循环的中间抛出了异常，循环的执行当然是要被打断的。。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的（因而也是错误的）数据，却得不到任何有关这份数据是否完整的提示。
  结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。 

修改后程序:

	public static void main(String[] args) {
		OutputStreamWriter out = null;
		Connection conn = null;
		try {
			out = new OutputStreamWriter(new FileOutputStream(new File(
					"E\\1.txt")));

			Class.forName("");

			conn = DriverManager.getConnection("", "", "");

		} catch (FileNotFoundException e) {
			System.out.println("文件不存在！");
		} catch (ClassNotFoundException e) {
			System.out.println("加载JDBC驱动出现错误！");
		} catch (SQLException e) {
			System.out.println("获取Connection出现错误");
		}

		try {
			Statement stat = conn.createStatement();
			ResultSet rs = stat.executeQuery("select uid, name from user");
			while (rs.next()) {
				out.write("ID：" + rs.getString("uid") + "，姓名: "
						+ rs.getString("name"));
			}
		} catch (SQLException sqlex) {
			try {
				out.write("警告：数据不完整");
			} catch (IOException e) {
				System.out.println("写入警告数据出现错误");
				e.printStackTrace();
			}
			// 抛出
			System.out.println("读取数据时出现SQL错误");
		} catch (IOException ioex) {
			// 抛出
			System.out.println("写入数据时出现IO错误");
		} finally {
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException sqlex2) {
					System.out.println("不能关闭数据库连接: " + sqlex2.toString());
				}
			}
			if (out != null) {
				try {
					out.close();
				} catch (IOException ioex2) {
					System.out.println("不能关闭输出文件" + ioex2.toString());
				}
			}
		}
	}