1.可以自定义一个异常，方法是继承Throwable类或者是继承Exception类。其实Exception类就是Throwable的子类。

2.当有一个函数会抛出我们自定义的异常，需要声明这个函数会抛出什么样的异常 例如：

public static void a() throws wrong{

这里，throw是抛出一个异常，而Throws是声明一个函数会抛出异常

e.getMessage() 异常中的信息

println（e） 异常的名字和异常中储存的值

e.printStacktrace() 跟踪异常出现位置

    class wrong extends Throwable{}

    public class 异常 {
        static int [] a = new int [10];
        public static void main(String [] args){
            try{
                a();
            }catch(wrong e ){
                System.out.println("这是自定义的异常");
            }
        }

        public static  void a() throws wrong{
            throw new wrong();
        }
    }

1.当一个异常继承于另一个异常时，捕捉父类异常时就可以同时捕捉子类的异常。
也就是说因为Exception是所有异常的父类，所以捕捉Exception异常时就可以捕捉所有的异常

2.当同时捕捉多个异常时，只会有一个异常被捕捉到。

3.当语句中先捕捉父类异常再捕捉子类异常时会报错。提示这是一个永远不会执行到的异常。

Unreachable catch block for wrong2

class wrong extends Exception { //父类异常
}

class wrong2 extends wrong{     //子类异常
}

public class 异常 {
    static int [] a = new int [10];
    public static void main(String [] args){
        try{
            a();
        }catch(wrong e ){
            System.out.println("这是异常wrong");
        }
    }

    public static  void a() throws wrong2{
        throw new wrong2();
    }
}

1.当覆盖函数的时候，子类不能声明抛出比父类的版本更多的异常。
2.在子类的构造函数中，必须声明父类可能抛出的全部异常。

如果有以下三种异常

class wrong1 extends Exception {}   //父类异常
class wrong2 extends wrong1{}       //子类异常
class wrong3 extends Exception{}    

当父类的函数f()抛出异常wrong1时，子类中覆盖它的函数的异常不能比它抛出更多的异常,但是子类的构造函数必须包含父类的所有异常

//父类
class test {
    public void f() throws wrong1,wrong3{}
    test()throws wrong1{}
}
//子类
public class 异常 extends test {
    //构造函数
    异常()throws wrong1,wrong3{}

    //子类覆盖的函数
    public void f()throws wrong1 ,wrong3
    {}

    public static void main(String [] args){
        try{
            a();
        }catch(wrong1 e ){
            System.out.println("这是异常wrong1");
        }catch(wrong3 e){}
    }
    public static  void a() throws wrong1,wrong3{
        test s = new test();
        s.f();
    }
}