Java基础之异常的捕获与处理4月打卡day01

关于作者

• 作者介绍

---

🍓 博客主页：作者主页

🍓 简介：JAVA领域优质创作者🥇、一名在校大三学生🎓、在校期间参加各种省赛、国赛，斩获一系列荣誉🏆。

🍓 关注我：关注我学习资料、文档下载统统都有，每日定时更新文章，励志做一名JAVA资深程序猿👨‍💻。

1、异常的捕获与处理

异常时导致程序中断执行的一种指令流。程序出现异常没用合理处理，就会导致程序终止执行。

观察没有异常产生的程序

public class TestDemo1{
	public static void main(String args[]){
		System.out.println("1、除法程序开始");
		int result =10/2;
		System.out.println("2、除法程序结果："+result);
		System.out.println("3、除法程序结束");
	}
}
/*
1、除法程序开始
2、除法程序结果：5
3、除法程序结束
*/

产生异常的程序

public class YiChang{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		int result =10/0;//会出现错误
		System.out.println("2,除法程序结果："+result);
		System.out.println("3,除法程序结束");
	}
}
/*
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at YiChang.main(YiChang.java:5)
*/

这个时候程序出现了错误，那么出现错误之后程序不执行了，而是直接进行了错误信息的输出，并且直接结束了程序，但是，出现了错误，应该去处理才对，但是现在没有处理。

1.1 处理异常

现在，如果希望程序出现了异常之后，程序依然可以正常的完成的话，那么就可以使用如下的格式进行异常的处理；

		try{
可能出现异常的语句
		}[catch(异常类型 异常对象){
			处理异常；
		}catch(异常类型 异常对象){
            处理异常；
}…][finally{
    异常统一出口
    不管是否出现异常，都执行此代码；
}]

使用该操作进行异常的处理

public class TestDemo1{
	public static void main(String args[]){
		System.out.println("1、除法程序开始");
		try{
			int result =10/0;
			System.out.println("2、除法程序结果："+result);
		}catch(ArithmeticException e){
		System.out.println("异常被正确的处理了");
		}
		System.out.println("3、除法程序结束");
	}
}
/*
1、除法程序开始
异常被正确的处理了
3、除法程序结束
*/

可以发现加入了异常处理之后，程序之中即使有了异常，程序也可以正常执行完毕，但是现在发现，异常处理时的错误输出信息和之前相比，出错的信息不明确了，那么为了让错误的信息更加完整，一般而言，都会调用printStackTrace()方法进行异常信息的打印

这个方法(printStackTrace)打印的异常信息是最完整的：

try{
	int x = 10/0;     //异常
	System.out.println("2,除法程序结果："+x);
}catch(ArithmeticException e){
	e.printStackTrace();
}

try catch finallly 操作

public class TestDemo1{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		try{
			int x = 10/0;     //异常
			System.out.println("2,除法程序结果："+x);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}finally{
			System.out.println("不管是否异常都会执行");
		}
		System.out.println("3,除法程序结束");
	}
}

但是，对于之前的程序现在又有了问题：现在执行数学计算的两个参数，都是由程序默认提供，那么如果说现在两个计算的参数通过初始化参数传递呢？

public class TestDemo2{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		try{
			int x = Integer.parseInt(args[0]);	//接收参数
			int y = Integer.parseInt(args[1]);    //接收参数
			int result = x/y;   
			System.out.println("2,除法程序结果："+result);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}finally{
			System.out.println("不管是否异常都会执行");
		}
		System.out.println("3,除法程序结束");
	}
}

时候发现，数据由外部传送，那么在这种情况下，就有可能出现一下几类问题：

​ 执行时不输入参数，ArrayIndexOutOfBoundsException，未处理。

​ 输入的参数不是数字，NumberFormatException，未处理。

​ 被除数为0，ArithmeticException，已处理。

可以发现，以上的程序实际上是存在三种异常，而程序之中只能处理一种，而对于不能处理的异常，发现程序依然会直接中断执行。

public class TestDemo2{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		try{
			int x = Integer.parseInt(args[0]);	//接收参数
			int y = Integer.parseInt(args[1]);    //接收参数
			int result = x/y;   
			System.out.println("2,除法程序结果："+result);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}catch(ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
		}catch(NumberFormatException e){
			e.printStackTrace();
		}finally{
			System.out.println("不管是否异常都会执行");
		}
		System.out.println("3,除法程序结束");
	}
}

此时，问题就来了，如果按照以上的方式一次一次的测试来进行异常类型的推断，还不如直接编写if…else。

1.2 异常处理的流程

以上已经完成了异常的基本处理流程，但是也可以发现问题，所有的异常都像之前那样一条条的判断似乎是一件不可能完成的任务，因为以后肯定会接触到一些不常见的异常信息，那么下面就必须首先研究异常的流程和结构。

首先查看两个异常的继承结构

ArithmeticException
java.lang.Object
java.lang.Throwable
java.lang.Exception java.lang.RuntimeException
java.lang.ArithmeticException
    

ArrayIndexOutOfBoundsException
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.IndexOutOfBoundsException
java.lang.ArrayIndexOutOfBoundsException

可以发现所有的异常类型最高的继承类是Throwable，通过doc文档可以发现Throwable下有两个子类：

​ Error:指的是JVM错误，这个时候的程序并没有执行，无法处理；

​ Exception:指的是程序之中出现了错误信息，可以进行异常处理，主要关心Exception。

​ 那么通过继承关系可以发现，肯定在进行日常处理的时候是以Exception为主，而这个时候就可以形成以下的异常处理流程。

1.3 throw关键字

throws关键字主要是在方法定义上使用的，表示的是此方法之中不进行异常处理，而交给被调用处处理。

class MyMath{
    //现在的div()方法之中抛了一个异常出来，表示的是，所有的异常交给被调用处进行处理。
	public int div(int x,int y) throws Exception{
			return  x/y;
	}
}
public class TestDemo3{
	public static void main(String args[]){
		try{
			System.out.println(new MyMath().div(10,0));
		}catch(Exception e){
			e.printStackTrace();	
		}
	}
}

在调用throws声明方法的时候，一定要使用异常处理操作进行异常的处理，这是是属于强制性的处理，而现在主方法本身也属于方法，那么实际上在主方法上也可以继续使用throws进行异常的抛出。

class MyMath{
    //现在的div()方法之中抛了一个异常出来，表示的是，所有的异常交给被调用处进行处理。
	public int div(int x,int y) throws Exception{
			return  x/y;
	}
}
public class TestDemo3{
	public static void main(String args[]) throws Exception{
		try{
			System.out.println(new MyMath().div(10,0));
		}catch(Exception e){
			e.printStackTrace();	
		}
	}
}

这个时候表示的是将异常继续向上抛，交给JVM进行异常的处理。

请解释throw和throws区别？

• throw用于方法内部表示进行手工的抛出
• throws主要用于方法声明上使用，明确的告诉本方法可能产生的异常，同时该方法可能不处理异常。

1.4 异常处理模型

现在觉得有两个内容实在没用finally，throw。

现在要求定义一个div()方法，而这个方法有如下一些要求：

​ 在进行除法操作之前，输出一行提示信息。

​ 在除法操作执行完毕后，输出一行提示信息。

​ 如果中间产生了异常，则应该交给被调用处来进行处理。

class MyMath{
	public static int div(int x, int y) throws Exception{
		int result = 0;
		//不写catch语句的执行流程
		//首先进行try代码块的执行后执行finally代码块执行完成后执行
		//throws进行异常捕获，捕获完成后再主方法catch语句中进行执行
		try{
			System.out.println("before进行除法计算");
			result = x / y;
		}finally{
			System.out.println("after进行除法计算");
		}		
		return result;
	}
}
public class TestDemo4{
	public static void main(String args[]){
		try{
			System.out.println(MyMath.div(10,0));
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

1.5 RuntimeException

public class TestDemo4{
	public static void main(String args[]){
		String str = "123";
		int num = Integer.parseInt(str);
		System.out.println(num*num);
	}
}

这个方法就是将一个字符串变为了基本数据类型，而后执行乘法操作，但是下面来看一下parseInt()方法的定义:

Public static int parseInt(String s) throws NumberFomatException

发现这个方法上抛出了一个NumberFomatException的异常，按照之前所讲，如果存在了throw，则必须使用try….catch进行处理，可是现在去没有强制要求处理，来观察一下NumberFomatException的继承结构。

java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.IllegalArgumentException
java.lang.NumberFormatException

发现NumberFormatException属于RuntimeException的子类，而在Java之中明确规定了，对于RuntimeException的异常类型可以有选择型的来进行处理，在开发之中，如果，没有处理，那么出现异常之后将交给JVM默认进行处理。

Exception和RuntimeException的区别？请你举出常见的RuntimeException？

• Exception是RuntimeException的父类，使用Exception定义的异常必须使用异常处理

• RuntimeException可以由用户选择性的异常处理

• 常见的Exception：NumberFormatException，ClassCastException，NullPointException,ArithmeticException,ArrayIndexOutBoundException。

1.6 断言：assert

断言指的是程序执行到某行之后，其结果一定是预期的结果，而在JDK1.4之后增加了一个assert关键字。

public class DuanYan{
	public static void main(String args[]){
		int x = 10;
		//假设经过了很多操作
		assert x == 30:"x的内容不是三十";
		System.out.println(x);
	}
}

默认情况下，Java之中的断言不会在正常执行的代码中出现，如果想要启用断言，则应该早呢更加一些选项。

1.7 自定义异常

在Java之中本省已经提供了大量的异常类型，但是在开发之中，这些异常类型根本就不能满足开发的需要，所以在一些系统架构之中往往会提供一些新的异常类型，来表示一些特殊的错误，而这种操作就称为自定义异常类，而要想实现这种自定义异常类，那么可以让一个类继承Exception或RuntimeException。

class MyException extends Exception{
	public MyException(String str){
		super(str);
	}
}
public class TestDemo5{
	public static void main(String args[]) throws Exception{
		throw new MyException("自己的异常类");
	}
}

如果以后见到了一些没见过的异常类型，那么基本都是自定义的异常类。

后语

厂长写博客目的初衷很简单，希望大家在学习的过程中少走弯路，多学一些东西，对自己有帮助的留下你的赞赞👍或者关注➕都是对我最大的支持，你的关注和点赞给厂长每天更文的动力。

对文章其中一部分不理解，都可以评论区回复我，我们来一起讨论，共同学习，一起进步！