Java中的异常

一、异常概述

什么是异常：
    程序运行中出现的不正常情况
    如：数组越界  int[] a=new int[5];
                b=a[5];//访问时数组越界
    程序运行过程中由于用户输入的格式有问题、读取文件文件被删除了、网络传输过程中断
    网了等就会导致程序出现不正常情况-->异常

需要注意的是，语法错误并非异常

java中的默认异常处理机制：
    当程序出现异常后，会将异常的信息包装在一个对应的对象中，并抛出此对象并终止程序运行
    控制台报错时，结构是 在某某线程中，异常的类型，异常的原因，异常的位置
    如：Exception in thread "main" //主线程
       java.lang.ArrayIndexOutOfBoundsException: 5//类型是数组越界，原因是索引值5
       at com.wbc.Exception.异常概述与常用异常.ExceptionDemo.main(Demo1.java:9)
       //程序运行的位置

异常的处理：
    1、遇到异常就终止程序运行
    2、编写代码时就充分考虑可能出现的情况。实在无法避免的要编写代码进行处理

二、常见的异常

//ArrayIndexOutOfBoundsException数组越界
int[] a =new int[5];
/*for(int i =0;i<=5;i++){
    a[i]=i;
}

//java.lang.StringIndexOutOfBoundsException字符串越界
String s ="abcd";
s.charAt(4);

//java.lang.ArithmeticException算数异常
/*int x=10;
int y=0;
int z=x/y;*/

//java.lang.NullPointerException空指针
/*String s=null;
s.length();*/


//java.lang.ClassCastException类型转换异常
/*Object s ="abcd";
Integer ac =(Integer)s;*/

//java.lang.NumberFormatException数字格式化异常
/*int ab = Integer.parseInt("abc0");
System.out.println(a);*/

三、异常的体系结构

异常的体系结构
    Java.lang.Throwable 异常体系的根父类
    内韩两个常用方法：
        public void printStacktrace();打印栈中的异常信息
        public String getMessage();获取异常的信息

    Throwable的两个子类
        Error：错误
               java虚拟机无法解决的严重问题，如：jvm系统内部错误，资源耗尽、内存不够用等
               是系统姓错误，java程序无法解决
        Exception：异常（这是本章要学习的）
               是出现的一般性问题，可以使用java中的异常处理机制进行处理的
                    运行时：ArithmeticException、NullPointerException...
                    非运行时：
        广义异常：所有的报错都可以称为异常
        狭义异常：Exception

四、异常的处理

异常处理
    java中提供一套异常处理机制没在程序发生异常时，可以执行预先设定好的处理程序，执行完成
    后，程序会停止，可以继续向后执行
    在写代码时，就要根据不同的情况设定好处理程序，
    运行程序：
    程序执行时，出现问题，执行异常处理程序
             没有出现问题，则不需要进行异常处理程序

    关键字：
        try{
            执行可以产生异常的代码
        }

        catch(){
            处理方式
        }

        finally{
            必须要执行的代码
        }

        thorw：用于手动抛出异常，一般写在方法体之内，当满足或不满足某种情况需要抛出时使用
        throws：抛出异常，一般写在方法声明中，当运用此方法时可获得其提示的异常类型，方便处理

相关示例

        1）try-catch-finally

package com.wbc.Exception.异常处理.catch_finally;

public class Demo2 {
    public static void main(String[] args) {
        try {

            String s =null;
            s.length();

            int a = 10;
            int b = 0;
            int c = a / b;


        }
        catch (ArithmeticException a){
            a.printStackTrace();
            System.out.println("除数不能为0");
        }
        catch (NullPointerException n){
            //try中的代码一旦出现异常，后面的代码就不会执行了转而执行对应的catch
            n.printStackTrace();
            System.out.println("对象为空指针");

        }
        catch (Exception e){//写Exception是在怕分辨不出哪里异常，但zx需要写到最底下
            System.out.println("程序异常"+e.getMessage());
        }
        finally {
            //必须要执行的代码
            //例如IO里的close
        }
        System.out.println("over");
    }
}

2）throws

package com.wbc.Exception.异常处理.throws_throw;

import java.io.UnsupportedEncodingException;

public class demo4 {
    public static void main(String[] args) {

        //不强制处理是因为这是个运行时异常，在运行时才可能会异常抛出
        //在编译期间不会强制处理，在写代码时需要注意
        chu(1,0);


        //这是个编译器异常，在编译的时候就会异常抛出
        //处理方法有两种 1、try_catch  2、throws 一般到顶层就不能再throws了
        try {
            test();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
    /*
    在方法声明的地方，通过throws关键字，声明此方法可能会出现异常
    使用throws抛出异常表示此方法不处理异常，交给调用这个方法的地方进行处理
    一般在底层的方法中都不进行处理
     */
    public static int chu(int a,int b)throws ArithmeticException{
        int c =a/b;
        return c;
    }

    public static void test() throws UnsupportedEncodingException {
        "abc".getBytes("utf-8");
    }
}

3）throw

//异常
package com.wbc.Exception.homework.triangle;

public class FormTriangleException extends Exception{
    public FormTriangleException() {
    }

    public FormTriangleException(String message) {
        super(message);
    }
}
//测试
package com.wbc.Exception.homework.triangle;

import java.util.Scanner;

public class triangle {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        int a =scanner.nextInt();
        int b =scanner.nextInt();
        int c =scanner.nextInt();
        try {
            checkTriangle(a,b,c);
        } catch (FormTriangleException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
    public static void checkTriangle(int a,int b,int c)throws FormTriangleException{
        if(a+b<=c||a+c<=b||b+c<=a){
            throw new FormTriangleException("不能构成一个三角形！");
        }

    }
}

4）自定义异常

    java API中定义的时标准异常类，都是与语法相关的，如索引越界、空指针等 在编写程序时，有可能在满足某种业务需求时，想要以抛出异常的方式进行处理 就需要自定义一个与业务相关的异常类来表示（如同分数不合法--ScoreException）

package com.wbc.Exception.异常处理.自定义异常;

public class ScoreException extends Exception{

    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);//调用父类的方法
    }
}

package com.wbc.Exception.异常处理.自定义异常;

public class Score {
    public static void main(String[] args) {
        int score =110;
        try {
            checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
    public static char checkScore(int score) throws ScoreException {
        if(score<0||score>100){
            //一般在方法体内
            // 当满足或不满足某种条件时，主动抛出一个异常对象，程序不可继续执行
            throw new ScoreException("分数非法");
        }
        else if(score<60){
            return 'D';
        }
        else if(score>=60&&score<75){
            return 'C';
        }
        else if(score>=75&&score<85){
            return 'B';
        }
        else
            return 'A';
    }
}