java异常-CFANZ编程社区

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

异常的概念

异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。
Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分为两类：
- Error:Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。
- Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：
  - 访问数组下标越界
  - 试图读取不存在的文件
  - 网络连接中断

异常的体系

Throwable类有两个直接子类：Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。Exception表示异常，是所有异常类的父类，是程序员所关心的。
异常分为运行期异常和编译期异常两种
- 运行期异常：程序运行时抛除的异常，所有RuntimeException的子类都是运行期异常
  - 算数异常（ArithmeticException）
  - 空指针异常（NullPointerException e2）
  - 数组下标越界异常（ArrayIndexOutOfBoundsException）
  - …
- 编译期异常(Checked Exception)：除去运行期的异常都是编译期异常，也称为检测异常
  - IOException
  - SQLException
  - …

异常处理

Java编程语言使用异常处理机制为程序提供了错误处理的能力
Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws
异常处理的基本语法

try{

可能会发生异常的代码

}catch(异常类型引用名){

异常处理代码

}finally{

无论是否发生异常都必须执行的代码

}

try catch

        int a = 10;
        int b = 0;
        try {//不会终止程序
            System.out.println("a÷b=" + a / b);//算术异常 ArithmeticException
            int c = Integer.parseInt("ZO");//这里会出现类型转换异常
            /*
                try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即              catch块。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。
             */
            try {//try{}catch()也可以嵌套使用
                int[] arr = {1, 2, 3, 4, 5};
                arr[6] = 0;
            } catch (ArrayIndexOutOfBoundsException e3) {
                e3.printStackTrace();//printStackTrace()获取异常类名和异常信息，以及异常出现在程                 //序中的位置。返回值void。
                System.out.println("数组越界！");
            }

            String s = null;
            s.length();//这里会出现空指针异常
            System.out.println("adfsafsagf");

        } catch (ArithmeticException e) {//空号里是捕获的异常类型和参数
            System.out.println("算术异常");
        } catch (NumberFormatException e1) {
            System.out.println("数字格式化异常");
        } catch (NullPointerException e2){
            System.out.println("空指针异常");//一个try后面可以写多个catch，分别捕获不同类型的异常
        } catch (Exception e3) {//Exception是上面两个的异常的父类，要写到后面，否则会出现编译时异             //常，其他catch无法捕获 无意义。
            System.out.println("系统繁忙！");
        }

运行结果：在这里插入图片描述
把 b = 0改为b = 1,则运行结果：
把int c = Integer.parseInt(“10”);改为int c = Integer.parseInt(“ZO”);

在这里插入图片描述
异常信息：

finally

public class exceptionDemo{
    public static viod main(String[] args){
        int a = 10;
        int b = 0;
        System.out.println(test1(a, b));
    }
    public static int test1(int a, int b) {
        try {
            int c = a / b;
            return c;//若b不等于0，会先执行finally中的代码，再回来return
        } catch (ArithmeticException e) {//处理异常
            return -1;//若b = 0，会先执行finally中的代码，再回来return，下同
        } finally {
            System.out.println("finally 代码块");
            //finally该内容总是会执行的，只能有一个finally语句
            
        }
    }
}

运行结果：
在这里插入图片描述

throws

throws,定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常，而交给方法调用处进行处理。
使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。

例1：

public class exceptionDemo1{
    public static void main(String[] args){    
        try {
                test3();//这里也可以抛出异常，但虚拟机会罢工，也就是程序终止运行
            }catch (UnsupportedEncodingException e){
                e.printStackTrace();
                System.out.println("\n不支持的编码格式");
            }
    }
    public static void test3() throws UnsupportedEncodingException{
        test4();//谁调用谁处理
    }
    public static void test4() throws UnsupportedEncodingException {//声明异常抛出，但不处理
        "abc".getBytes("UTF-8");
    }
}

例2：

import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;

public abstract class P {
    public abstract void test1()throws UnsupportedEncodingException;//任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
    public abstract void test2()throws IOException;
    public abstract void test3()throws NullPointerException;
}

class C extends  P{
    /*
       throws 在方法的形参列表后面,声明此方法可能会抛出某种类型的异常,可以声明多个
               如果声明为运行时异常,编译期间不强制处理
               如果声明为编译期异常,编译期间强制提示进行处理
     */
    
    @Override
    public void test1() throws UnsupportedEncodingException {
    }
    
    @Override
    public void test2() throws FileNotFoundException {//重写父类方法时声明的异常类型要等于，小于父类中声明的异常类型
    }
    
    @Override
    public void test3() throws RuntimeException {//这里声明的是运行时异常，运行时异常(检测异常)声明的即使是大于父类的也不会提示
    }
}

throw

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象.
在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。
throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try catch捕获异常，要么使用throws声明异常
语法:

throw throw new 异常类构造方法

如： throw new RunTimeException();

例：

public class throwDemo {

    public static void main(String[] args) {
        try {
            test(101);
        } catch (ScoreException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }


    public static char test(int score) throws ScoreException {
        if(score<0||score>100){
            //不合法分数,没必要继续向下执行,此处可以使用throw直接在方法中抛出一个异常对象.
            throw new ScoreException("不合法的分数");
        }
        if(score>=90){
            return 'A';
        }else{
            return 'B';
        }
    }
}

//我们可以根据自己的业务需要,开发自定义异常类
class ScoreException extends  Exception{

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

运行结果：
在这里插入图片描述