Java 异常

Java 异常

---

Java 异常概念

---

• 广义异常：指一切的不正常（程序余下出现的不正常情况）
  Exception：通过异常处理机制处理，处理之后程序可以继续向下执行。
  Error ：Java 虚拟机无法解决的严重问题。如：对象内存不够，程序无法执行。一般无法处理。
• Java 中异常：Exception
  运行时程序出现的一般问题，可以使用异常处理机制处理的情况
• 常见的异常（Exception）
• 数组越界

  //数组越界
        int [] a = new int[5];
        a[5] = 10;//java.lang.ArrayIndexOutOfBoundsException 异常类型 Create breakpoint 异常原因

• 算数异常

 //算数异常
        int a = 10;
        int b = 0;
        int c = a / b; //java.lang.ArithmeticException 异常类型
        System.out.println(c);

• 空指针

//空指针
        String str = null;
        str.length();//java.lang.NullPointerException 异常类型

• 类型转换

//类型转换
        
        Object str = "abc";
        Integer i = (Integer) str;//java.lang.ClassCastException 异常类型

• 数字格式化

//数字格式化
        new Integer("a");//java.lang.NumberFormatException

异常的体系

---

• Java 中将程序中有可能出现的每一类问题，都包装成了一个类，当出现对应的某类异常时，虚拟机会抛出对应的类信息。

• 解决办法
  1.默认抛出异常信息
  2.通过异常处理机制处理它。在编码时，就需要对有可能出现问题的代码进行处理。

• Throwable类
  有两个直接子类：Exception类，Error类。
  

• 异常分为运行期异常和编译期异常两种

• 运行期异常
  程序运行时抛除的异常，所有RuntimeException的子类都 是运行期异常。

• 编译期异常（检测异常）
  除去运行期的异常都是编译期异常。

异常处理

---

• Java 异常处理的五个关键字：：try、catch、 finally、throw、throws
• try,catch
  语法：

try {
            System.out.println("运行前");
            int a = 10,b = 0;
            new Integer(1);
            int c = a / b;
            System.out.println("运行后");
        }catch (ArithmeticException a){//精确异常类型  处理办法不是把坏的处理好了
            a.printStackTrace();
            System.out.println(a.getMessage()); //将异常原因打出来
        }catch (Exception e){//当不知道是什么异常时
            e.printStackTrace();
        }
        System.out.println("a");

• finally

• 处理异常类型

//处理异常
try {
            System.out.println("运行前");
            int a = 10,b = 1;
            new Integer("abc");
            int c = a / b;
            System.out.println("运行后");
        }catch (ArithmeticException a){
            a.printStackTrace();
            a.getMessage(); 
        }catch (Exception e){
            e.printStackTrace();
        }finally {//无论try{}中代码块是否异常，finally{}代码块一定会执行
            System.out.println("aaaaaaaaaa");
        }
        System.out.println("a");//此处可以输出

• 不处理异常类型

 //不处理异常
        try {
            System.out.println("运行前");
            int a = 10,b = 1;
            new Integer("abc");
            int c = a / b;
            System.out.println("运行后");
        }finally {//无论try{}中代码块是否异常，finally{}代码块一定会执行
            System.out.println("aaaaaaaaaa");
        }
        System.out.println("a");//此处不执行

• 返回类型

public static int test() {
        try {
            System.out.println("运行前");
            int a = 10, b = 0;
            int c = a / b;
            return c;
        } catch (Exception e){
            e.printStackTrace();
            return -1;
        }finally {//无论try{}中代码块是否异常，finally{}代码块一定会执行
            System.out.println("aaaaaaaaaa");
        }
    }

throws和throw

---

• 关键字 throws
  定义一个方法时可以使用throws在方法参数后声明，表示此方法不处理异常，而交给方法调用处根据情况是否进行处理
• 我们在调用throws声明的方法时，若不想处理异常，可以继续向上抛出，交给上层处理，若已经抛到main方法时，就不能再抛了，不然就抛给java虚拟机，然而虚拟机并不会处理。
• Exception 体系下又分为：
  编译异常（检查异常）：没有继承RuntimeException，编译时就强制要处理。
  运行期异常：继承 RuntimeException，在编译器间不需要强制处理。

public static void main(String[] args) {

        //在main方法时，已经是最顶层，就不能再抛了，不然就抛给java虚拟机，然而虚拟机并不会处理。
        try {
            test1();//此处已经为main方法，为最高层，就不能再抛了，不然就抛给java虚拟机，然而虚拟机并不会处理。
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }finally {
            System.out.println("异常已经处理，输出继续想执行的语句");
        }

    }

    public static void test1() throws UnsupportedEncodingException {

        test2();//下层经过throws 声明，已经将问题抛过来，此处仍然可能出现异常，此处根据情况是否处理，若不想处理，仍然可以继续向上抛出
    }

    public static void test2() throws UnsupportedEncodingException {

        try {
            "abc".getBytes("UTF-8");//此方法可能出现异常，此处不处理可以向上抛，交给上一层处理
        }finally {
            System.out.println("需要继续执行的语句");
        }

    }

• 关键字 throw
  在方法体内，抛出一个异常的对象，抛出后，程序不继续向下执行，一般在方法中不符合业务逻辑要求时，可以主动使用throw抛出异常

public static void main(String[] args) {

        Index(11);
        }
public static void Index(int Index){
        int [] a = new int[10];
        if(Index<0||Index>=a.length){
            throw new ArrayIndexOutOfBoundsException(Index+"数组下标越界");
        }else {
            System.out.println("数组下标未越界");
        }

    }

自定义异常

---

• 自定义异常
  根据自己业务逻辑需要，开发对应类型
  自定义异常类继承Exception
  当出现某种逻辑不满足时抛出

package com.xytx.javaexception.exception;

public class ScoreException extends Exception{
    // 成绩分数异常
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}

public static char CheckScore(int score) throws ScoreException {
        if(score < 0 || score > 100){
            throw new ScoreException("分数不符合要求"+score);
        }

        if(score >=90 || score <= 100){
            return 'A';
        }
        if(score >=80 || score <= 89){
            return 'B';
        } else {
            return 'C';
        }
    }
public static void main(String[] args) {
        try {
            CheckScore(101);//分数异常
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }