本文主要是介绍Java——异常处理，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 1、为什么需要处理异常
• 2、Throwable类
• • 2.1、类图
  • 2.2、throwable的方法
• 3、异常的产生
• 4、捕获和处理异常
• • 4.1、finally关键字
• 5、抛出异常
• 6、声明异常
• • 6.1、抛出还是处理
• 7、自定义异常

1、为什么需要处理异常

1. 如果java程序在运行期间出现了一个错误。比如，文件错误、设备错误、代码错误等。期望程序能继续运行下去或者以适当的形式终止程序。
2. 异常处理的任务就是将控制权从产生错误的地方传给能够处理这种情况的错误处理代码。

2、Throwable类

2.1、类图

1. Throwable是Error和Exception的父类，用来定义所有可以作为异常被抛出来的类。
2. Error描述了运行时系统内部错误和资源耗尽错误。
3. Exception描述了运行时导致程序无法继续运行的异常。
4. RuntimeException非检查异常，描述了程序缺陷导致的异常，可以避免。
5. XException已检查异常（RuntimeException之外的异常）描述了由于某些特殊情况导致原本能够正常运行的程序无法完成的异常，强制检查。

2.2、throwable的方法

• Throwable中定义了多个方法。因为所有的异常类都是Throwable的子类，所以它们都继承了Throwable的这些方法。
  1. void printStackTrace(); //将调用栈信息输出到标准错误。
  2. String getMessage(); //返回对异常的描述。
  3. String toString(); //返回一个包含异常描述的String对象。

3、异常的产生

代码演示

package Throw;

public class Throw01 {
    public static void main(String[] args ){
        int[] arr_a=new int[4];
        System.out.println("接下来会有异常！");
        arr_a[12]=123;
        System.out.println("End！");
    }
}

运行结果

• 当程序发生异常时，会生成一个异常对象，这个对象会在方法内部被抛出。如果程序不捕获它，它就会被JVM捕获，程序也就终止了。
• 当有异常不想终止程序，有两种处理方法：
  1. 捕获并处理它，让程序继续运行；
  2. 捕获但不处理它，把它交给上一级程序处理；

4、捕获和处理异常

• 捕获异常的基本结构：

try{
	//可能会产生异常的代码
}catch(异常类型1 e){
	//处理异常类型1的对象e
}catch(异常类型2 e){
	//处理异常类型1的对象e
}
//后续代码

• 如果try块中的代码产生了一个在catch语句中声明的异常：
  1. 程序将跳过try语句块中的其它代码；
  2. 程序将执行对应的catch子句中的处理代码；
  3. 程序将继续执行后续代码；
     代码演示

package Throw;

public class Throw02 {
    public static void main(String[] args ){
        int[] arr_a=new int[4];
        System.out.println("接下来会有异常！");
        try {
            arr_a[12]=123;
        } catch (ArrayIndexOutOfBoundsException e) {	//数组下标越界异常
            System.out.println("数组下标越界异常！");
        }
        System.out.println("End！");
    }
}

运行结果

代码演示

package Throw;

public class Throw03 {
    public static void main(String[] args){
        int[] arr_a=new int[4];
        System.out.println("接下来会有异常！");
        try {
            arr_a[12] = 123;
        }catch(Exception e){
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界异常！");
        }
        System.out.println("End！");
    }
}

运行结果

4.1、finally关键字

• 对于一些代码，可能会希望无论try块中的异常是否被抛出，它们都能得到执行——可以在异常处理程序后面加上finally子句 。

	try {
 	      // 可能产生异常的代码
	}catch（Type1 e）{
       // 对异常类型Type1的异常处理代码
	}
	………
	finally{
       // 退出try/catch代码块后要执行的代码
	}  

代码演示

package Throw;

public class Throw04 {
    public static void main(String[] args ){
        int[] arr_a=new int[4];
        System.out.println("接下来会有异常！");
        try {
            arr_a[12]=123;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界异常！");
        }finally{
            System.out.println("finally块执行了");
        }
        System.out.println("=======分割线=======");
        try {
            arr_a[0]=123;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界异常！");
        }finally{
            System.out.println("finally块执行了");
        }
        System.out.println("End！");
    }
}

运行结果

5、抛出异常

• 当程序发生异常时，会生成一个异常对象，这个对象会在方法内部被抛出。如果程序不捕获它，它就会被JVM捕获，程序也就终止了。
• 当有异常不想终止程序，有两种处理方法：
  1. 捕获并处理它，让程序继续运行；
  2. 捕获但不处理它，把它交给上一级程序处理；
• 如果不知道如何处理捕获的异常，应当将它传递出去，交与上一级程序处理——抛出异常。
• 语法：
  throw e;
e是某个异常的实例对象。
  代码演示

package Throw;

public class Throw05 {
    public static void main(String[] args ){
        int[] arr_a=new int[4];
        System.out.println("接下来会有异常！");
        try {
            arr_a[12]=123;
        } catch (ArrayIndexOutOfBoundsException e) {
            throw e;            //不做任何处理，直接抛出异常
        }
        System.out.println("End！");
    }
}

运行结果

6、声明异常

• 对于含有throw语句的方法，必须在定义方法的同时声明异常——提示使用此方法的人：调用此方法的过程可能会产生异常。
• 如果一个方法中没用显式处理可能会出现的受检异常，就必须对它进行声明。而对于方法中没有显示处理的非检异常，可以声明，也可以不声明。
• 声明异常语法：
  1. 在定义方法的“)”和“{”之间；
  2. 添加Throws ExceptionType；
  3. 如果方法中可能抛出不止一个异常，throws后必须声明所有可能抛出的异常，用“,”隔开；
• throw和throws的区别：
  1. throw没有s;throws有s;
  2. throw是语句，用来抛出异常；而throws是声明，用它修饰的方法可能会抛出异常。
  3. throw后面跟对象；throws后面跟类名；

6.1、抛出还是处理

• 抛出还是处理

1. 对于RuntimeException（运行是异常），不应该catch，它们属于能够解决的异常，应该尽量在程序中解决掉。
2. 其它Exception，如果方法能够解决就在方法中处理，否则交给上级程序处理。

7、自定义异常

• 尽管Java的内置异常处理了大多数常见的错误，但是Java的异常处理机制并不局限于处理这些错误，我们可以自己定义异常类来表示程序中可能会遇到的特定问题。
• 创建一个异常类很容易，只需定义一个Exception的子类即可。一般为其定义一个默认构造方法和一个参数为String的构造方法。
  代码演示

package Throw;

public class Throw06 extends Exception {
    public Throw06(){

    }
    public Throw06(String msg){
        super(msg);
    }

}

package Throw;

public class Demo {
    public static void main(String[] args)  {
        int flag=101;
        if(flag>100){
            try {
                throw new Throw06("分数不能大于100");
            } catch (Throw06 throw06) {
                throw06.printStackTrace();
            }
        }
    }
}

运行结果

这篇关于Java——异常处理的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！