JAVA中的异常处理

 JAVA中的异常概念：

 1：异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java通 过API中1：：Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的 错误条件。当条件生成时，错误将引发异常。

:2一些RuntimeException 如空指针异常 数组越界异常 属于运行时异常直接由jvm 抛出异常，编译阶段不会提醒

3受查异常：例如sql异常 等属于别人编写类的时候利用throws关键字声明了这个方法的异常所以需要处理：

      除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

3异常处理机制

3.1 由于运行时异常的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。

3.2   对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常

3.3对于所有的可查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。

      能够捕捉异常的方法，需要提供相符类型的异常处理器。所捕捉的异常，可能是由于自身语句所引发并抛出的异常，也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。

先抛出再捕获。

PS:

注意：

 任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。

        从方法中抛出的任何异常都必须使用throws子句。

        捕捉异常通过try-catch语句或者try-catch-finally语句实现。

         总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

小结：

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。

catch 块：用于处理try捕获到的异常。

finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：

1）在finally语句块中发生了异常。

2）在前面的代码中用了System.exit()退出程序。

3）程序所在的线程死亡。

4）关闭CPU。

：下面以int a=1/0；这个runtime异常说明基本的异常处理

  我主要是异常的几种处理方式混合使用--抛出自己的自定义异常  try 。。。。catch捕获异常

首先自定义自己的异常类并且重写自己的message方法：

public class Message extends Exception {

/**
* 信息代码
*/
private String msgCode = "";

/**
* 备注信息。
*/
private String msgRemark = "";

/**
* 根据msgCode查找到的提示信息。
*/
private String msgInfo = "";

public Message() {
}

public Message(String msgCode) {
this.setMsgCode(msgCode.trim());

}

/**
* 创建信息对象。
* <p>
* 1、调用setMsgCode(msgCode)方法。<br>
* 2、调用setMsgRemark(msgRemark)方法。
*
* @param msgCode
* 错误信息代码
* @param msgRemark
* 错误信息备注
*/
public Message(String msgCode, String msgRemark) {
this.setMsgCode(StringUtil.trimStr(msgCode));
this.setMsgRemark(StringUtil.trimStr(msgRemark));

}

/**
* 获取提示信息。
* <p>
* 返回的信息。 返回信息格式为：msgCode：msgInfo【msgRemark】。
*
* @return String
*/
public String getMsgInfo() {
String returnMsg = "";
if (msgInfo != null && !msgInfo.equals("")) {
returnMsg += msgCode + "：" + msgInfo;
}
if (msgRemark != null && !msgRemark.equals("")) {
returnMsg += "【" + msgRemark + "】";
}
return returnMsg;
}

@Override
public String getMessage() {
return this.getMsgInfo();
}

/**
* 设置提示信息。
* <p>
* 1、查询msgCode在系统中是否定义。若未定义则throw
* RuntimeException("未定义错误代码["+msgCode+"]，请定义后再使用。")。<br>
* 2、查询msgCode所对应的提示信息。<br>
* a)直接在数据库中查询。<br>
* b)程序启动时初始化，然后在初始化的对象中获得。<br>
* 3、this.msgCode = msgCode。 this.msgInfo = 2中查询的信息。
*
* @param msgCode
*/
public void setMsgCode(String msgCode) {
// this.msgInfo = ErrorCode.getErrorMsg(msgCode.trim());
this.msgInfo = msgCode;
this.msgCode = msgCode.trim();
}

/**
* 设置备注信息
*
* @param msgRemark
* 备注信息
*
*/
public void setMsgRemark(String msgRemark) {
this.msgRemark = msgRemark.trim();
}

public String getMsgCode() {
return msgCode;
}

public String getMsgRemark() {
return msgRemark;
}

下面是自己的测试类：public class Throws {
//声明一个方法：这个方法有可能会出现异常（就和mysql中定义的方法都抛出一个异常）
public static void testException() throws Exception {
//假设这里面捕获的是mysql异常(这个异常最好向上抛出)
try {
int i=1/0;
System.out.println("hahhaa我这个方法存在异常");
//throw new Exception();
} catch (Exception e) {
// TODO Auto-generated catch block
//e.printStackTrace();//这里我假如捕获的异常不抛出，后面方法调不到
//e.printStackTrace();
//抛出我的自定义异常
throw new Message("1","除数不能为0");
//throw e;
}finally{
System.out.println("我会执行吗");
}
System.out.println("来吧");
}
public static void test2() throws Exception {
testException();
}
public static void main(String[] args) {
//由于别人定义的方法中：抛出了异常所以你要么继续抛这个异常，要么try
//。。。catch捕获这个异常
//选择继续往上抛异常，程序会交给虚拟机估计所以程序不会执行了
//此时他不再抛了程序交给catch
// 第一种情况
try {
test2();
} catch (Exception e) {
// TODO Auto-generated catch block
//e.printStackTrace();
System.out.println("我捕获到我的自定义异常了"+e.getMessage());
}
/*test2();//程序继续抛出异常，异常交给了JVM执行所以程序不再执行下去
*/ //抛出的异常最后都需要自己处理一下
System.out.println("sss");
System.out.println("我还可以继续执行");
//testException();
}

}


特别说明：假如我最后不处理我的异常让异常继续在main方法里继续 throws，这个异常就会交给虚拟机处理（程序不会继续执行）

public static void main(String[] args) throws Exception
/*test2();//程序继续抛出异常，异常交给了JVM执行所以程序不再执行下去
*/ //抛出的异常最后都需要自己处理一下
System.out.println("sss");
System.out.println("我还可以继续执行");  



                 但是如果我在最顶端try。。。catch捕获这个异常，程序会继续执行：

// 第一种情况
try {
test2();
} catch (Exception e) {
// TODO Auto-generated catch block
//e.printStackTrace();
System.out.println("我捕获到我的自定义异常了"+e.getMessage());
}



综上所述：异常2种处理情况：要么直接try。。。catch捕获到异常，抛出一个自定义异常---要么继续向上抛出--总之必须在最后一次根据业务需要将异常处理