黑马程序员——Java基础-异常

时间:2021-10-09 21:45:15

异常概述

异常:就是程序在运行时出现不正常情况。

异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述,并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

异常有两种

        编译是被检测到的异常 

               该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
                该异常被标识,代表这可以被处理。

        运行时异常(编译时不检测)

               在编译时,不需要处理,编译器不检查。
                该异常的发生,建议不处理,让程序停止,需要对代码进行修正。

Throwable:

(1)--Error:指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出,

因为已经失去了运行所必须的物理环境,一般不编译特定的代码进行处理

(2)--Exception:要用针对性的处理方式进行处理

--RunntimeException:运行时异常,可以不进行处理
这类异常可以不捕获或声明,编译可以通过,因为需要出错时爆出来然后解决掉他!

--非RunntimeException:要进行处理,这类异常要捕获或是声明,不然编译无法通过

异常的处理方式

第一种方式:捕获

在函数内部try{}内异常出现,交给catch{}内捕获的出来,

 

第二种方式:声明  

在函数内部直接将异常抛出,并在函数上声明这个异常,将异常交由上一级处理

 throw与throws区别

  throw:用在函数内部,在函数内部抛出异常,后面跟的是异常对象

  throws:用在函数上,后面跟的是异常类,并且可以跟多个异常类,中间有逗号分开

第一种方式:捕获异常(代码实现)

public class ExceptionTest  

    {  

        public static void main(String[] args)  

        {  

            div(4,7);  

            System.out.println("main code");  

        }  

  

        public static void div(int a,int b)  

        {  

          //捕获异常,当出现异常时,语句直接跳转到catch中进行异常的处理,try中出现异常的后面的语句就不会执行了  

            try  

            {  

                int temp=a/b;  

                int[] num=new int[a];  

                System.out.println("temp="+temp);  

                System.out.println(num[a]);  

             }  

           catch(ArithmeticException e)  

            {  

                 e.printStackTrace();  

                 //try后可以跟多个catch,应按照子类到父类的排列顺序,  

                //如果try中出现了catch中所有的异常,那么程序会直接抛出异常给上一级  

  

           }  

           catch(ArrayIndexOutOfBoundsException e)  

            {  

            e.printStackTrace();  

            //finally中执行的一般是关闭资源的操作  

           }  

           finally  

            {  

                 System.out.println("一定会执行的语句");  

             }  

        }  

    }  

第二种方式:声明异常(代码实现)

public class ExceptionTest  

    {  

        public static void main(String[] args) throws Exception  

        {  

            //调用者可以进行try或在函数上声明,如果进行了try那后面的语句还会执行,只是声明那后面的语句就不会执行了  

            div(4,0);  

             System.out.println("main code");  

        }  

        //在函数上声明异常,将异常交由上一级处理  

        public static void div(int a,int b) throws Exception  

        {  

            int temp=a/b;  

            System.out.println("temp="+temp);  

        }  

    }  

 

第三.打印异常信息的原理

class Demo  

{  

    int div(int a,int b)  

    {  

        return a/b;  //会产生 new aritchmeticexception(),以前是会传给虚拟机,但是现在有了catch就传给catch  

    }  

  

}  

class ExceptionDemo  

{  

    public static void main(String [] args)  

    {  

        Demo d = new Demo();  

        try  

        {  

            int x = d.div(4,0);   //在这里会产生  

            System.out.println("x="+x);  

        }   

        catch (Exception e)  // exception e = new arithmeticexception();  

        {  

            //System.out.println("除零了");  

          

            System.out.println(e.getMessage());// by zero//获取异常信息/ by zero  

            //System.out.println(e.toString());//异常名称:异常信息。java.lang.ArithmeticException: / by zero  

            //e.printStackTrace();//异常名称,异常信息,异常出现的位置。  

                                //其实jvm的默认的异常处理机制,就是在调用printstacktrace  

                                //打印异常的堆栈的跟踪信息    

                                //java.lang.ArithmeticException: / by zero  

                                //at cn.itcast.exception.Demo.div(ExceptionDemo.java:7)  

                                //at cn.itcast.exception.ExceptionDemo.main(ExceptionDemo.java:18)  

        }  

      

    }  

  

  

}  

多异常的处理

1.     声明异常时,建议声明更为具体的异常。这样处理的可以更具体
2.对方声明几个异常,就对应有几个catch块,不要定义多余的catch块,如果多个catch 块中异常出现继承关系,父类异常catch块放在最下面,建议在进行catch处理时,catch中一定要定义具体处理方式

2.      也不要简单的就书写一条输出语句。

class Demo  

{  

    int div(int a , int b) throws airthmeticexception,arrayindexoutofboundsexcwption //一个是算数异常,一个是越界  

    {  

        Int[] arr = new int[a];  

        System.out.println(arr[4]);   

        return a/b;  

    }  

}  

  

class Exceptiondemo1                                                  

{  

    public static void main(String[] args)throws exception      

    {  

        Demo d = new Demo();  

        try  

        {  

            int x = d.div(4,1);  

            System.out.println("x="+x);  

        }     

        catch (airthmeticexception e)  

        {  

            System.out.println(e.tostring());  

            System.out.println("被零除了!!");  

        }  

        catch (arrayindexoutofboundsexcwption e)  

        {  

            System.out.println(e.tostring());  

            System.out.println("角标越界啦!!");  

  

        }  

        catch (excwption e)   //父类异常catch块处理,父类异常放最后!!!  

        {  

            System.out.println(e.toString());  

  

        }  

  

            System.out.printlln("over");  

    }  

}  

自定义异常

自定义异常类:必须是自定义类继承Exception类体系

继承Exception原因:
异常体系有一个特点,因为异常类和异常对象都要被抛出

他们都具备可抛性,这个可抛性是throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throwsthrow操作。

如果不想对自定义的异常类进行处理,可以让自定义类继承RuntimeException
因为项目中会出现特有的问题
而这些问题并未被java所描述并封装对象。

所以对于这些特有的问题都可以按照java的对问题封装的思想
将特有的问题,进行自定义一个异常封装

throws和throw的区别
throws使用在函数上。
throw使用在函数内。
throws后面跟的异常类,可以跟多个,用逗号隔开。
throw后跟的是异常对象。

class FuShuException extends Exception   

{  

    /*  super(msg)就可以了 

        private String msg; 

        FuShuException(String msg) 

        { 

            this.msg = msg; 

         

        } 

 

        public String getMessage()//发现打印的结果中只有异常的名称,却没有异常的信息,因为自定义的异常并未定义信息(getmessage 

        { 

            return msg; 

        } 

        */  

        private int value;  

        FuShuException()  

        {  

            super();  

        }  

        FuShuException(String msg, int value)  

        {  

            super(msg); //如何定义异常信息呢?  

                        //因为父类中已经把异常信息的操作都完成了。  

                        //所以子类只要在构造时,将异常信息传递给父类通过super语句。  

                        //那么就可以直接通过getMessage方法获取自定义的异常信息  

            this.value = value;  

  

        }  

        public int getValue()  

        {  

          

            return value;  

        }  

}  

  

class Demo  

{  

      

    //这里抛出FuShuException是因为一般情况下,函数内出现异常,函数上也需要声明!!!  

  

    int div(int a , int b)throws FuShuException  

    {  

        if(b<0)  

            throw new FuShuException("出现了除数是负数的情况",b);//手动通过throw关键字抛出一个自定义异常对象  

          

        return a/b;  //除零自动抛出,负数只能手动抛出  

    }  

}  

  

class ExceptionDemo3  

{  

  

    public static void main(String[] args)  

    {  

        Demo d= new Demo();  

        try  

        {  

            int x = d.div(4,-1);   

            System.out.println("x="+x);  

        }  

        catch (FuShuException e)  

        {  

            System.out.println(e.toString()); //toString会自动调用getMessage  

        //  System.out.println("除数出现负数了");  

            System.out.println("错误" + e.getValue());  

        }  

          

              

          

          

          

          

  

          

        System.out.println("over");  

      

    }  

}  

异常-处理语句其他格式

第一个格式
try

{

}

catch

{

}

第二个格式
try

{

}

catch ()

{

}

finally 

{

}

第三个格式:

Try

{

}

finally ()

{

}

//记住一点,catch用于处理异常,如果没有catch就代表异常没有被处理过,如果该异常是检测时异常,那么必须声明

class Demo  

{  

    public void method()  

    {  

        /* 

        try 

        { 

            throw new Exception(); //问题在这里用catch解决了,就不用去method上面声明,如果没有try catch就要申明,否则会报错 

        } 

        catch (Exception e) 

        { 

            throw e; 

        } 

        */  

        try  

        {  

            throw new Exception(); //这里method就要声明,否则编译报错,因为没有解决  

        }  

        finally   

        {  

            //关资源  

        }  

          

    }  

}  

class    

{  

    public static void main(String[] args)   

    {  

        System.out.println("Hello World!");  

    }  

}  

异常覆盖时的特点

异常在字符类覆盖中的体现:

1.子类再覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类

2.如果父类抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集(也就是其中一个)。!!!

3.如果父类或接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理,绝对不能抛

注意如果接口没有异常抛出,那么子类内部就不能抛出异常!!!!!这就是为什么继承Runable  里面的wait不能抛异常的原因
如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常,如果子类发生了异常,只能进行try

class AException extends Exception  

{  

}  

  

class BException extends AException  

{  

}  

class CException extends Exception  

{  

}  

/* 

Exception 

    |--AException 

        |--BException 

 

    |--CException 

 

 

*/  

class Fu  

{  

  

        void show() throws AException  

        {  

          

          

        }  

}  

  

class  Test  

{  

    void function (Fu f)  

    {  

        try  

        {  

            f.show();  

        }  

        catch (AException e )  

        {  

        }  

      

      

    }  

}  

class Zi extends Fu  

{  

    void show throws Bexception //这里就不能抛父类  

    {  

      

      

    }  

}  

  

class    

{  

    public static void main(String[] args)   

    {  

        //System.out.println("Hello World!");  

        Test t = new Test();  

        t.function(new zi());  

        //可以看到zi中抛出CException,但是只能处理AException,处理不了CException  

    }  

}  

有关finally的问题

finally的执行时间问题

  finally语句是在return语句之后,跳转到上一级程序之前执行(即return语句中间执行)
  finally中的语句一定会执行,是建立在对应的try得到执行情况下,如果程序在try语句之前就发生了
  异常或就已经结束,那finally中的语句是不会执行的

  finally在一种情况下不会执行,System.exit(0):程序停止运行,退出虚拟机!!!!!!!!

public class ExceptionDemo  

{  

    public static void main(String[] args)  

    {  

        System.out.println(test());  

    }  

      

    public static String test()  

    {    

         try  

         {    

           System.out .println("try block");    

           return test1 ();    

         }   

         finally   

         {    

           System.out .println("finally block");  

         //  return "finally";// 如果finally中有返回值,那么finally返回值就会替换掉上一级方法中的返回值  

                            //这一句如果执行,那程序上一级方法中的after return 就会被finally所替换  

                              //  

                              // try block  

                              // return statement  

                              // finally block  

                              //finally  

                              //没有  

                              // try block  

                              // return statement  

                              // finally block  

                              // after return  

  

         }    

    }    

      

    public static String test1()  

    {    

      System.out.println("return statement");    

      return "after return";    

    }  

}  

/* 

程序结果为: 

  try block 

  return statement 

  finally block 

  after return 

 

原因分析: 

   1.try语句块,return test1(),则调用test1方法 

   2.test1()执行后返回"after return",返回值"after return"保存在一个临时区域里 

   3.执行finally语句块。若finally语句有返回值,则此返回值将替换掉临时区域的返回值 

   4.将临时区域的返回值送到上一级方法中。 

*/  

  

public class ExceptionTest  

{  

        public static void main(String[] args)  

    {  

        int a=5;  

        int[] arr=new int[5];  

        //return 0;要想让方法停止运行可以returnthrow个异常  

        int i=a/0;  

        try  

        {  

         System.out.println(arr[6]);  

        }  

         catch(ArrayIndexOutOfBoundsException e)  

         {  

           System.out.println(e.getMessage());  

           System.out.println("角标越界");  

          //这里的finally语句是不会执行的,因为在try语句之前程序就已经停止运行了  

         }  

         finally  

        {  

            System.out.println("finally");  

         }  

    }  

}  

finally代码块:定义一定执行的代码,通常用于关闭资源
finally代码块:定义一定执行的代码
通常用于关闭资源

class FuShuException extends Exception  

{  

    FuShuException(String msg)  

    {  

        super(msg);  

    }  

}  

  

class Demo  

{  

    int div(int a , int b )throws FuShuException  

    {  

        if(b<0)  

        throw new FuShuException("除数为负数");  

          

        return a/b;  

      

    }  

}  

  

class ExceptionDemo6  

{  

    public static void main(String[] args)  

    {  

        Demo d =new Demo();  

        try  

        {  

            int x = d.div(4,-1);  

            System.out.println("x="+x);  

        }  

        catch (FuShuException e)  

        {  

            System.out.println(e.toString());  

        }  

        finally  

        {  

            //即使catch中有return也会执行finally  

            System.out.println("finally");//finally中存放的代码是一定会执行的  

        }  

        System.out.println("over");  

    }  

}  

  

class NoException extends Exception  

{  

}  

//数据库类似于服务器,可以建立的连接数量有限,所以用完就要释放,要不然别人就没法用  

//这里不能throws SQLException ,因为调用method的对象不懂SQLException  

//所以抛出也没用,这里只能抛出throws Noexception(数据没存成功)  

//类似于销售问仓库要货,仓库发现要的货发霉了(SQLException  

//发霉了只能仓库处理,但是仓库要告诉销售没有货(Noexception  

public void method() throws Noexception  

{  

    连接数据库;  

    数据操作;//throw new SQLException();  

    关闭数据库;//该动作,无论数据操作是否成功,一定要关闭资源  

  

  

  

    try  

    {  

        连接数据库;  

        数据操作;//throw new SQLException();  

    }  

    catch (SQLException e)  

    {  

        会对数据库进行异常处理;  

            throw new NoException();  

    }  

    finally  

    {    

    关闭数据库;//该动作,无论数据操作是否成功,一定要关闭资源  

    }  

}