Java自学笔记（第十天）-异常-异常的处理-throws-throw-多异常处理-自定义异常-throwable类-RunTimeException类-finally-异常在方法继承中的注意事项-

（*）异常：就是程序在运行时出现的不正常情况

//用面向对象的思想，把生活中的问题(不正常情况)也都归纳成类，这就是问题类的出现

//问题有两种:error和exception

//Java通过error类(严重的问题)来描述错误，对于error一般不编写针对型的代码对其进行处理

//Java通过exception类(轻微的问题)来描述异常，对于exception可以编写代码进行处理

//throwable类是error类和exception类的父类，throwable类也就是传说中的问题总类

（*）异常的处理：被catch就是被处理，或是继续声明异常。

//语句格式：

try

{

　　//需要被检测的代码

}

catch(异常类 变量)

{

　　//处理异常的代码；（处理方式）

}

finally

{

　　一定会执行的语句；

}

（*）对捕获到的异常对象进行常见的处理：

//就是3个常用的Exception类的方法：

getMessage():得到异常信息

toString():得到异常所属的类

printStackTrace():得到异常出现的位置

//jvm默认的异常处理机制，就是在调用printStackTrace方法，打印异常的详细信息

（*）throws关键字：写在有可能出异常的方法后面，叫做声明异常，调用此方法的地方就要使用try{}catch{}处理异常，也可以该方法继续throws抛出异常，最终抛给虚拟机。

如下，就是将异常抛给虚拟机：

class eccl 
{
    public static void main(String[] args) throws Exception
    {
        div d = new div();
        
        System.out.println(d.div(4,0));
    
        System.out.println("main");
    }
}
class div
{
    int div(int a,int b) throws Exception
    {
        return a/b;
    }
}

如下，就是对方法抛出的异常进行处理

class eccl 
{
    public static void main(String[] args) 4     {
        div d = new div();
        try
        {
            System.out.println(d.div(4,0));
        }
        catch (Exception e)
        {
            System.out.println("捕获异常");
        }
        
    
        System.out.println("main");
    }
}
class div
{
    int div(int a,int b) throws Exception
    {
        return a/b;
    }
}

//不建议将异常抛给虚拟机，最好对声明的异常进行处理

（*）多异常处理，一个try跟多个catch

//函数当中如果有异常发生，这个函数的执行会立即终止，后面的语句不在执行

？？//为什么当方法throws Exception时，调用该方法的地方没有处理，编译就不通过

？？//而当方法throws ArithmeticException时或者ArrayIndexOutOfBoundsException时，调用该方法的地方没有处理，编译可以通过

1，声明异常时，建议声明更为具体的异常，这样处理的可以更具体

2，对方声明几个异常，就对应有几个catch

　　如果多个catch中的异常出现继承关系，父类异常catch放在最下面

//在进行catch处理时，catch中一定要定义具体处理方式

//正常情况下，处理异常就是把发生的异常用日志文件记录下来

（*）自定义异常：自定异常类，就是自定义一个Exception类的子类

//自定义异常类必须要手动抛出异常对象，就是throw new 自定义异常类();

//当手动抛出自定义异常类的对象时，一定要进行相对应的异常处理（方法声明异常或trycatch处理），否则编译不通过

//自定义异常练习，如下：

class demo1025 
{
    public static void main(String[] args) 
    {
        ex a = new ex();
        int x=0;
        try
        {
            x= a.div(100,-10);
            System.out.println("jubux="+x);
        }
        catch(fushuException e)//捕捉自定义异常
        {
            System.out.println(e);
            System.out.println("-------"+e.getValue());
        }
        catch (ArithmeticException e)
        {
            System.out.println("-ArithmeticException    catch   code-"+e);
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            System.out.println("-ArrayIndexOutOfBoundsException    catch   code-"+e);
        }

        
        
    }
}
class ex
{
    int div(int a,int b) throws fushuException
    {
        if(b<0)
        {
            throw new fushuException("被除数不能为负数",b);//抛出自定义异常
        }
        int[] arr = new int[a];
        System.out.println(arr[9]);
        return a/b;
    }
}


//自定义的异常类
class fushuException extends Exception
{
    private int value;
    fushuException(String message,int value)
    {
        super(message);
        this.value = value;
    }
    public int getValue()
    {
        return this.value;
    }
}

//throwable类就是可抛出类，只有throwable类和它的子类，可以被throws和throw两个关键字操作，也就是被抛出

//throws 和 throw的区别，throws是声明异常的，throw是抛出异常对象的

//可以声明多个异常，用“，”号隔开

（*）运行时异常runtimeException类极其子类的异常，不被处理，编译时不会报错，这就是运行时异常的特殊之处。而普通异常则必须被处理，否则编译报错。

当运行时异常出现时，程序必须停止，所以一般情况下没有对运行时异常进行处理的情况。

//所以自定义异常时，可以根据需要来自定义，普通异常或者运行时异常。

（*）finally关键字代码块：一定会执行的语句，一般用于关闭资源。

//即使try里有return语句(终止函数的关键字)，return语句执行完毕后，还会再继续执行finally代码块的语句。

//有一种情况执行不到finally，就是System.exit(0)，关闭jvm的语句。

（*）try代码块：

不在try块中，有异常，程序停止，虚拟机自动显示异常信息。其实就是虚拟机自动处理异常信息。

在try块中，有异常，异常后面的代码不再执行，虚拟机不自动显示异常信息。其实就是虚拟机不再自动处理异常信息

（*）异常在方法继承中的注意事项：

1，子类方法在覆盖父类方法时，如果父类方法抛出异常，那么子类的方法只能抛出父类方法抛出的异常，或是该异常的子类异常，或是不抛异常，如果不抛出异常则必须将父类抛出的异常在子类方法内部解决。

2，如果父类方法抛出多个异常，那么子类方法在覆盖时也可以抛出多个异常，但是要满足上一个条件。

3，如果父类方法或接口方法不抛出异常，那么子类方法在覆盖时也不可以抛出异常。如果子类方法确实产生异常，则必须在该子类方法内部将异常进行处理。

（*）异常小练习：

class yichang1027 
{
    public static void main(String[] args) 
    {
        rect r=null;
        r = new rect(-10,10);
        System.out.println(r.area());
    }
}
abstract class area
{
    abstract int area();
}
class rect extends area
{
    int length;
    int width;
    rect(int length,int width) 
    {
        if(length <= 0 || width <= 0)
            throw new NoValueException("不能为负数");
        this.length = length;
        this.width = width;
    }
    int area()
    {
        return this.length*this.width;
    }
}
class NoValueException extends RuntimeException//或是Exception,区分继承不同异常父类后的区别
{
    NoValueException(String msg)
    {
        super(msg);
    }
}

RuntimeException运行时异常，发生时，程序必须要停，运行时异常是一个严重的异常，一般情况下都要停下来，并不是程序代码错误出的异常，而是进行运算的参数不符合规矩。运行时异常。

class yichang1027 
{
    public static void main(String[] args) 
    {
        rect r=null;

        //r = new rect(-10,10);  rect构造函数抛出的异常没有被处理，程序出异常而终止

        try
        {
            //rect构造函数抛出的异常被处理了，就执行最后一句System.out.println(r.area());
            r = new rect(-10,10);
        }
        catch (NoValueException e)
        {

        }
        System.out.println(r.area());
    }
}
abstract class area
{
    abstract int area();
}
class rect extends area
{
    int length;
    int width;
    rect(int length,int width) 
    {
        if(length <= 0 || width <= 0)
            throw new NoValueException("不能为负数");
        this.length = length;
        this.width = width;
    }
    int area()
    {
        return this.length*this.width;
    }
}
class NoValueException extends RuntimeException//或是Exception,区分继承不同异常父类后的区别
{
    NoValueException(String msg)
    {
        super(msg);
    }
}

普通异常在编译时被检测，运行时异常不被检测。

（*）异常的好处：

1，将问题进行封装

2，将正常流程代码和问题处理代码分离

（*）异常的处理原则：

1，处理方式：try或者继续throws

2，调用抛出异常的功能时，有几个抛出，就做几个catch

3，当多个catch时，父类catch放下面

4，catch内，需要定义针对性的处理方式，不要只写一句简单的输出语句或是什么也不写。

5，当捕获到的异常，处理不了时，可以继续在catch中抛出。 如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理，也可以将捕获异常处理后，抓换成新的异常再抛出。

（*）异常的注意事项：

1，子类方法在覆盖父类方法时，如果父类方法抛出异常，那么子类的方法只能抛出父类方法抛出的异常，或是该异常的子类异常，或是不抛异常，如果不抛出异常则必须将父类抛出的异常在子类方法内部解决。

2，如果父类方法抛出多个异常，那么子类方法在覆盖时也可以抛出多个异常，但是要满足上一个条件。

3，如果父类方法或接口方法不抛出异常，那么子类方法在覆盖时也不可以抛出异常。如果子类方法确实产生异常，则必须在该子类方法内部将异常进行处理。