Java day15【第二十七章】异常的捕获及处理.

【第二十七章】异常的捕获及处理

四.异常处理流程

　　要想进行合理异常就必须清楚异常产生之后程序做了哪些事情。

 

 

 

　　通过分析我们发现整个异常处理流程中操作的其实是一个异常类的实例化对象，该对象成为我们理解异常处理的核心关键所在，之前接触过俩种异常： 

　　

java.lang.Object
　　java.lang.Throwable
　　　　java.lang.Exception
　　　　　　java.lang.RuntimeException
　　　　　　　　java.lang.IndexOutOfBoundsException
　　　　　　　　　　java.lang.ArrayIndexOutOfBoundsException

 　　可以发现程序之中可以处理的最大类型就是Throwable，而打开Throwable提供有俩个子类：

　　（1）Error：此时程序还未执行出现的错误，无法处理。

　　（2）Exception：程序中出现的异常。

　　通过分析可以发现异常产生的时候回产生异常的实例化对象，按照对象的引用原则，可以自动向父类转型。

所以所有的异常都可以使用Exception来处理。

范例：简化异常处理：

public class Exceptiono {
    public static void main(String args[]){
        System.out.println("开始执行程序");
        try{
            int x = Integer.parseInt(args[0]);
            int y = Integer.parseInt(args[1]);
            System.out.println("数学计算："+(x/y));
        }catch(ArithmeticException e){
            e.printStackTrace();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            System.out.println("【F】不管程序异常是否处理，程序都继续执行");
        }
        System.out.println("程序执行完毕");    
        }
}

　　如果此时有多个异常处理，那么范围大的一定要放在后面。

　　这种异常的处理虽然简便，但是它描述的错误信息不全面，所以分开处理异常是可以更加明确的处理。

五.throws关键字

　　需要明确告诉使用者这个方法可能会产生何种异常，在方法的声明上利用throws关键字。

 范例：观察throws

class MyMath{
    public static int div(int x ,int y) throws Exception {
        return (x/y);
    }
}
public class Exceptiono{
    public static void main(String args[]){
        try{
            System.out.println(MyMath.div(10, 2));
        }catch(Exception e){
            System.out.println("There is a exception");
        }        
    }    
}

范例：在主方法上继续抛出异常

class MyMath{
    public static int div(int x ,int y) throws Exception {
        return (x/y);
    }
}
public class Exceptiono{
    public static void main(String args[]) throws Exception{
            System.out.println(MyMath.div(10, 0));
        }        
    }    
}

　　如果主方法继续向上抛出异常，那么表明此异常将交给JVM进行处理。

六.throw关键字

　　与throws对应的还有throw关键字，此关键字的主要作用在于表示手工进行异常的抛出，此时将手工产生一个异常类的实例化对象，并且进行异常的抛出处理。

范例：观察throw的使用

public class Exceptiono{
    public static void main(String args[]){
            try{
                throw new Exception("自己抛出的异常");
            }catch(Exception e){
                e.printStackTrace();
            }
    }
}    

　　throw是自己抛出异常

面试题：throw与throws的区别：

　　throw：是在代码块中使用的，主要是手工进行异常对象的抛出

　　throws：是在方法定义上使用的，便是将此方法可能产生的异常告诉调用处。

七.异常处理模型

　　现在要求定义一个可以实现除法计算的方法

class MyMath{
    public static int div(int x, int y) throws Exception{
        int temp = 0;
        System.out.println("***【Begin】除法计算开始");
        try{
            temp = x/y;
        }catch(Exception e){
            throw e;　　　　　　　　//向上抛异常对象
        }finally{
            System.out.println("***【End】除法计算结束");
        }
        return temp;
    }
}
public class Exceptiono{
    public static void main(String args[]){
            try{
                System.out.println(MyMath.div(10,0));
            }catch(Exception e){
                e.printStackTrace();
            }
    }
}

　　对于此类操作实际上可以省略catch语句。

八.RuntimeException

java.lang.Object
　　java.lang.Throwable
　　　　java.lang.Exception
　　　　　　java.lang.RuntimeException
　　　　　　　　java.lang.IndexOutOfBoundsException
　　　　　　　　　　java.lang.ArrayIndexOutOfBoundsException

　　如果现在所有的程序执行上只要使用了throws定义的方法都必须进行手工处理，那么代码编写就很麻烦

所以在设计过程中，提供有一个灵活的可选的异常处理父类“RuntimeException”，这个类的子类不需要强制处理

面试题：请解释RuntimeException与Exception的区别？

　　RuntimeException是Exception的子类；

　　RuntimeException标注的异常可以不进行强制性处理，但是Exception异常必须强制性处理；

九.自定义类异常

　　实际开发中JDK异常类型未必够你使用，所以我们考虑自定义异常类

　　自定义类型的俩种方式：继承Exception或者继承RuntimeException

范例：实现自定义异常

class BoomException extends RuntimeException{
    public BoomException(String msg){
        super(msg);
    }
}
class Food{
    public static void eat(int num) throws BoomException{
        if(num > 10){
            throw new BoomException("You have ate too much");
        }else{
            System.out.println("Eating");
        }
    }
}
public class Exceptiono{
    public static void main(String args[]){
        Food.eat(11);
    }
}

十.assert断言

　　断言：确定代码执行到某行之后一定是所期待的结果

　　断言不一定是准确的