1-Java常用工具类-异常
除了自定义类，java中还为我们提供了一系列的工具类。我们会为大家介绍6种最常用的工具类。
- 如何进行应用异常处理程序中的问题？(系统介绍)
- 如何通过包装器类实现基本数据类型的对象化处理
- String、StringBuilder是如何进行字符串信息操作的
- 常用集合框架及实现类使用
- 如何使用Java输入输出流进行文件读写
- 如何使用多线程实现数据并发通信(难度从上向下依次递增)
异常课程介绍
什么是异常？如何处理异常？
try-catch-finally;throw;throws;自定义异常;异常链
什么是异常？
异常: 意外、例外。异常本质上是程序上的错误。
错误在我们编写程序的过程中会经常发生,包括编译期间和运行期间的错误。
括号没有正常的配对; 语句结束后少写了分号;关键字编写错误 前面这几种都是编译期间的错误。通常这种错误编译器会帮助我们一起进行修订
但是运行期间的错误，编译器就无能为力了。
前面我们遇到的程序中的异常:
使用空的对象引用调用方法
String str=null;
System.out.println(str.length());
数组访问时下标越界
int[] ary={1,2,3};
for(int i=0;i<=3;i++){
System.out.println(ary[i]);
}
算术运算时除数为0
int one =12;
int two=0;
System.out.println(one/two);
类型转换时无法正常转型
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal{
}
public class Test {
public static void main(String[] args) {
Animal a1 = new Dog();
Animal a2 = new Cat();
Dog d1 = (Dog)a1;
Dog d2 = (Dog)a2;
}
以上都是运行期间的错误。以上这些代码在编译时是没有错误提示的。
在程序运行过程中,意外发生的情况,背离我们程序本身的意图的表现,都可以理解为异常。
错误执行 & 执行到崩溃
如何针对程序运行期间产生的异常进行合理的处理?
Java中有强大的异常处理机制。
异常分类
异常可以理解为一种事件，当它发生时会影响正常的程序运行流程。
Java中通过Throwable来进行各种异常信息的描述。
Error是程序无法处理的错误，表示运行应用程序中较严重问题。Java虚拟机问题(虚拟机错误 VirtualMachineError;内存溢出OutOfMemoryError;线程死锁 ThreadDeath);它们在应用程序的控制和处理能力之外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。
Exception是程序本身可以处理的异常。异常处理通常指针对这种类型异常的处理。
Exception可以分为两大类: 非检查异常(Unchecked Exception); 检查异常(Checked Exception)
非检查异常是编译器不要求强制处置的异常，它包括RuntimeException以及它的子类: 空指针异常 NullPointerException;数组下标越界异常 ArrayIndexOutOfBoundsException;算数异常 ArithmeticException;类型转换异常 ClassCastException;
java程序在编译阶段是不会去检查上面这些runtime异常的
检查异常，编译器要求必须处置的异常。如: IO异常 IOException; SQL异常 SQLException
异常处理分类
在Java应用程序中,异常处理机制为: 抛出异常;捕捉异常
异常要先被抛出，然后才能被捕获。
抛出异常指的就是当一个方法当中出现异常，方法会去创建异常对象，并去交付给运行时系统来进行处理。
异常对象: 异常类型以及异常出现时的程序状态等
当运行时系统捕获到这个异常，此时会去寻找合适的处理器，如果找到了，就会执行处理器的相关逻辑；如果始终没找到，运行就会终止
对于运行时异常、错误或可查异常, Java技术所要求的异常处理方式有所不同。
Java规定: 对于可查异常（检查异常(Checked Exception)）必须捕捉、或者声明抛出
允许忽略不可查的RuntimeException(含子类)和Error(含子类)。
对于抛出异常和捕获异常，Java中通过5个关键字来实现: try catch finally throw throws
其中try catch finally是一组，是用来捕获异常的。try 执行可能产生异常的代码; catch 捕获异常;finally 无论是否发生异常代码总能执行;
throws 声明可能要抛出的异常; throw 手动抛出异常
try-catch-finally简介
public void method(){
try {
//代码段1
//产生异常的代码段2
}catch (异常类型 ex) {
//对异常进行处理的代码段3
}finally{
//代码段4
}
}
try块后可接零个或多个catch快,如果没有catch块则必须跟一个finally块。简单来讲就是try要和catch或finally组合使用，不可单独存在。catch和finally如果没有try的加入，也是无法起作用的。
package cn.mtianyan.exception;
import java.util.Scanner;
public class TryDemo {
public static void main(String[] args) {
// // 定义两个整数，输出两数之商
// int one = 12;
// int two = 2;
// System.out.println("one/two="+one/two);
// 用户输入不可控
System.out.println("====运算开始====");
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数字: ");
int one = scanner.nextInt();
System.out.print("请输入第二个数字: ");
int two = scanner.nextInt();
System.out.println("one/two="+one/two);
System.out.println("====运算结束====");
}
}
注释部分是我们在程序写死的数字逻辑，是可以正常运行的。但一旦我们将这些变量交给了用户，那么用户输入的不可控因素就会给程序带来异常。
Exception in thread "main" java.lang.ArithmeticException: / by zero
at cn.mtianyan.exception.TryDemo.main(TryDemo.java:19)
Exception in thread "main" java.util.InputMismatchException
at java.base/java.util.Scanner.throwFor(Scanner.java:939)
at java.base/java.util.Scanner.next(Scanner.java:1594)
at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
at cn.mtianyan.exception.TryDemo.main(TryDemo.java:16)
try-catch结构进行异常处理
将可能出现异常的代码放在try块里。
package cn.mtianyan.exception;
import java.util.Scanner;
public class TryDemo {
public static void main(String[] args) {
// 用户输入不可控
System.out.println("====运算开始====");
try {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数字: ");
int one = scanner.nextInt();
System.out.print("请输入第二个数字: ");
int two = scanner.nextInt();
System.out.println("one/two=" + one / two);
}catch (Exception e){
System.out.println("程序出错啦");
}
System.out.println("====运算结束====");
}
}
有没有办法可以提示我是哪里出错，出的什么错呢？
catch (Exception e){
System.out.println("程序出错啦");
e.printStackTrace();
}
printStackTrace输出的格式有些诡异。错误栈应该是倒着看，最后一行是我们自己代码中的位置。
finally {
System.out.println("====运算结束====");
}
finally块保证一定会被执行。
使用多重catch结构处理异常
针对不同的异常有不同的处理方式该如何做到？
catch (ArithmeticException e){
System.out.println("除数不可以为0");
e.printStackTrace();
}catch (InputMismatchException e){
System.out.println("请输入整数");
e.printStackTrace();
}catch (Exception e){
System.out.println("程序出错了");
}
推荐最后使用Exception兜底，必须放在最后一个。
package cn.mtianyan.exception;
public class TestExercise {
public static void main(String args[]) {
try {
int a = 1 - 1;
System.out.println("a = " + a);
int b = 4 / a;
int c[] = {1};
c[10] = 99;
} catch (ArithmeticException e) {
System.out.println("除数不允许为0");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界");
}
}
}
上述代码的运行结果为:
第一次发生异常被捕获之后，程序去执行了catch块中的语句，不会再去执行首次出现异常行之下的try中代码
终止finally执行方法
通常情况，finally块是一定会执行的。
catch (ArithmeticException e){
System.exit(1);
System.out.println("除数不可以为0");
e.printStackTrace();
}
System.exit(1);终止当前虚拟机运行。程序无条件终止运行。
0代表正常退出,非0代表非正常退出。如果程序按照正常逻辑执行需要退出时,调用System.exit(O)。如果发生异常而退出,比如在catch块使用,则调用System.exit(1);
return关键字在异常处理中的作用
之前的学习中我们知道return关键字可以用于方法返回值的带回。
package cn.mtianyan.exception;
import java.util.Scanner;
public class TryDemoReturn {
public static void main(String[] args) {
System.out.println("one/two="+add());
}
public static int add(){
// 用户输入不可控
System.out.println("====运算开始====");
try {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数字: ");
int one = scanner.nextInt();
System.out.print("请输入第二个数字: ");
int two = scanner.nextInt();
return one/two;
}catch (ArithmeticException e){
System.out.println("除数不可以为0");
return 0;
} finally {
System.out.println("====运算结束====");
return -9999;
}
}
}
运行结果:
可以看到，不管有多少个return在前面，都会以最后一个finally中的return为准作为返回值。
删除掉finally中的return语句，程序就可以按照我们预期的状态运行。
package cn.mtianyan.exception;
public class TestExerciseTwo{
public static int test(int b){
try{
b+=10;
return b;
}catch(Exception e){
return 1;
}finally{
b+=10;
return b;
}
}
public static void main(String[] args) {
int num =10;
System.out.println(test(num));
}
}
运行结果:
使用throws声明异常类型
可以通过throws声明将要抛出何种类型的异常,通过throw将产生的异常抛出。
如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常。谁调用了这个方法，谁就该去处理这样的异常。
throws语句用在方法定义时声明该方法要抛出的异常类型。
public void method() throws Exception1,Exception2,...,ExceptionN {
//可能产生异常的代码
}
当方法抛出异常列表中的异常时,方法将不对这些类型及其子类类型的异常作处理,而抛向调用该方法的方法,由他去处理。
public static int add() throws ArithmeticException {
// 用户输入不可控
System.out.println("====运算开始====");
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数字: ");
int one = scanner.nextInt();
System.out.print("请输入第二个数字: ");
int two = scanner.nextInt();
System.out.println("====运算结束====");
return one / two;
}
上面的代码在方法中声明可能抛出的异常，去除掉方法自己的异常处理，交给上层处理。可以采取快捷键来生成try catch包裹(生成时会自动检查异常类型)。
try {
System.out.println("one/two=" + add());
} catch (ArithmeticException e) {
e.printStackTrace();
}
通过throws抛出异常时，针对可能出现的多种异常情况，解决方案:
1. throws后面接多个异常类型,中间用逗号分隔
2. throws后面接Exception，直接Exception的时候，编译器会提示你test方法可能会产生异常，因为Exception是父类包含了出现检查异常的情况。
而我们只写几个具体的异常类型(非检查型异常时)时是不会有提示的，如果想要提醒别人注意添加异常处理，可以添加文档注释。
/**
* 两数字相加的方法
* @return
* @throws ArithmeticException
* @throws InputMismatchException
*/
throw抛出异常对象
throw用来抛出一一个异常。
例如: throw new IOException();
throw抛出的只能够是可抛出类Throwable或者其子类的实例对象。
例如: throw new String("出错啦"); 是错误的
public void method(){
try {
//代码段1
throw new 异常类型();
} catch(异常类型 ex){
//对异常进行处理的代码段2
}
}
方案一: 自己抛出的异常自己进行异常处理。
方案二: 在抛出异常处通过throws关键字标明异常类型。
public void method() throws 异常类型{
//代码段1
throw new 异常类型();
}
- 规避可能出现的风险; 2. 完成一些程序的逻辑
场景: 要求:如果入住人员年龄在18岁以下或者80岁以上，必须由亲属陪同入住,不能单独入住。
public static void testAge() {
try {
System.out.println("请输入年龄：");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if (age < 18 || age > 80) {
throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
} else {
System.out.println("欢迎入住本酒店");
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
testAge();
}
运行结果:
throw抛出异常对象的处理方案：
1. 通过try..catch包含throw语句-自己抛自己处理
2. 通过throws在方法声明出抛出异常类型-谁调用谁处理-调用者可以自己处理，也可以继续上抛,此时可以抛出与throw对象相同的类型或者其父类
public static void testAge() throws Exception {
System.out.println("请输入年龄：");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if (age < 18 || age > 80) {
throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
} else {
System.out.println("欢迎入住本酒店");
}
}
try {
testAge();
} catch (Exception e) {
e.printStackTrace();
}
关于throw抛出异常类型问题的逼叨叨
public static void testAge() throws Throwable {
System.out.println("请输入年龄：");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if (age < 18 || age > 80) {
throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
} else {
System.out.println("欢迎入住本酒店");
}
}
try {
testAge();
} catch (Throwable e) {
e.printStackTrace();
}
因为Throwable是Exception异常的父类。throws后面不能是Exception的子类。
此时可以抛出与throw对象相同的类型或者其父类(不能是子类)
public static void testAge(){
System.out.println("请输入年龄：");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if (age < 18 || age > 80) {
throw new ArithmeticException();
// throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
} else {
System.out.println("欢迎入住本酒店");
}
}
非检查异常，不做强制处理。
testAge(); //无提示
throw抛出异常时是不推荐抛出非检查异常的。
自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。
也可以通过自定义异常描述特定业务产生的异常类型。
所谓自定义异常,就是定义一个类,去继承Throwable类或者它的子类。
新建一个类: HotelAgeException 继承自Exception类
package cn.mtianyan.exception;
public class HotelAgeException extends Exception{
public HotelAgeException(){
super("18岁以下，80岁以上的住客必须由亲友陪同");
}
}
public static void testAge() throws HotelAgeException {
System.out.println("请输入年龄：");
Scanner input = new Scanner(System.in);
int age = input.nextInt();
if (age < 18 || age > 80) {
throw new HotelAgeException();
} else {
System.out.println("欢迎入住本酒店");
}
}
因为是继承自Exception类的，会提醒throws。
try {
testAge();
} catch (HotelAgeException e) {
System.out.println(e.getMessage());
System.out.println("酒店前台工作人员不允许为其办理入住登记");
}
运行结果:
当然后面可以多添加几个catch来捕获。
异常链
有时候我们会捕获一个异常后在抛出另一个异常
后一个方法接收前一个方法抛出的异常对象。
package cn.mtianyan.exception;
public class TryDemoFive {
public static void main(String[] args) {
try {
testThree();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void testOne() throws HotelAgeException {
throw new HotelAgeException();
}
public static void testTwo() throws Exception {
try {
testOne();
} catch (HotelAgeException e) {
throw new Exception("我是新产生的异常1");
}
}
public static void testThree() throws Exception {
try {
testTwo();
} catch (Exception e) {
throw new Exception("我是新产生异常2");
}
}
}
最后只会获得最后一个方法调用时throw的异常，前面的异常都丢失了。如何解决这种异常的丢失情况，让异常链的情况为我们所知。
构造方法中添加上一层异常e，或者使用initCause(e)
public static void testOne() throws HotelAgeException {
throw new HotelAgeException();
}
public static void testTwo() throws Exception {
try {
testOne();
} catch (HotelAgeException e) {
throw new Exception("我是新产生的异常1",e);
}
}
public static void testThree() throws Exception {
try {
testTwo();
} catch (Exception e) {
Exception e1 = new Exception("我是新产生异常2");
e1.initCause(e);
throw e1;
}
}
顾名思义就是:将异常发生的原因一个传一个串起来,即把底层的异常信息传给上层,这样逐层抛出。
课程总结
程序中的异常
在程序运行过程中,意外发生的情况,背离我们程序本身的意图的表现,都可以理解为异常。
利用Java中的异常机制,我们可以更好地提升程序的健壮性。
在Java中, 通过Throwable及其子类描述各种不同的异常类型。
检查异常，编译器强制要求进行异常处理。
异常处理:
在Java应用程序中,异常处理机制为:抛出异常、捕捉异常
通过五个关键字来实现: try,catch,finally,throw,throws
try中未发生异常：直接执行try catch块后的代码段
当try块中发生了异常,产生异常对象与catch中异常类型匹配
当try块中发生了异常,产生异常对象与catch中异常类型不匹配
使用多重catch进行异常类型信息匹配
无论是否执行catch块通常都能正常执行。
一旦加入了System.exit(1)会强制终止执行
return关键字，一定是finally执行完成之后，才会去执行相应的代码。
实际应用中的经验与总结:
- 处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
- 在多重catch块后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
- 对于不确定的代码,也可以加上try-catch ,处理潜在的异常
- 尽量去处理异常,切忌只是简单的调用printStackTrace()去打印输出
- 具体如何处理异常,要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源
关于方法重写时throws的注意事项
可以通过throws声明将要抛出何种类型的异常,通过throw将产生的异常抛出。
如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常,
抛出的异常有两种处理方案: 自己处理，抛出谁调用谁处理。
当子类重写父类抛出异常的方法时,声明的异常必须是父类方法所声明异常的同类或子类。
package cn.mtianyan.exception;
public class FatherTest {
public void test() throws HotelAgeException {
throw new HotelAgeException();
}
}
package cn.mtianyan.exception;
public class SonTest extends FatherTest {
@Override
public void test() throws Exception { // 报错
}
}
public class SonTest extends FatherTest {
@Override
public void test() throws RuntimeException {
}
}
上面代码RuntimeException就不会报错。
package cn.mtianyan.exception;
public class HotelAgeException extends Exception{
public HotelAgeException(){
super("18岁以下，80岁以上的住客必须由亲友陪同");
}
}
class SubException extends HotelAgeException{
}
package cn.mtianyan.exception;
public class SonTest extends FatherTest {
@Override
public void test() throws SubException {
}
}
此时也是不会报错的。当子类重写父类抛出异常的方法时,声明的异常必须是父类方法所声明异常的同类或子类。
自定义异常: 可以通过自定义异常描述特定业务产生的异常类型。所谓自定义异常,就是定义一个类,去继承Throwable类或者它的
子类。
异常链: 当捕获一个异常后再抛出另一个异常时,如果希望将异常发生的原因一个传一个串起来 ,即把底层的异常信息传给上层,就形成了异常链。
构造方法带参数e或者initCause方式来实现。
在下一集中，我们将针对Java中包装类的相关知识进行学习,基本数据类型与其对应包装类的对应关系是怎样的呢?让我们来一一认识他们。
