JavaSE中的异常

在Java语言中，将程序执行中发生的不正常情况称为“异常”

异常可以分为2类一类是虚拟机无法解决的问题，代码无法处理的异常，叫Error，

还有一类是可以通过代码处理的异常，比如空指针，数组越界等。

public class test1 {
    public static void main(String[] args) {
     int c=10/0;
        System.out.println(c);
    }
}

这就是一个异常，下面会提升，ArithmeticException意思是算术异常，大家都知道除数是不能为0的，by zero at one test.main意思是异常在那个方法里，java：5表示在第几行代码.

可处理的异常可以分为编译期异常(Checked Exception)和运行期异常(RuntimeException).

编译期异常有I/O异常和SQL异常等，在出现异常后，系统会强制提示你去处理这个异常。

运行期异常数学异常，空指针异常，数组下标越界等，只有在运行程序时才会报错.

下面这幅图可以描述异常的体系

异常处理通常有5个关键字，try，catch，finally，throws，throw。其中前三个通常可以配合使用。

try：检测不安全的代码块（发现异常），ry块中任何一条语句发生了异常，下面的代码将不会被执行，程序将
跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

catch：把抓到的类型匹配的异常捕获，保证程序能继续运行下去catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误.

捕获异常后可以用一下方法去处理异常：

getMessage() 获取异常信息，返回字符串，通常是写提示信息
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

（2）try catch finally 有一些组合，

try catch finally 有一些组合，

try{}catch{}组合

 try{
         int a=10/0;//try中的代码块用来写可能出现异常的代码
         int b=20;//当上面的代码出现异常之后，便不会执行下面的代码直接跳到catch里去
         System.out.println(b);
     }catch(Exception e)
     {
         e.printStackTrace();//当try中出现了异常之后，catch会捕获这个异常，然后处理异常
     }

try{}catch{}finally{}组合

try{
         int a=10/0;//try中的代码块用来写可能出现异常的代码
         int b=20;//当上面的代码出现异常之后，便不会执行下面的代码直接跳到catch里去
         System.out.println(b);
     }catch(Exception e)
     {
         e.printStackTrace();//当try中出现了异常之后，catch会捕获这个异常，然后处理异常
     }
     finally{
         System.out.println("我出现算术异常了");
     }
    }
 java.lang.ArithmeticException: / by zero
	at lianxi.bc.main(bc.java:6)
我出现算术异常了  

finally中的代码是必须要执行的.它可以提示一下用户发生了什么事情。

try{} catch{}中还可以嵌套try catch，try 还可以有多个catch，try{}catch{}catch{

还有try{} finally{}。

try catch 嵌套 try catch

try{
         int a=10,b=0;
         int c;
         try{c=a/b;}
         catch (Exception e){
             System.out.println("除数不为0");
         }
     }catch(ArithmeticException e)
     {
         System.out.println("出现算术异常");
     }
运行结果只有：除数不为0
出现catch运行之后程序将不再执行后面的东西.

try 有多个catch

 try{
         int a=10/0;//try中的代码块用来写可能出现异常的代码
          int arr={1,2,3};
           arr[4]=10;
     }catch(ArithmeticException e)
     {
         System.out.println("出现算术异常");
     }catch(NullpointerException){
         System.out.println("出现空指针异常");  
     }catch(Exception e) {
         System.out.println("出现异常");
     }
     finally{
         System.out.println("我出现算术异常了");
     }
出现算术异常
出现空指针异常
我出现算术异常了

在这种情况下，ArithmeticException是Exception的子类，他应该写到Exception之前不然程序会报错的，就是当有多个异常时，父类类型应放在子类类型下面。

当异常中含有return 时，finally 就不是最后一个执行的了

public class test1 {
    public int test(){
       try{ int a=10/0;
        return a;
    }catch(Exception e){
           System.out.println("异常");
           return 1;
    }finally {
           System.out.println("finally");
       }
       }
    public static void main(String[] args) {
        test1 a=new test1();
        System.out.println(a.test());
    }
}
异常
finally
1

在这个代码中，try出现了异常，然后catch捕获输出异常，然后执行finally代码，输出finally，最后返回一个值，因为try后代码不执行了所以会return catch里面的值，输出1.

（3）.throw关键字，throw关键字是用来声明异常的，但是他不处理异常，谁调用这个方法，谁去处理这个异常。

 public static void main(String[] args) {

        try {
            abcd.test1();//（4）调用test（1）方法，没人调用他了他只能处理异常了，所以try catch处理
        } catch (UnsupportedEncodingException e) {
            System.out.println("sb");
        }
    }
    public  static  void test1() throws UnsupportedEncodingException {
        abcd.test2();//（3）调用test（2）方法，他也没处理异常
    }
    public static void test2() throws UnsupportedEncodingException,NullPointerException {//（2）throws 声明异常，
        String s="abc";
        s.getBytes("utf-811");//（1）产生异常
        System.out.println(s);
    }

上面的(1)(2)(3)(4)顺序能说明问题.

（4）throw关键字，抛出一个异常，他也可以自己处理异常，也可以向上抛出.在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

public static void main(String[] args) throws b {
        try{
            System.out.println(d.sanjiao(1,2,3));
        }catch (b e){
            e.printStackTrace();
        }
    }
    public static String sanjiao(int a, int b, int c) throws b {
        if(a>0&b>0&c>0){
            if((a+b)>c&&(a+c)>b&&(b+c)>a){
                System.out.println("可以三角形");
            }
            throw new two.b("两边之和不大于第三边");//在这个方法中，当不可以为三角形时，就别互相异常了，用throw抛出一个异常两边这和不大于第三边
        }
        throw new two.b("边不大于0");//当他输入的三角形边为负数时，也不可以所以抛出异常
    }

（5）throws和throw的区别

throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try catch捕获异常，要么使用throws声明异常
throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处理这些异常
抽象方法也可以使用throws.

自定义异常的作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

自定义异常类中往往不写其他方法，只重载需要使用的构造方法 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或throws抛出

public class b extends Exception {//继承Exception
public b (String msg){//重载构造方法
    super(msg);
                     }
}

 public static void main(String[] args)  {
        try {//（3）调用方法，处理异常
            c.train(105);
        } catch (two.b b) {
            b.printStackTrace();
        }
    }
    public  static void train(int score) throws b {//（2）throws声明
        if(score>100||score<0){
            throw new b("输入错误");//（1）throw抛出
        }
        if(score>90){
            System.out.println("A");
        }else{
            System.out.println("B");
        }
    }
two.b: 输入错误
	at two.c.train(c.java:17)
	at two.c.main(c.java:9)

这就算一个自定义异常被调用了.