第09章 异常

/*****************
***第09章 异常
*******知识点:
**************1.异常的基础知识
**************2.异常类类图
**************3.异常关键字  
**************4.异常处理机制 
**************5.异常继承
**************6.异常小结
*/

/*
*演示用的自定义异常类
*/
class MyException extends Exception{
    private String msg;
    public MyException(String msg){
        super();
        this.msg = msg;
    }
    public String toString(){
        return ("异常信息：" + msg);
    }
}

public class test9{
    public static void main(String[] args){
        showDemo("1.异常的基础知识");
        demoExceptionBasicKnowledge();//演示1.异常的基础知识
        
        showDemo("2.异常类类图");
        demoExceptionClassView();//演示2.异常类类图
        
        showDemo("3.异常关键字");
        demoExceptionKeyWord();//演示3.异常关键字
        
        showDemo("4.异常处理机制");
        demoExceptionHandle();//演示4.异常处理机制
        
        showDemo("5.异常继承");
        demoExceptionExtend();//演示5.异常继承
        
        showDemo("6.异常小结");
        demoExceptionNote();//演示6.异常小结
    }
    
    /*
    *1.异常的基础知识
    */
    public static void demoExceptionBasicKnowledge(){
        //异常————非正常情况，出现这样错误其实是程序上的错误。其中包括逻辑错误和系统错误
        //比如：数组下标越界、除数为0、内存溢出等
    }
    
    /*
    *2.异常类类图
    */
    public static void demoExceptionClassView(){
        //异常类的根类————java.lang.Throwable  其中有两个子类分别为：Error、Exception
        // 1.Error类：无法处理的异常，也成为错误。如：操作系统错误、内存硬件损坏等(编程时无需关心这类异常)
        // 2.Exception类:可处理的异常。其中有两个子类分别为：RuntimeException和非RuntimeException
        //                                (有时也称为unchecked exception——非检查异常(RuntimeException) 和checked exception——检查异常)
        //        2.1RuntimeException：运行时异常或非检查异常。对于运行时异常，不要求必须捕获处理或抛出异常，由程序员自行决定
        //        2.2非RuntimeException：非运行时异常或检查异常。对于非运行时异常，要求必须捕获处理或抛出异常，如不捕获或抛出则编译不通过
    }
    
    /*
    *3.异常关键字  
    */
    public static void demoExceptionKeyWord(){
        //关键字有：try catch finally throw throws
        //1.try catch finally关键字
        //    1.1 try关键字    包围可能出现异常的逻辑代码，不能单独使用。必须配合catch/finally一同使用
                //如：  try..catch..;    try..catch..finally..;  try..finally;  只能有一个try  可以有多个catch  finally可选
        //    1.2 catch关键字   用于捕获可能出现的异常  建议不要使用空catch块
        //  1.3    finally关键字   不管有没捕获到异常，finally代码均会执行，常用于释放资源操作
        //  三者的执行顺序为：try—>catch—>finally  但如果存在多个catch,一旦捕获到异常，后面的catch则不会执行，
        //  且finally在return前执行   建议不要在finally中使用return  不然返回值会被覆盖掉
        showDemo("演示try..catch");
        testTryCatch();
        
        showDemo("演示try..catch..finally");
        testTryCatchFinaly();
        
        
        //2.throw throws
        //    2.1 throw关键字  抛出一个异常对象  只会出现在方法体内
        //    2.2 throws关键字  出现在方法的声明中，表示可能会抛出的异常，可允许后面跟着多个异常类型
        showDemo("演示throws");
        try{
            testThrows();//演示throws
        }catch(ArithmeticException e){
            System.out.println("除数都能为0?哥笑了！");
        }
        
        showDemo("演示throw");
        try{
            testThrow();//演示throw
        }catch(ArithmeticException e){
            System.out.println("除数都能为0?大哥我笑了！");
        }
    }
    
    /*
    *4.异常处理机制
    */
    public static void demoExceptionHandle(){
        //1.对于可能出现异常的代码，处理方式有两种
        //    1.1处理异常————使用try..catch语句对异常进行处理
        //        如：  try{ ...} catch(异常类型1){} catch(异常类型2){} catch(异常类型3){} finally{}
        //    1.2不处理异常————对于处理不了的异常或者需要转型的异常在方法声明处使用throws语句进行异常的抛出
        //        如：public void testException() throws Exception{ if(...) { throw new Exception();}}
        
        //2.使用异常类的方式有两种：
        //    2.1使用java提供的已有异常类————如：IOException、SQLException
        //    2.2使用自定义的异常————创建一个继承Exception/RuntimeException的子类
        
        //3.异常的转译
        //    3.1异常链————把原始的异常包装为新的异常类,并在新的异常类中封装原始异常类
        /*  如:
                public void test(){
                    try{
                        .....
                    }catch(ArithmeticException ex){
                         System.out.println("Arithmetic exception occoured: "+ex);
                         try {
                             throw new NumberFormatException();
                         }catch(NumberFormatException ex1) {
                            System.out.println("Chained exception thrown manually : "+ex1);
                         }
                    }
                }
        
        */
        //    3.2异常转型————相当于在捕获到异常后，将异常以新类型的异常抛出，使异常的信息更加直观
        /*        如： 
        public void test() throws MyException{ 
                                
            try{
                ...
            } catch(IOException e){ 
              throw new MyException(); 
              } 
            finally{
                ...
                }
        }
        */
        try{
            testDefinedException();//演示自定义异常类和异常转译
        }catch(MyException e){
            System.out.println("演示自定义异常类：" + e.toString());
        }
    }
    
    /*
    *5.异常继承
    */
    public static void demoExceptionExtend(){
        //1.父类的方法没有声明异常，子类在重写该方法时不能声明异常
        //2.如果父类方法声明一个异常A，则子类在重写该方法时声明的异常不能是A的父类
        //3.如果父类的方法声明的异常类型只有非运行时异常(运行时异常)，则子类在重写该方法时声明的异常也只能是非运行时异常(运行时异常)
        /*
        总结就是：父类方法声明了什么异常，那么子类在重写该方法时只能是一样声明该异常或者该异常的子类
        */
    }
    
    /*
    *6.异常小结
    */
    public static void demoExceptionNote(){
        //根据度娘和工作经验得出异常的小结：
        /*
        1.只有在必要的时候才使用异常，因为捕获异常的代价是非常非常非常高的(没错，重要的词语要说三次)
        2.不要用异常去控制程序的流程
        3.不要使用空catch块
        4.try块尽可能过小。保持一个try块对应一个或者多个异常
        5.尽可能细化异常，别动不动就来个catch(Exception e)
        6.catch块要保持一个块对应一类异常
        7.不要把自己能处理的异常抛出
        8.尽可能将检查异常转为非检查异常，然后交给上层处理
        */
    }
    
    /**演示TryCatch关键字**/
    public static void testTryCatch(){
        int a[] ={1,2,3};
        try{
            for(int i = 0;;i++){
                System.out.println("获取数组值：" + a[i]);
            }
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Catch语句：" + "数组访问越界了");
        }
    }
    
    /**演示TryCatchFinaly关键字**/
    public static void testTryCatchFinaly(){
        int i = 0;
        try{
            int k = 1/i;
        }catch(ArithmeticException e){
            System.out.println("Catch语句：" + "除数为0");
        }finally{
            System.out.println("Finally语句："+"除数都能为0?呵呵！");
        }
    }
    
    /**演示Throws关键字**/
    public static void testThrows() throws ArithmeticException{
        int i = 0;
        int k = 1/i;
    }
    
    /**演示Throw关键字**/
    public static void testThrow(){
        int i = 0;
        int k = 1/i;
        if( i==0){
            throw new ArithmeticException();
        }
    }
    
    /**演示自定义异常类**/
    public static void testDefinedException() throws MyException{
        int i = 0;
        try{
            int k = 1/i;
        }catch(ArithmeticException e){
            throw new MyException("除数为0");
        }
    }

    
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
}