【Java异常】

java异常概述

异常

异常：指程序执行过程中，出现的非正常情况，如果不处理会导致JVM的非正常终止。

• 异常指的并不是语法错误和逻辑错误。语法错了，编译不通过，不会产
  生字节码文件，根本不能运行。
• 代码逻辑错误，只是没有得到想要的结果，例如：求a与b的和，你写成
  了a-b。

程序出现异常，一般有两种解决方法：
1.程序遇到错误就终止运行。
2.对可能出错的代码进行异常的检测，处理，保证代码的健壮性。

java异常体系结构

Throwable：java.lang.Throwable类是Java程序执行过程中发生的异常事件对应的类的根父类。

常见方法：

• public void printStackTrace():打印异常的详细信息。
  包含异常的类型，原因，异常出现的位置，在开发和调试阶段都得使用printStackTrace。
• public String getMessage():获取发生异常的原因。
  +

常见的异常

Error

• 堆溢出: OutOfMemoryError
• 栈溢出: StackOverflowError

异常–运行时异常

• 数组越界异常 类
• 转换异常
• 数字格式化异常
• 空指针异常
• 算术异常

package Day8.ExceptionDemo;

public class Demo2 {
    public static void main(String[] args) {
/*      int[] a={1,2,3,4,5};
        a[5]=0;
        System.out.println(a[5]);//ArrayIndexOutOfBoundsException:数组越界*/
        //-------------------------------------------
        /*       Object o=new Integer("0");
        String str=(String)o;
        System.out.println(str);//.ClassCastException:类型·转化异常*/
        //-------------------------------------------
/*     Integer integer=new Integer("a");//NumberFormatException:数字格式化异常
        System.out.println(integer);*/
        //-------------------------------------------
 /*       String str1=null;
        System.out.println(str1.length());//NullPointerException：空指针异常*/
        //-------------------------------------------
        int c = 10;
        int b = 0;
        System.out.println(c / b);//ArithmeticException:算术异常
    }
}

异常–编译器异常

1. 日期格式化
2. 文件找不到
3. 编码不支持

异常处理

5个关键字（try,catch,finally,throw,throws）

Java编程语言使用异常处理机制为程序提供了错误处理的能力。

Java的异常处理由五个关键字实现：try，catch，finally，throw，throws。

try

检测不安全的代码块（发现异常）

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

catch（可以有多个catch语句）

把抓到的类型匹配的异常捕获，保证程序能继续运行下去

catch语句必须紧跟着try语句之后，称为 (捕获异常)，也就是异常处理函数，
一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类
的顺序写，否则有编译错误。

• 捕获异常的有关信息：
  与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
  Ø getMessage() 获取异常信息，返回字符串
  Ø printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的
  位置。返回值void。

finally

finally该内容总是会执行的，只能有一个finally语句

throw 与 throws

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

基础语法（try-catch-finally）

try-catch:

package Day8.ExceptionDemo;

import javax.xml.transform.Source;

public class Demo3 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int[] a1 = {1, 12, 2, 45, 4};
        try {
            int i = Integer.parseInt("a");
            a1[6] = 10;
            int c = a / b;
        } catch (ArithmeticException e) {
            System.out.println("除数不为0");
            e.printStackTrace();//返回异常信息
        } catch (ArrayIndexOutOfBoundsException r) {
            System.out.println("越界了");
            r.printStackTrace();
        } catch (Exception r) {
            r.getMessage();//返回异常信息，简洁
            r.printStackTrace();
        }
        System.out.println("下来了");
    }
}

try-catch-finally

package Day8.ExceptionDemo;

import java.lang.annotation.Retention;

public class Demo4 {
    public static void main(String[] args) {
        System.out.println(tototo(10, 0));
        System.out.println("--------------------------------------------------");
        System.out.println(tototo(10, 2));
    }
    public static int tototo(int a,int b){
        try{
            int c=a/b;
            return 1;
        }catch (ArithmeticException ss){
            System.out.println("出错了");
            return -1;
        }finally {
            System.out.println("fianlly");//先与return。
            return 0;//先与try与catch返回，一定会执行
        }
    }
}

throws

package Day8.ExceptionDemo;

import java.io.UnsupportedEncodingException;

public  class Demo5 extends Demo51{
    public static void main(String[] args) {
        try {
            toto();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        tototo();

    }
    //编译期
    public static void toto() throws UnsupportedEncodingException {
        "abc".getBytes("UTF-811");
    }
    //运行期
    public static void tototo() throws ArithmeticException {

    }
    @Override
    public void eat() throws ArithmeticException{

    }
}

**throw**

```java
package Day8.ExceptionDemo;

public class Demo6 {
    public static void main(String[] args) {
        try {
            toto(-1);
        } catch (ArithmeticException e) {
            e.printStackTrace();//打印异常
            System.out.println(e.getMessage());
        }

    }
    public static char toto(int number)throws ArithmeticException{
        if(number<0||number>100){
            throw  new ArithmeticException("成绩错了同志");
        }else
        if(number>90){
            return 'A';
        }
        else return  'B';
    }
}

自定义异常

概述

自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的 子类

• 作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆
• 自定义异常类中往往不写其他方法，只重载需要使用的构造方法
• 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或
  throws抛出

自定义异常示例

package Day8.ExceptionDemo;

import org.omg.CORBA.PUBLIC_MEMBER;

public class Demo7 {
    public static void main(String[] args) {
        try {
            toto(-1);
        } catch (ExceptionXX exceptionXX) {
            exceptionXX.printStackTrace();
            System.out.println(exceptionXX.getMessage());
        }
    }
    public static char toto(int number)throws ExceptionXX{
        if(number<0||number>100){
            throw  new ExceptionXX("成绩错了同志");
        }else
        if(number>90){
            return 'A';
        }
        else return  'B';
    }
}
class ExceptionXX extends Exception{
    public ExceptionXX(String str){
        super(str);
    }
}