异常和错误

Java运行时期发生的问题就是异常。

Java中运行时发生的除了异常Exception还有错误Error。

异常：通常发生可以有针对性的处理方式的。
错误：通常发生后不会有针对性的处理方式。
Error的发生往往都是系统级别的问题，都是jvm所在系统发生的并反馈给jvm的。
无法针对处理，只能修正代码。

class ExceptionDemo 
{
    public static void main(String[] args) 
    {
        int[] arr = new int[1024*1024*100];//OutOfMemoryError  错误

        System.out.println(arr[0]);
        System.out.println(arr[3]);//该句运行时发生了异常 ArrayIndexOutOfBoundsException，导致程序无法继续执行。程序结束。
        System.out.println("over");
    }
}

自定义异常

/
//自定义异常。描述Person的年龄数值非法。
/**
只要是本项目的Person的年龄出现非法值就会发生该异常。
*/
class NoAgeException
{
    /*
    为什么要定义构造函数，因为看到Java中的异常描述类中有提供对问题对象的初始化方法。
    */
    NoAgeException()
    {}

    NoAgeException(String message)
    {}
}

class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        //加入逻辑判断。
        if(age<0 || age>200)
        {
            throw new NoAgeException(age+",年龄数值非法");
        }
        this.name = name;
        this.age = age;
    }
    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。
    public String toString()
    {
        return "Person[name="+name+",age="+age+"]";
    }
}
class ExceptionDemo5 
{
    public static void main(String[] args) 
    {
        Person p = new Person("xiaoming",-20);
        System.out.println(p);
    }
}

发生编译失败：
ExceptionDemo5.java:43: 错误: 不兼容的类型
throw new NoAgeException(age+",年龄数值非法");
^
需要: Throwable
找到: NoAgeException
1 个错误

不兼容，不明白，查阅，提示中说需要Throwable,啥东西?
搜索API。看到Throwable描述。发现。它是异常和错误的超类(父类)
原来它是异常体系的顶层类。
Throwable
|--Error
|--Exception

通过阅读：自定义异常被抛出，必须是继承Throwable，或者继承Throwable的子类。
该对象才可以被throw抛出。

原来这个异常体系具备一个特有的特性：可抛性：可以被throw关键字操作。

继承选择父类时，更为确切是继承Exception。

/
//自定义异常。描述Person的年龄数值非法。
/**
只要是本项目的Person的年龄出现非法值就会发生该异常。
*/
class NoAgeException extends Exception
{
    /*
    为什么要定义构造函数，因为看到Java中的异常描述类中有提供对问题对象的初始化方法。
    */
    NoAgeException()
    {
        super();
    }

    NoAgeException(String message)
    {
        super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。
    }
}

class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        //加入逻辑判断。
        if(age<0 || age>200)
        {
            throw new NoAgeException(age+",年龄数值非法");
        }
        this.name = name;
        this.age = age;
    }
    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。
    public String toString()
    {
        return "Person[name="+name+",age="+age+"]";
    }
}
class ExceptionDemo5 
{
    public static void main(String[] args) 
    {
        Person p = new Person("xiaoming",-20);
        System.out.println(p);
    }
}

但是发现编译又一次失败了。

ExceptionDemo5.java:62: 错误: 未报告的异常错误NoAgeException; 必须对其进行捕获或
声明以便抛出
throw new NoAgeException(age+",年龄数值非法");
^
1 个错误

通过这个编译失败提示，发现自定义的异常和之前所使用的异常(空指针异常，角标越界异常，无效参数异常有不同)
抛出哪些异常没有这个失败提示？那么之前的异常和自定义的异常有什么区别呢？
通过查看api的继承体系发现，之前的异常都是Exception下面的RuntimeException子类的子类。
阅读RuntimeException描述中有明确说明，这个运行时异常以及其子类都无需进行声明。

可以将自定义的异常继承RuntimeException.

/
//自定义异常。描述Person的年龄数值非法。
/**
只要是本项目的Person的年龄出现非法值就会发生该异常。
*/
class NoAgeException extends RuntimeException
{
    /*
    为什么要定义构造函数，因为看到Java中的异常描述类中有提供对问题对象的初始化方法。
    */
    NoAgeException()
    {
        super();
    }

    NoAgeException(String message)
    {
        super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。
    }
}

class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        //加入逻辑判断。
        if(age<0 || age>200)
        {
            throw new NoAgeException(age+",年龄数值非法");
        }
        this.name = name;
        this.age = age;
    }
    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。
    public String toString()
    {
        return "Person[name="+name+",age="+age+"]";
    }
}
class ExceptionDemo5 
{
    public static void main(String[] args) 
    {
        Person p = new Person("xiaoming",-20);
        System.out.println(p);
    }
}

继承Exception和继承RuntimeExcpetion为什么差距这么大？

class Demo
{
    void show()
    {
        //如果在函数内抛出Exception//编译失败，因为编译器在检查语法时发生了错误。
        /*
        该程序已经出现问题，Java认为这个程序本身存在隐患，
        需要捕获或者声明出来(你要么把问题处理，要么把问题标识出来让调用知道)
        */
//      throw new Exception();

        /*
        为什么抛出RuntimeException，不需要捕获，不要声明呢？
        不是功能本身发生的异常，而是因为比如调用者传递参数错误而导致功能运行失败。
        这时也是问题，需要通过异常来体现，但是这个异常不要声明出来的。
        声明的目的是为了让调用者进行处理。
        不声明的目的是不让调用者进行处理，就是为了让程序停止，让调用者看到现象，并进行代码的修正。★★★★★

        原理异常分两种：
        1，编译时异常：编译器会检测的异常。
        2，运行时异常：编译器不会检测的异常。不需要声明。声明也可以，如果声明了，无外乎就是让调用者给出处理方式。
        ArrayIndexOutOfBoundsException
        IllegalArgumentException
        NullPointerException
        ClassCastException
        */
        throw new RuntimeException();
    }
}
class ExceptionDemo6 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}

声明和捕获

声明：将问题标识出来，报告给调用者。
如果函数内通过throw抛出了编译时异常，而捕获，那么必须通过throws进行声明，让调用者去处理。

捕获：Java中对异常有针对性的语句进行捕获。
语句：
try
{
    //需要被检测的语句。
}
catch(异常类 变量)//参数。
{
    //异常的处理语句。
}
finally
{
    //一定会被执行的语句。
}

class Demo
{
    /*
    如果定义功能时有问题发生需要报告给调用者。可以通过在函数上使用throws关键字进行声明。
    */
    void show(int x)throws Exception
    {
        if(x>0)
            throw new Exception();
        else
            System.out.println("show run");
    }
}

class ExceptionDemo7 
{
    public static void main(String[] args)//throws Exception//在调用者上继续声明。 
    {
        Demo d = new Demo();
        try
        {
            d.show(1);//当调用了声明异常的方法时，必须有处理方式。要么捕获，要么声明。
        }
        catch (Exception ex)//括号中需要定义什么呢？对方抛出的是什么问题，在括号中就定义什么问题的引用。
        {
            System.out.println("异常发生了");
        }
        System.out.println("Hello World!");
    }
}

继承Exception呢？还是继承RuntimeException呢?

class NoAgeException extends RuntimeException
{
    /*
    为什么要定义构造函数，因为看到Java中的异常描述类中有提供对问题对象的初始化方法。
    */
    NoAgeException()
    {
        super();
    }

    NoAgeException(String message)
    {
        super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。
    }
}

class Person
{
    private String name;
    private int age;
    /*
    构造函数到底抛出这个NoAgeException是继承Exception呢？还是继承RuntimeException呢？
    继承Exception，必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行。
    但是如果使用到了Person对象的数据，导致都失败的。
    继承RuntimeExcpetion,不需要throws声明的，这时调用是不可能编写捕获代码的，因为调用根本就不知道有问题。
    一旦发生NoAgeException，调用者程序会停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码。哦耶。

    */
    Person(String name,int age)//throws NoAgeException
    {
        //加入逻辑判断。
        if(age<0 || age>200)
        {
            throw new NoAgeException(age+",年龄数值非法");
        }
        this.name = name;
        this.age = age;
    }
    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。
    public String toString()
    {
        return "Person[name="+name+",age="+age+"]";
    }
}
class ExceptionDemo8
{
    public static void main(String[] args) 
    {
//      try
//      {
            Person p = new Person("xiaoming",20);
            System.out.println(p);
//      }
//      catch (NoAgeException ex)
//      {
//          System.out.println("异常啦");
//      }
        System.out.println("over");
    }
}

编译时异常的应用

/*
案例：老师用电脑讲课。
两个对象：
    老师：
        属性：姓名。
        行为：讲课。
    电脑：
        行为：运行。

考虑问题。
1，电脑蓝屏-->异常。

2，电脑冒烟-->异常。

*/
// 可以声明，让调用给出处理方式。
class LanPingException extends Exception
{
    LanPingException()
    {
        super();
    }
    LanPingException(String message)
    {
        super(message);
    }
}

class MaoYanException extends Exception
{
    MaoYanException()
    {
        super();
    }
    MaoYanException(String message)
    {
        super(message);
    }
}
/*
讲课中冒烟，问题可以临时解决，是冒烟问题没有直接处理，所以就使用throws声明。
但是发现，这个问题不应该属于讲课的问题。调用讲课方法的调用者是处理不了这个冒烟问题的。
该调用者能处理的应该是冒烟导致的课程进行不下去的问题。
应该在列出一个异常。课时停止异常。

*/
class NoPlanException extends Exception
{
    NoPlanException()
    {
        super();
    }
    NoPlanException(String message)
    {
        super(message);
    }
}


class NoteBook
{
    private int state = 2;
    public void run()throws LanPingException,MaoYanException//方法上可以通过throws声明多个异常。
    {
        System.out.println("笔记本电脑运行");
        if(state == 1)
            throw new LanPingException("电脑蓝屏了");

        if(state == 2)
            throw new MaoYanException("电脑冒烟了");
    }
    public void reset()
    {
        state = 0;
        System.out.println("电脑重启");
    }
}
class Teacher
{
    private String name;
    private NoteBook book;
    Teacher(String name)
    {
        this.name = name;
        book = new NoteBook();
    }
    //讲课。
    public void prelect()throws NoPlanException
    {
        /*
        调用到了声明异常的方法，在这里到底是捕获好呢？还是声明好呢？
        有具体的捕获处理方式吗？有，那就捕获，没有，那么声明。
        我可以处理，重启就可以了，重启是电脑的功能。
        */
        try
        {
            book.run();//对于声明多个异常的方法，在处理，需要定义多个catch与之对应。
        }
        
        catch (LanPingException e)//LanPingException e = new LanPingException("电脑蓝屏了");
        {
            //重启。
            System.out.println(e.toString());//异常的名称+异常的信息。
//          e.printStackTrace();
            book.reset();
        }
        catch(MaoYanException e)//MaoYanException e = new MaoYanException("电脑冒烟了");
        {
            System.out.println(e.toString());
            test();
            //冒烟问题没有解决，继续声明throws出去。
//          throw e;
//          new 电脑维修部(book);//去修电脑。
//          book = new NoteBook();
            throw new NoPlanException(e.getMessage()+",课时停止");//异常转换。


        }
        System.out.println(name+"....讲课");
    }
    //留练习。
    public void test()
    {
        System.out.println("做练习");
    }
}

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

throw和throws的区别

• throw用在函数内。
  throws用在函数上。

• thorw抛出的是异常对象。
  throws用于进行异常类的声明，后面异常类可以有多个，用逗号隔开。

finally的使用

需求：有一些特定的代码无论异常是否发生，都需要执行。
因为异常会引发程序跳转，导致有写语句执行不到。无法满足这个需求。
异常捕获处理时java提供解决方案。
try catch finally
finally就是解决这个问题的，这个代码块中存放的代码都是一定会被执行的。

应用场景；

定义一个功能往数据库中添加数据。

void add(Data data)throws NoAddException
{
    //1,连接数据库。
    try{
    //2,添加数据。//添加数据时发生了异常情况。throw new SQLException();程序跳转，就执行不到断开连接。
                //而断开连接必须要执行，因为不执行，连接资源在浪费。
                //无论是否发生问题，都需要执行断开连接的动作，从而释放资源。
    }catch(SQLException e)
    {
        //解决数据库的问题。
        //同时将问题告诉调用者。
        throw new NoAddException();
    }
    finally
    {
        //3,断开连接。
    }

}

总结：finally到底什么时候用？
只要程序中使用到了具体的资源(数据库连接，IO资源，网络连接socket等)
需要释放，都必须定义在finally中。你在定义程序，只要问题发生与否，
指定程序都需要执行时，就定义finally中。

• 注意: return后finall也会执行, 有一种情况发生(System.exit(0);//退出Jvm。)，finally不执行。

class NoShowException extends Exception
{
    NoShowException(String message)
    {
        super(message);
    }
}

class Demo
{
    void show(int num)throws NoShowException
    {
        if(num<0)
            throw new NoShowException(num+",数值是非法的");
        System.out.println("show ....."+num);
    }
}

class ExceptionDemo9
{
    public static void main(String[] args)
    {
        Demo d  = new Demo();
        //因为调用到了声明异常的show方法，所以调用者要给处理方式，要么继续声明，要么捕获。
        try
        {
            d.show(-5);
        }
        catch (NoShowException ex)
        {
            System.out.println(ex.toString());//打印是异常名称+异常信息。

            //如果异常发生，处理完毕后，希望功能结束。
                        //return后finall也会执行
            return ;

            //注意：有一种情况发生，finally也不执行。
            //System.exit(0);//退出Jvm。
        }
        finally
        {
            System.out.println("hello");
        }
        System.out.println("over");
        */

        Test t = new Test();
        int num = t.show(-4);
        System.out.println("num="+num);


    }
}

catch和finally都return后，结果？

由于catch中的return会在finally后执行，如果finally有return，就以finally中return为结果

class ExceptionDemo9
{
    public static void main(String[] args)
    {
        Test t = new Test();
        int num = t.show(-4);//100
        System.out.println("num="+num);
    }
}
class Test
{
    int show(int num)
    {
    
        try{
            if(num<0)
                throw new Exception();
            return 4;
        }catch(Exception e)
        {
            System.out.println(e.toString());
            return 200;
        }
        finally
        {
            System.out.println("finally run");
            return 100;
        }
    }
}

try catch finally 组合方式

1，
try catch : 对代码进行异常检测，并对检测的异常传递给catch处理。
            异常捕获处理。
void show()//不用throws 
{
    try{
    throw new Exception();
    }catch(Exception e)
    {
    
    }
}

2，
try finally : 对代码进行异常检测，检测到异常后因为没有catch，所以一样会被默认jvm抛出。
            异常是没有捕获处理的。但是功能所开启资源需要进行关闭，所有finally。
            只为关闭资源。

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

3，
try catch finally
检测异常，并传递给catch处理，并定义资源释放。

4，try catch1 catch2 catch3......

异常在继承或者实现中的使用细节

• 细节总结

1,子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明。
2,当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。
3,当被覆盖的方法没有异常声明时，子类覆盖时是无法声明异常的。
    举例：父类存在这种情况，接口也有这种情况，
    问题：接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？
        　无法进行throws声明，只能catch的捕获。万一问题处理不了呢？catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出。

• 子类覆盖父类方法时，如果父类的方法声明异常，子类不声明异常，子类调用覆盖方法不需要try...catch...

/*
Exception
    |--AException
        |--AAException
    |--BException
*/
class AException extends Exception
{
}
class BException extends Exception
{
}
class AAException extends AException
{
}
class Fu
{
    void show() throws AException
    {
    }
}
class Zi extends Fu
{
    void show()
    {
        
    }
}
class ExceptionDemo11 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
        z.show();
    }
}

• 子类覆盖父类方法时，如果父类的方法声明异常AException，子类覆盖方法时可以声明异常AException或者异常AException的子类，子类调用覆盖方法需要try...catch...

class AException extends Exception
{
}
class BException extends Exception
{
}
class AAException extends AException
{
}
class Fu
{
    void show() throws AException
    {
    }
}
class Zi extends Fu
{
    void show() throws AException
    {
        
    }
}
class Zi1 extends Fu
{
    void show() throws AAException
    {
        
    }
}
class ExceptionDemo11 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
    try{
            z.show();
    }catch(Exception e){};

    Zi1 z1 = new Zi1();
    try{
            z.show();
    }catch(Exception e){};
    }
}

如果没有trc...catch...，就会变异报错

编译会报错

• 子类覆盖父类方法时，如果父类的方法声明异常AException，子类不声明异常BException，编译会报错

class AException extends Exception
{
}
class BException extends Exception
{
}
class AAException extends AException
{
}
class Fu
{
    void show() throws AException
    {
    }
}
class Zi extends Fu
{
    void show() throws BException
    {
        
    }
}
class ExceptionDemo11 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
    try{
            z.show();
    }catch(Exception e){};
    }
}

编译错误

• 当被覆盖的方法没有异常声明时，子类覆盖时是无法声明异常的

class Fu
{
    void show()
    {
    }
}
class Zi extends Fu
{
    void show()throws Exception
    {
    
    }
}
class ExceptionDemo11 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
        try{
        z.show();
        }catch(Exception e)
        {}
    }
}

编译错误

• 接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？无法进行throws声明，只能catch的捕获。万一问题处理不了呢？catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出。

    Interface Inter
    {
        public void show();
    }
    class Demo implement Inter
    {
        public void show()
        {
            try{
                throw new Exception();
            }catch(Exception e)
            {
                code...;
                throw new RuntimeException("");// 告知调用者问题所在。
            }
        }
    }