Java-10-异常

1.异常:是在运行时期发生的不正常情况.

1.2 在java中用类的形式对不正常情况进行了描述和封装对象.

描述不正常的情况的类,就称为异常类.
以前正常流程代码和问题处理代码相结合.
现在将正常流程代码和问题处理代码分离,提高阅读性.
其实异常就是java通过面向对象的思想将问题封装成了对象.
用异常类对其进行描述.
不同的问题用不同的类进行具体的描述.比如角标越界,空指针等等.

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

2.2 最终问题(不正常情况)就分成了两大类.

Throwable:无论是error还是exception问题,问题发生就应该可以抛出,让调用者知道并处理.
该体系的特点就在于Throwable及其说有子类都具有可抛性.

2.3 可抛性到底是什么呢?怎么体现可抛?

其实就是通过两个关键字来体现的.throw ,throws ,
凡是可以被这两个关键字所操作的类和对象都具备可抛性.
    |--1.一般不可处理的.Error
        特点:是由JVM抛出的严重性问题.
        这种问题发生一般不针对性处理,直接修改程序.
    |--2.可以处理的.Exception

该体系的特点:
子类的后缀名都是用其父类名作为后缀,阅读性强.

2.4 例子

class Test
{
    int method(int[] arr, int index)
    {
        if(arr == null)
        {
            throw new NullPointerException("兄弟,数组的引用不能为空!");
        }

        if(index < 0)
        {
            throw new ArrayIndexOutOfBoundsException("数组下标为负数,兄弟,你真疯了!");
        }
        if(index >=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组下标越界,兄弟,你疯了么?");
        }
        return arr[index];
    }
}
class ExceptionDemo
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        Test t = new Test();
        arr = null;
        t.method(arr,3);
        System.out.println(arr[4]);
    }   
}

3.自定义异常

对于角标是整数越界,可以用角标越界表示;
对于负数为角标的情况,准备用负数角标异常来表示.
负数角标这种异常在java中没有定义.

那就按照java异常的创造思想,面向对象,
将负数角标进行自定义,并封装成对象.
这种自定义的问题描述为自定义异常.

注意:
如果让一个类成为异常类,必须要继承异常体系,
因为只有成为异常体系的子类才有资格具备可抛性.
才可以被两个关键字所操作,throw,throws

3.2异常的分类:

1.编译时被检测异常:只要是Exception和其子类都是,除了特殊子类RuntimeException体系.

这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式.
这样的问题都可以针对性的处理.

2.编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类.

这种问题的发生,无法让功能继续,运算无法进行,更多是因为调用的原因导致的或者引发了内部状态的改变导致的.
那么这种问题一般不处理,直接编译通过,在运行时,让调用者调用时的程序强制停止,让调用者对代码进行修正.

所以自定义异常时,要么继承Exception,要么继承RuntimeException

3.3 throw 和 throws的区别

1.throws 使用在函数上,用于声明.
        抛出的是异常类,可以抛出多个,用逗号隔开.
2.throw 使用在函数内.
        抛出的是异常对象.

3.4 自定义异常举例

class Person
{
    private String name ;
    Person(String name)
    {
        this.name = name;
    }
    String getName()
    {
        return this.name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);//父类中有名字的方法,子类只用拿来用即可
    }
}


class FuShuIndexException extends RuntimeException 
{
    FuShuIndexException(){}
    FuShuIndexException(String msg)

    {
        super(msg);
    }
}

class Test
{
    void method(int[] arr, int index) //throws FuShuIndexException
    {
        if(arr == null)
        {
            throw new NullPointerException("兄弟,数组的引用不能为空!");
        }

        if(index < 0)
        {
            //throw new ArrayIndexOutOfBoundsException("数组下标为负数,兄弟,你真疯了!");
            throw new FuShuIndexException("数组下标为负数,兄弟,你真疯了!");
        }
        if(index >=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组下标越界,兄弟,你疯了么?");
        }
    }
}
class ExceptionDemo2
{
    public static void main(String[] args)// throws FuShuIndexException
    {

        Student s = new Student("张三");
        System.out.println(s);
        int[] arr = new int[3];
        Test t = new Test();
        t.method(arr,1);
        System.out.println(arr[1]);
    }   
}

4.1 异常处理的捕捉形式:

这是可以对异常进行针对性处理的方式.

具体格式是:

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

4.2 什么时候try什么时候throws

内部可以解决的问题就用try catch;
解决不了就抛出去让调用者处理.

4.3 异常处理原则:

1.
    函数内容如果抛出需要检测的异常,那么函数上必须要声明.
    必须在内容内使用trycatch捕捉,狗杂编译失败.
2.
    如果调用了声明异常的函数,要么try,catch要么throws,否则编译失败.
3.什么时候用catch,什么时候throws呢?
    功能内容可以解决,用catch.
    解决不了,用throws告诉调用者,由调用者解决.
4.
一个功能如果抛出多个异常,那么调用时,必须有对应多个catch进行针对性的处理
内部有几个需要检测的异常,就抛出几个异常,抛出几个,就catch几个.

4.4 例子

class FuShuIndexException extends Exception//RuntimeException 
{
    FuShuIndexException(){}
    FuShuIndexException(String msg)
    {
        super(msg);
    }
}

class Test
{
    public int method(int[] arr, int index) throws FuShuIndexException, NullPointerException, ArrayIndexOutOfBoundsException
    {

        if(arr == null)
        {
            throw new NullPointerException("兄弟,数组的引用不能为空!");
        }

        if(index < 0)
        {
            //throw new ArrayIndexOutOfBoundsException("数组下标为负数,兄弟,你真疯了!");
            throw new FuShuIndexException("数组下标为负数,兄弟,你真疯了!");
        }

        if(index >=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组下标越界,兄弟,你疯了么?");
        }

        return arr[index];
    }
}
class ExceptionDemo3
{
    public static void main(String[] args)// throws FuShuIndexException
    {

        int[] arr = new int[3];
        Test t = new Test();
        try
        {       
            int num = t.method(null,-3);
            System.out.println("num: "+num);
        }
        catch(FuShuIndexException e)
        {
            // System.out.println("下标异常!!!");
            // System.out.println("Message: "+e.getMessage());
            //System.out.println(e.toString());
            e.printStackTrace();//JVM默认的异常处理机制就是调用异常对象的这个方法.
        }
        catch(NullPointerException e)
        {
            e.printStackTrace();
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            e.printStackTrace();
        }
        catch(Exception e)//多catch的父类catch放在最后.
        {
            return;
        //  System.exit(0);//退出JVM
        }
        finally//通常关闭(释放)资源
        {

        }
        System.out.println("over");

    }   
}
/*
try catch finally 代码块组合特点:
1. try catch finally
2. try catch (多个)当没有必要资源需要释放时,可以不用定义finally
3.try finally 异常无法直接catch处理,但是资源需要关闭.
void show() throws Exception
{
    try
    {
        //开始资源
        throw new Exception();
    }
    finally
    {
        //关闭资源
    }
}

5.1 应用举例

毕老师用电脑上课

对象 老师 电脑



电脑 要能运行
老师  有名字  有一台电脑 要讲课

电脑可能出现蓝屏 冒烟 等状态.要处理这些异常的情况
蓝屏 电脑可以重启进行处理.
冒烟 要送给维修部门.
*/
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;//0代表电脑正常运行

    public void run()  throws LanPingException,MaoYanException
    {
    //if for等语句要在函数体内才可以运行
        if(state == 1)
        {
            throw new LanPingException("电脑蓝屏啦!!!");
        }
        if(state == 2)
        {
            throw new MaoYanException("电脑冒烟啦!!!");
        }       
        System.out.println("电脑运行....");
    }
    public void restart()
    {
        state = 0;
        System.out.println("电脑重启.....");
    }
}
class Teacher
{
    private String name;
    private Computer cpt;

    Teacher(String name)
    {
        this.name = name;
        cpt = new Computer();
    }

    public void prelect() throws NoPlanException
    {
        try
        {   cpt.run();
            System.out.println(this.name+"讲课");
        }
        catch(LanPingException e)
        {
            System.out.println(e.toString());
            cpt.restart();
            this.prelect();

        }
        catch(MaoYanException e)
        {
            System.out.println(e.toString());
            practice(); 
            //可以对电脑进行维修.
            throw new NoPlanException("课时进度无法完成, 原因:"+e.getMessage());

        }       
    }
    public void practice()
    {
        System.out.println("大家自由练习!!!");
    }

}

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

    }

 }

5.2 异常的转换
简单的说 就是把我们所不了解的异常转换为我们所了解认识的异常.

拿上面的例子来说 (设定一个老师绑定一台电脑)电脑烧坏是一个异常,但对于公司来说是陌生的异常他们没有处理的办法, 电脑烧坏也就是说老师不能讲课了,对于公司来说他们可以处理的是老师不能讲课的异常,他们可以换老师来讲课,也就说把电脑烧坏转化为老师不能讲课的异常,抛出这个异常让公司知道才能处理这个异常.

class NoAddException extends Exception
{
    NoAddException(String msg)
    {
        super(msg);
    }
}
void addData(Data d)
{
    链接数据库
    try{
        添加数据,出现异常  
        throw SQLException();
    }catch(SQLException e){
        //处理代码

        throw new NoAddException();
    }
    finally{
        关闭数据库
    }

}

5.3 异常的注意事项:

1:子类在覆盖父类方法时,父类的方法如果抛出了异常.
那么该子类的方法只能抛出父类的异常或者该异常的子类.
2:如果父类抛出多个异常,那么子类只能抛出父类异常的子集.

简单的说:子类覆盖父类只能抛出父类的异常或者子类或者子集.
注意:如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛,只能try.