Java语言基础异常

异常

    是在运行时期发生的不正常情况

    在Java中用类的形式对不正常情况进行了描述和封装对象；
    描述不正常的情况的类，就称为异常类；

    以前正常流程代码和问题处理代码相结合，
    现在讲正常流程代码和问题处理代码分类，提高阅读性；

    其实异常就是Java通过面向对象的思想将问题封装成了对象，
    用异常类对其进行描述；
    不同的问题用不同的类进行具体的描述；比如角标越界，空指针等；

    问题很多，意味着描述的类也很多，
    将其共性进行向上抽取，就形成了异常体系；

    最终异常分为两大类：
    Throwable：无论是Error还是异常，都是问题，问题发生就应该抛出，让调用者知道并处理。
    该体系的特点：Throwable及其所有的子类都具有可抛性。
                            子类的后缀名都是用其父类名作为后缀，阅读性强；
    如何体现可抛性？
    通过两个关键字来体现：throws、throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性；

    1.一般不可处理的：Error
        特点：是由JVM抛出的严重性的问题，影响到程序的执行；
                    这种问题发生一般不针对性处理，而是直接修改程序；
    2.可处理的：Exception

    如果有未定义的异常，需要按照Java异常的创建思想，面向对象，将负数下标进行自定义描述，并封装成对象。
    这种自定义的问题描述叫做自定义异常。

    注意：如果让一个类成为异常类，必须要继承异常体系，因为只有成为异常体系的子类，
    才有资格具备可抛性，才可以被两个关键字所操作：throw(函数)，throws(函数声明)
    如果函数发生了异常，需要在函数上声明，否则编译失败；

    异常的分类：
    1.编译时被检测异常：只要是Exception和其他子类都是(出了特殊子类RuntimeException体系)；
                                    这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式；
                                    这样的问题都可以针对性的处理。
    2.编译时不检测异常(运行时异常)：就是Exception中的RuntimeException和其子类。
                                    这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的，
                                    或者引发了内部状态的改变导致的。
                                    这种问题一般不处理，直接编译通过，在运行时，让调用时的程序强制停止，让调用者对代码进行修正。
    自定义异常时，继承Exception或者RuntimeException。

    注意：1.throws使用在函数上，throw使用在函数内；
                        2.throws抛出的是异常类，可以抛出多个，用逗号隔开，
                             throw抛出的是异常对象。
    异常处理的捕捉形式：
    这是可以对异常进行针对性处理的方式；
    具体格式是：
   

try
    {
        //需要被检测异常的代码
    }
    catch(异常类 变量)//该变量用于接收用于接收发生的异常对象
    {
        //处理异常的代码
    }
    finally
    (
        //一定会执行的代码
    )

    异常处理示例
   

class FuShuIndexException extends Exception
    {
        FuShuIndexException()
        {
        }
        FuShuIndexException(String msg)
        {
            super(msg);//调用父类即可
        }
    }

    class Demo
    {
        public int method(int[] arr,int index) throws FuShuIndexException,NullPointerException
        {
            if(arr==null)
                throw new NullPointerException("没有任何数组实体");
            if(index<0)
                throw new FuShuIndexException("下标不能为负数");
            return arr[index];
        }
    }

    class ExceptionDemo4
    {
        public static void main(String[] args) 
        {
            int[] arr=new int[3];
            Demo d=new Demo();
            try
            {
                int num=d.method(arr,3);
                System.out.println("num="+num);
            }
            catch (NullPointerException e)
            {
                System.out.println(e.toString());
            }
            catch (FuShuIndexException e)
            {
                System.out.println("message:"+e.getMessage());
                System.out.println("string"+e);//System.out.println("string:"+e.toString());默认效用toString()
                e.printStackTrace();//JVM默认的异常处理机制就是么偶人调用异常对象的这个方法
            }
            /*
            catch (Exception e)//多catch，父类的catch放在最后，否则，编译失败
            {
                System.out.println("其他异常：\n"+e);
            }
            */
            System.out.println("over");
        }
    }

    异常处理的原则:
    1.函数内部如果抛出需要检测的异常，那么函数上必须要声明；
         否则必须在函数内用try-catch捕捉，否则编译失败。
    2.如果调用到了声明异常的函数，要么try-catch，要不throws，否则编译失败；
    3.什么时候catch，throws
         功能内部可以解决，用catch；
         无法解决用throws，告诉调用者，由调用者解决;
    4.一个功能如果抛出多个异常，那么调用时必须有对应的多个catch进行针对性处理；
         内部有几个需要检测的异常，就抛出几个异常，抛出几个异常就catch几个异常。

    try-catch-fianlly代码块组合特点
    1.try-catch-fianlly
    2.try-catch    没有必要资源需要释放时，可以不用定义finally；
    3.try-finally    异常无法直接catch处理，但是资源需要关闭；
       

void show() throws Exception//没有catch时必须声明
        {
            try
            {
                //开启资源
                throw new Exception();
                //关闭资源
            }
            finally
            {
                //出现异常时，关闭资源
            }
        }

    finally使用示例
   

class Demo
    {
        public int show(int index) throws ArrayIndexOutOfBoundsException
        {
            if(index<0)
                throw new ArrayIndexOutOfBoundsException("下标越界");
            int[] arr=new int[3];
            return arr[index];
        }
    }

    class  ExceptionDemo5
    {
        public static void main(String[] args) 
        {
            Demo d=new Demo();
            try
            {
                int num=d.show(-3);
                System.out.println("num="+num);
            }
            catch (ArrayIndexOutOfBoundsException e)
            {
                System.out.println(e.toString());
                //return;
                //System.exit(0);//结束JVM，后面所有语句都不执行
            }
            finally//通常用于关闭(释放)资源
            {
                System.out.println("finally");
            }
            System.out.println("over");
        }
    }

    try-catch-finally综合使用示例
   

/*
    必要时用电脑上课
    问题领域中涉及两个对象：毕老师，电脑
    分析其中的问题：
    电脑蓝屏，无法使用
    */
    class LanPingException extends Exception
    {
        LanPingException(String msg)
        {
            super(msg);
        }
    }
    class MaoYanException extends Exception
    {
        MaoYanException(String msg)
        {
            super(msg);
        }
    }

    class NoPlanException extends Exception
    {
        NoPlanException(String msg)
        {
            super(msg);
        }
    }
    class Computer 
    {
        private int state=2;
        public void run() throws LanPingException,MaoYanException
        {
            if(state==1)
                throw new LanPingException("电脑蓝屏");
            if(state==2)
                throw new MaoYanException("电脑冒烟");
            System.out.println("电脑运行");
        }
        public void reset()
        {
            state=0;
            System.out.println("电脑重启");
        }
    }

    class Teacher
    {
        private String name;
        private Computer comp;
        Teacher(String name)
        {
            this.name=name;
            comp=new Computer();
        }
        public void prelect() throws NoPlanException
        {
            try
            {
                comp.run();
                System.out.println(name+"讲课");
            }
            catch (LanPingException e)
            {
                System.out.println(e.toString());
                comp.reset();
                prelect();
            }
            catch (MaoYanException e)
            {
                System.out.println(e.toString());
                test();
                //可以对电脑进行维修
                //throw e;
                throw new NoPlanException("课时进度无法完成："+e.getMessage());//异常转换
            }
        }
        public void test()
        {
            System.out.println("大家练习");
        }
    }

    class ExceptionTest 
    {
        public static void main(String[] args) 
        {
            Teacher t=new Teacher("毕老师");
            try
            {
                t.prelect();
            }
            catch (NoPlanException e)
            {
                System.out.println(e.toString()+"..........");
                System.out.println("换人");
            }
        }
    }

    /*
    异常的封装
    class NoAddException extends Exception
    {}

    void addData(Data d)throws NoAddException
    {

        连接数据库
        try
        {
        添加数据。出现异常 SQLException();
        }
        catch(SQLException e)
        {
            //处理代码。
            throw new NoAddException();
        }
        fianlly
        {
        关闭数据库。
        }
    }
    */

   
    异常的注意事项：
    1.子类在覆盖父类方法时，父类的方法如果抛出了异常，
        那么子类的方法只能抛出父类的异常或者该异常的子类；
    2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集；

    简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集；

    注意：如果父类的方法没有抛出异常，那么子类覆盖时不能抛出异常，只能try；