java Exception

搞清原理很重要，基础的东西一定要扎实，给自己的一句话。

throws 定义一个方法时候可以用throws关键字声明，表示此方法不处理异常，而交给方法调用处处理。

public class MathDemo {

    public int div(int i,int j) throws Exception{//定义除法异常，如果有异常，则交给被调用处处理
        int temp=i/j;   //计算，但是此处可能出现异常
        return temp;
    }
}
//-=-=-=-=-=-=-=-=-=-=-
public class ThrowDemo{
        public static void main(String args[]){
            MathDemo m = new MathDemo();
            try {
                Log.e("mrpeng", "除法操作: "+m.div(10,2));
            } catch (Exception e) {
                e.printStackTrace();//打印异常
            }
        }
    }

div 使用了throws关键字声明，所以调用此方法的时候，方法外面必须进行异常处理，即 try…catch
如果在主方法也是用throws关键字，意味着主方法可以处理异常

public class ThrowDeno {
    public static void main(String args[]) throws Exception {
        MathDemo m = new MathDemo();
        Log.e("mrpeng", "除法操作: " + m.div(10, 2));
    }
}

主方法不处理任何异常，而交给java最大头JVM，所以如果在主方法使用了throws关键字，则表示一切异常交给JVM处理，默认处理方式也是JVM完成。

throw关键字
作用，抛出一个异常，抛出的是一个异常类的实例化对象，
在异常处理中try语句要捕获的是一个异常对象，此异常对象也可以自己抛出

public class ThisDemo06{
    public static void main(String args[]){
        try{
            throw new Exception("自己抛着玩的。") ;    // 抛出异常的实例化对象
        }catch(Exception e){
            System.out.println(e) ;
        }
    }
}

一般开发中 try catch finally ,throw,throws联合使用情况最多

class Math{
    public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理
        System.out.println("***** 计算开始 *****") ;
        int temp = i / j ;    // 计算，但是此处有可能出现异常
        System.out.println("***** 计算结束 *****") ;
        return temp ;
    }
};
public class ThrowDemo02{
    public static void main(String args[]){
        Math m = new Math() ;
        try{
            System.out.println("除法操作：" + m.div(10,0)) ;
        }catch(Exception e){
            System.out.println("异常产生：" + e) ;
        }
    }
};
运行结果：

***** 计算开始 *****
异常产生：java.lang.ArithmeticException: / by zero

以上计算结束，因为没有异常发生了，直接中断程序操作，所以做以下操作。

class Math{
    public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理
        System.out.println("***** 计算开始 *****") ;
        int temp = 0 ;    // 定义局部变量
        try{
            temp = i / j ;    // 计算，但是此处有可能出现异常
        }catch(Exception e){
        }
         System.out.println("***** 计算结束 *****") ;
        return temp ;
    }
};
public class ThisDemo06{
    public static void main(String args[]){
        Math m = new Math() ;
        try{
            System.out.println("除法操作：" + m.div(10,0)) ;
        }catch(Exception e){
            System.out.println("异常产生：" + e) ;
        }
    }
};
运行结果：

***** 计算开始 *****
***** 计算结束 *****
异常产生：java.lang.ArithmeticException: / by zero

这里异常在方法中自动被处理，并没有抛出去，要抛出异常对象，给方法调用处处理，需要使用throw关键字

class Math{
    public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理
        System.out.println("***** 计算开始 *****") ;
        int temp = 0 ;    // 定义局部变量
        try{
            temp = i / j ;    // 计算，但是此处有可能出现异常
        }catch(Exception e){
            throw e ;　　　　//抛出异常。使用中也可用if判断  不用try catch
        }finally{    // 不管是否有异常，都要执行统一出口
            System.out.println("***** 计算结束 *****") ;
        }
        return temp ;
    }
};
public class ThisDemo06{
    public static void main(String args[]){
        Math m = new Math() ;
        try{
            System.out.println("除法操作：" + m.div(10,0)) ;
        }catch(Exception e){
            System.out.println("异常产生：" + e) ;
        }
    }
};

总结

throw与throws关键字联合使用问题。

1）throw：抛出异常。

2）throws：在方法声明处使用，表示此方法不处理异常，而在调用此方法处处理异常。

Exception是必须处理的，而RuntimeException异常是可以不处理的。但是为了保证程序正常运行，最好处理。

如果自定义异常，直接继承异常即可。

关于try catch finally 中的return问题
* 情况1：try{} catch(){}finally{} return;
显然程序按顺序执行。
* 情况2:try{ return; }catch(){} finally{} return;
程序执行try块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，最后执行try中return;
finally块之后的语句return，因为程序在try中已经return所以不再执行。
* 情况3:try{ } catch(){return;} finally{} return;
程序先执行try，如果遇到异常执行catch块，
有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，最后执行catch块中return. finally之后也就是4处的代码不再执行。
无异常：执行完try再finally再return.
- 情况4:try{ return; }catch(){} finally{return;}
程序执行try块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，因为finally块中有return所以提前退出。
- 情况5:try{} catch(){return;}finally{return;}
程序执行catch块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，因为finally块中有return所以提前退出。
- 情况6:try{ return;}catch(){return;} finally{return;}
程序执行try块中return之前（包括return语句中的表达式运算）代码；
有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；
则再执行finally块，因为finally块中有return所以提前退出。
无异常：则再执行finally块，因为finally块中有return所以提前退出。

结论：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值