Java学习个人备忘录之异常

概述

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

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

描述不正常的情况的类，就称为异常类。

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

其实异常就是java通过面向对象的思想将问题封装成了对象。

用异常类对其进行描述。
不同的问题用不同的类进行具体的描述。

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

最终问题(不正常情况)就分成了两大类
Throwable：无论是error，还是异常，问题发生就应该可以抛出，让调用者知道并处理。
//该体系的特点就在于Throwable及其所有的子类都具有可抛性。
可抛性到底指的是什么呢? 怎么体现可抛性呢?
其实是通过两个关键字来体现的。
throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。
|--1。一般不可处理的。 一般用Error表示
特点:是由jvm抛出的严重性的问题。
这种问题发生一般不针对性处理.直接修改程序。
|--2。可以处理的，一般用Exception表示 。

该体系的特点：
子类的后缀名都是用其父类名作为后缀，阅读性很强。

class ExceptionDemo
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        System.out.println(arr[3]);//编译通过，运行不通过  

        sleep(-5);
    }  

    public static void sleep(int time)
    {
        if (time<0)
        {
             //抛出 new FuTime();//就代码的时间为负的情况，这个对象中会包含着问题的名称，信息，位置等信息。
        }
        System.out.println("我睡..."+time);
    }
}
class FuTime
{
}

异常对象的抛出throw  

class Demo
{
    public int method(int[] arr，int index)
    {
        if (arr==null)
        {
            throw new NullPointerException("数组的引用不能为空!");
        }
        if (index>=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组的角标越界了 "+index);//这里就抛出了自定义的异常信息。
        }
        if (index<0)
        {
            throw new ArrayIndexOutOfBoundsException("数组的角标不能为负值 "+index);//这里就抛出了自定义的异常信息。
        }
        return arr[index];
    }
}  

class ExceptionDemo2
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];  

        Demo d = new Demo();
        int num = d.method(arr，30);
        System.out.println("num="+num);
        System.out.println("over");
    }
}

自定义异常&异常类的抛出throws

对于角标是正数不存在，可以用角标越界表示。
对于角标为负数的情况，准备用负数角标异常来表示。

负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。

这种自定义的问题描述称为自定义异常.

class Demo
{
    public int method(int[] arr，int index)throws FuShuIndexException  //表示抛出了。
    {
        if (arr==null)
        {
            throw new NullPointerException("数组的引用不能为空!");
        }
        if (index>=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组的角标越界了 "+index);//这里就抛出了自定义的异常信息。
        }
        if (index<0)
        {
            throw new FuShuIndexException("数组的角标不能为负值 "+index);
        }
        return arr[index];
    }
}  

class ExceptionDemo3
{
    public static void main(String[] args)throws FuShuIndexException
    {
        int[] arr = new int[3];  

        Demo d = new Demo();
        int num = d.method(null，30);
        System.out.println("num="+num);
        System.out.println("over");
    }
}

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

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

异常的分类：
1。编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。

2。编译时不检测异常(运行时异常)：就是Exception中的RuntimeException和其子类。
这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。
那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。

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

throws和throw的区别
1。throws使用在函数上。
throw使用在函数内。
2。throws抛出的是异常类，可以抛出多个，用逗号隔开。
throw抛出的是异常对象.

异常捕捉trycatch

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

具体格式是：

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

class Demo
{
    public int method(int[] arr，int index)throws FuShuIndexException，NullPointerException  //表示抛出了。
    {
        if (arr==null)
        {
            throw new NullPointerException("没有任何数组实体");
        }
        if (index<0)
        {
            throw new FuShuIndexException("数组的角标不能为负值 "+index);
        }
        return arr[index];
    }
}  

class ExceptionDemo4
{
    public static void main(String[] args)throws FuShuIndexException
    {
        int[] arr = new int[3];
        Demo d = new Demo();
        try
        {
            int num = d.method(null，-30);
            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.toString());  //FuShuIndexException：数组的角标不能为负值  

            e.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。 

            //System.out.println("负数角标异常!!!!");
        }
        System.out.println("over");
    }
}  

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

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

finally代码块

class Demo
{
    public int show(int index)
    {
        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());  //开发的时候不要写输出语句。
        }
        finally //通常用于关闭(释放)资源
        {
            System.out.println("finally");
        }
    }
}

例如：
连接数据库
查询。Exception
关闭连接

try catch finally 代码块组合特点：

1。try catch finally

2。try catch(多个) 当没有必要资源需要释放时，可以不用定义finally。

3。try finally //必须用throws声明

void show()throws Exception
{
    try
    {
        throw new Exception();
    }
    finally
    {
    }
}

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

解释：

class A extends Exception
{
}
class B extends A
{
}
class C extends Exception
{
}  

Exception
    |--A
        |--B
    |--C  

class Fu
{
    void show()throws A
    {}
}
class Zi extends Fu
{
    void show()throws A或B  //这里抛出的必须是父类的异常或父类异常的子类，所以不能抛出C
    {}
}

2。如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
解释：如果父类抛出A B C D ，那么子类要么抛出 A B，要么抛出 C D ，要么抛出 A B C ，也可以全抛出，总之就是不能抛出像A B C D E这样的。简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。