8.杨明翰的Java教学系列之异常篇

Java教学系列 专栏收录该内容
11 篇文章 2 订阅


复习

1.使用接口的好处是什么?
2.Java的工作机制?
3.什么是方法重写与方法重载?
4.什么是Java三要素?
5.抽象类与接口的区别?
6.多态的三个必要条件?
7.this与super的用法?
8.final的用法?
9.方法有几种?分别是什么?区别是什么?
10.JDK&JRE&JVM分别是什么以及他们的关系?

前文链接

1.偏头痛杨的Java入门教学系列之认识Java篇
http://blog.csdn.net/piantoutongyang/article/details/70138697
2.偏头痛杨的Java入门教学系列之变量&数据类型篇
http://blog.csdn.net/piantoutongyang/article/details/70193622
3.偏头痛杨的Java入门教学系列之表达式&运算符&关键字&标识符&表达式篇
http://blog.csdn.net/piantoutongyang/article/details/71027446
4.偏头痛杨的Java入门教学系列之初级面向对象篇
http://blog.csdn.net/piantoutongyang/article/details/78135129
5.偏头痛杨的Java入门教学系列之流程控制语句篇
http://blog.csdn.net/piantoutongyang/article/details/71698589
6.偏头痛杨的Java入门教学系列之数组篇
http://blog.csdn.net/piantoutongyang/article/details/72510787
7.偏头痛杨的Java入门教学系列之进阶面向对象篇
http://blog.csdn.net/piantoutongyang/article/details/73176373


前言

程序是程旭猿编的,程序猿也是人,是人就会有出错的地方,就会有想不到的地方,
那么程序在运行的时候就会有出错的地方,及时你能保证程序没有出错的地方,
但你能保证用户的输入就按照你的意愿来?用户不会输入一些非法信息导致程序出现问题?
你能保证网络传输永远良好?硬件设备永远不出问题?操作系统永远不出问题?等等等等。
有太多种的情况是我们无法保证了,那这些我们无法保证的情况出现后,程序出错了。

一旦程序出错了之后,我们应该如何处理?如何解决?
有没有一套机制来hold?是把异常信息记录到日志中?
还是在出现某种异常后,需要运行一些代码?
还是出现某种异常后短信&微信报警?还是什么也不做?
今天我们来学习Java的异常体系。


什么是异常

所谓异常就是不正常的情况,程序在运行中出现了程序猿们始料未及的状况。。
异常机制使得我们的程序拥有更强大的容错性、健壮性。
异常分两种情况讨论:运行期间出现的错误与编译时的语法错误。

编译期间的语法错误

所谓编译期间,就是在程序还没有真正运行之前,编译器需要把源代码编译成字节码。
例如:写程序的时候少写了一个分号,或者关键字写错了,语法错了,
此时你的IDE工具(eclipse或IDEA)会给你报错,注意,此时还没有进行编译。
一旦你编译后,便会出现java.lang.Error的提示,然后编译失败。

运行期间出现的错误

编译全部通过后,程序开始运行,运行期间,由于种种原因导致程序出现异常情况,
例如你使用11/0,Java是不允许0当作除数的,那么便会抛出java.lang.ArithmeticException,例如你调用了一个null对象的属性,那么便会抛出java.lang.NullPointerException,
此时程序继续执行,而不会中断。
当然,在运行时,也可能会出现java.lang.Error,导致程序中断,例如内存溢出等错误。
那对于运行期间出现的错误,就是今天我们要讨论的重点。

运行期间异常的出现时机

打开一个不存在的文件?
网络连接中断?
操作数组越界?
调用一个null对象的属性or方法?
用户输入了非法数据?

给2个小例子:

String name = null;
System.out.println(name.length());

上述代码执行之后会出现:
Exception in thread “main” java.lang.NullPointerException
这就是空指针异常,被誉为“世界上最简单的异常”。

int i = 0;
String greetings[] = {"Hello World", "Hello Dingdang", "Hello Kitty"};
while(i<4){
  System.out.println(greetings[i]);
  i++;
}

上述代码执行之后会出现:
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
这就是数组下标越界异常。


异常的分类与层次结构

异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。
Java中的异常信息通过对象来表示。
Java对异常的处理是按异常分类处理的,不同异常有不同的分类,
每种异常都对应一个类型(class),类与类之间具有继承关系,
每个异常都对应一个异常(类的)对象。
在这里插入图片描述

Throwable

Throwable有两个重要的子类:Exception(异常)和 Error(错误),
二者都是Java异常处理的重要子类,各自都包含大量子类。
通常,这些实例是在异常情况的上下文中新近创建的,因此包含了相关的信息(比如堆栈跟踪数据)。

Throwable类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时,
才能通过 Java 虚拟机或者 Java throw 语句抛出。
类似地,只有此类或其子类之一才可以是 catch 子句中的参数类型。

错误error

Error表示恢复不是不可能但很困难的情况下的一种严重问题。
错误不是异常,而是脱离程序员控制的问题,不可能指望程序能处理这样的情况。
错误在代码中通常被忽略。
错误类定义被认为是不能恢复的严重错误条件。
在大多数情况下,当遇到这样的错误时,建议让程序中断。
大多数错误与代码编写者执行的操作无关。

例如:系统崩溃,代码运行时JVM出现的问题,
Java虚拟机运行错误(Virtual MachineError),
类定义错误(NoClassDefFoundError),
内存溢出错误(OutOfMemoryError),当JVM不再有继续执行操作所需的内存资源时,
这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。

异常exception

Exception是Java中所有异常的直接或间接父类,即Exception类是所有异常的根类。
Exception 类及其子类是 Throwable 的一种形式,它指出了合理的应用程序想要捕获的条件,
表示程序本身可以处理的异常。
Exception下面的异常又分两大类:检查性异常,非检查型异常。

检查性异常checked exception

检查性异常一般指程序编写没有错误,但程序运行后,可能由于用户的输入而造成的异常,
依赖于程序运行上下文。

若系统运行时可能产生该类异常,则必须写出相应的处理代码,否则无法通过编译,
checked异常相当于时刻在提醒程序员需要处理可能发生的异常,让程序变得更加严谨。
例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。

非检查性异常unchecked exception

非检查异常也叫运行时异常runtime exception,运行时异常是可能被程序员避免的异常。
与检查性异常相反,运行时异常可以在编译时被忽略。
RuntimeException表示一种设计或实现问题,如果程序运行正常,从不会发生的情况,
默认不需要进行异常处理。比如,如果数组索引扩展不超出数组界限,
那么,ArrayIndexOutOfBoundsException异常不会抛出。
当程序中可能出现这类异常时,即使没有用try…catch语句捕获它,
也没有用throws字句声明抛出它,还是会编译通过,这种异常可以通过改进代码实现来避免。

注意事项

  1. Java中凡是继承自Exception,而不继承自RuntimeException类以及其子类的异常都是checked exception,需要检查。
  2. 异常类之间也有父子类继承的关系。
  3. 所有的异常类是从 java.lang.Exception 类继承的子类。
  4. Java程序通常不捕获错误。错误一般发生在严重故障时,它们在Java程序处理的范畴之外。

异常处理

异常处理允许程序捕获异常,处理捕获的异常,然后继续程序执行。
异常的处理过程:
抛出异常->捕获异常->处理异常

在Java程序执行过程中如果出现异常,系统会发出异常报告,这时系统将生成一个异常类对象,
异常类对象封装了异常事件的信息并将其提交给Java运行时系统。

需要试一下,如果没有catch住的异常,异常下面的程序是否还会被执行?
书上写的是不会执行直接退出了。。。

try-catch关键字

Java中可用于处理异常的两种方式:

自行处理

把可能引发异常的语句封入在try块内,
所谓try块就是使用try关键字,后面接着一个花括号,try{},花括号里面放置可能出现异常的代码,而处理异常的相应语句则封入在catch块内,所谓catch块就是使用catch关键字,后面接着一个小括号和花括号,catch(Exception e){},小括号里放置需要捕获的异常类,花括号里放置捕获异常处理的代码。

回避处理

在方法声明中包含throws子句,通知潜在调用者,如果发生了异常,必须由调用者处理。

try块里的代码如果没有抛出异常则程序继续往下正常运行,如果有抛出异常则进入catch块。
catch块是用来捕获并处理try块抛出的异常的代码块。没有try块,catch块不能单独存在。
我们可以有多个catch块,以捕获不同类型的异常。

try-catch用法

在这里插入图片描述
如果程序抛出多个不同类型的异常,我们需要多个catch()语句来处理。

try {

}catch (ArrayIndexOutOfBoundsException e) {
  System.out.println(“Out of Bounds!);
} catch (RuntimeException e) {
  System.out.println(“Runtime Exception!);
} catch (Exception e) {
  System.out.println(“Exception!);
}

当引发异常时,系统会按顺序来查看每个catch语句,并执行第一个类型与异常类型匹配的语句。
catch(Exception e)表示每一条catch语句对应一个异常对象,系统将异常对象传递给e,
允许程序员对e进行操作,以便查看更多的异常信息等。
程序执行其中的一条catch语句之后,其他的catch语句将被忽略。
catch块的顺序为异常类父子类顺序,父类写在下面,子类写在上面,否则下面的类永远得不到执行机会

在JDK7之后,java允许每个catch可以同时捕获多种类型的异常。

public class ExceptionDemo2 {
	public static void main(String[] args) throws Exception {
		try {
			eat(1);
		}catch(NullPointerException | ArrayIndexOutOfBoundsException e) {
			//jdk1.7允许每个catch块捕获多个异常
			System.out.println("jdk1.7");
			e.printStackTrace();
		}catch(Exception e) {
			e.printStackTrace();
		}
		System.out.println("看看抛异常后是否还会运行?");
	}
	
	public static void eat(int n) throws NullPointerException,ArrayIndexOutOfBoundsException,IOException {
		if(n==1) {
			throw new NullPointerException();
		}else if(n==2) {
			throw new ArrayIndexOutOfBoundsException();
		}else if(n==3) {
			throw new IOException();
		}
	}
}

访问异常信息

我们在catch块中会使用异常类的对象,并调用异常对象的方法。
例如调用printStackTrace()方法则是打出堆栈信息。

try{

}catch(Exception ex){
  ex.printStackTrace();
}

下面列出常见的异常方法:

方法定义方法描述
public String getMessage()返回关于发生的异常的描述信息(不详细)。
public Throwable getCause()返回一个Throwable 对象代表异常原因。
public String toString()使用getMessage()的结果返回类的串级名字。
public void printStackTrace()打印异常的栈跟踪信息,常用于查找异常的原因。
public StackTraceElement [] getStackTrace()返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
public Throwable fillInStackTrace()用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

注意事项

  1. catch块里可以什么都不写,这样也算是处理异常,但通常不推荐这么做;
  2. 一旦异常被catch住,那么程序可以继续往下进行,除非你在catch块中又抛出了异常或返回;
  3. try{}和catch(){}之间不可以添加任何代码;
  4. try-catch是可以嵌套的;
  5. try{}中定义的变量属于局部变量,只能在try{}中使用;
  6. 如果没有catch住异常,那么理论上异常出现的代码之后的代码就没有机会执行了;

throws关键字

如果一个方法中的语句执行时可能抛出某种异常,但是并不能确定如何处理,
则可以在程序所在的方法声明后,使用throws关键字抛出异常 ,让调用者来解决这个问题。

class ThrowsDemo{
  public void proc() throws IOException{
    System.out.println("inside proc");
  }
}

你自己来决定出现异常后是由自己来处理还是往上抛,反弹给调用你方法的人。
父子类情况下的throws,如果子类重写父类方法:

  1. 如果父类方法没有throws异常,则子类方法也不能throws异常;
  2. 如果父类方法有throws异常,则子类方法throws的异常一定不能是父类异常的父类;
  3. 如果父类方法throws RuntimeException,则子类不能throws checked exception;

注意事项

  1. 所有的RuntimeException以及其子类异常,都不用显式的进行throws与try-catch,
    当然写了也不算错;
  2. throws后面的异常可以有多个,允许使用逗号分隔;

throw关键字

当程序出现异常时,一般情况下由系统自动抛出异常,但也可以由程序员手动抛出异常。
异常可以通过关键字throw抛出,不要与throws关键字混淆。

void doA() throws Exception {
  try {
    
  } catch(Exception1 e) {
    throw e;
  } catch(Exception2 e) {
    System.out.println("出错了");
  }
}

throw语句用在方法体内,表示抛出异常,由方法体内的语句处理。
如果抛出的是checked exception则不能单独使用,要么和try-catch一起使用,
要么和throws一起使用,如果抛出的是runtime exception,则允许单独使用。
throw语句的操作数一定是Throwable类类型或Throwable子类类型的一个对象。

catch与throw连用

  1. 有时候,在catch住异常进行相关处理后还需要调用方进行连带的处理,
    那么我们就需要在catch块进行相关处理后再throw异常,让调用方进行相应处理,
    如果catch块中没有写throw,则调用方是无法感知到异常存在的,同时也无法处理异常。
    类似于一个异常向上传递的过程。

  2. 我们完全没有必要把底层的一些异常直接抛到最上层,
    例如,不要把底层数据库的异常抛给用户去看,这样很不安全,
    因此可以通过在catch住sql的异常后,在catch块中做了相应的异常处理后,
    再通过throw往上抛一个业务相关的异常,这样对用户友好且安全。

finally关键字(不要与final关键字混淆)

finally语句放在try-catch语句后。
finally语句中的代码块不管异常是否被捕获总是要执行。

通常在finally语句中可以进行资源的清除操作,如:关闭打开文件、删除临时文件。

对应finally代码中的语句,即使try代码块和catch代码块中使用了return语句退出当前方法,
相关的finally代码块都有执行。

try{

catch (ArrayIndexOutOfBoundsException e) {
  System.out.println(“Out of Bounds!);
  return;
} catch (RuntimeException e) {
  System.out.println(“Runtime Exception!);
} catch (Exception e) {
  System.out.println(“Exception!);
} finally{
  System.out.println(“program is running into finally!);
}

注意事项

  1. 当try或catch代码块中执行了System.exit(0)时,finally代码块中的内容不被执行;
  2. 在try/catch后面添加finally块并非强制性要求的;
  3. try代码后不能既没catch块也没finally块,至少二选一,也可以同时出现;
  4. 垃圾回收器只能回内存上的内存,却不能回收物理资源,例如io、连接等等;

finally的大坑,非常常见的面试题

public static void main(String[] args) throws Exception {
  System.out.println("最后返回------>"+eat(null));
}

public static int eat(String name) {
  int temp = 0;
  try {
    if(name==null){
      throw new Exception();
    }
    return temp;
  } catch(Exception e){
    System.out.println("catch......");
    temp = 2;
    System.out.println("catch要准备返回了...");
    return temp;
  } finally {
    temp = 3;
    System.out.println("finally...");
    System.out.println("在finally的temp是"+temp);
  }
}

输出的结果是:
catch…
catch要准备返回了…
finally…
在finally的temp是3
最后返回------>2

为什么明明在finally里都已经把temp赋值3了,返回的依然是2呢?
在catch块中return的前一刻先按一下"暂停键",要返回的值依然是那个先不动,然后去调用finally,
无论finally怎么弄,都不会影响catch块中影响的结构,但除了一种情况,那就是在finally里写了return,
在finally中写了return和throw后,那么try/catch块中的return被throw就会被忽略掉。
因此尽量不要在finally中写throw和return;

finally {
  temp = 3;
  System.out.println("finally...");
  System.out.println("在finally的temp是"+temp);
  return temp;
}

输出的结果是:
catch…
catch要准备返回了…
finally…
在finally的temp是3
最后返回------>3

JDK7自动关闭资源的try块

JDK7之前,为了回收资源则需要通过编写finally块来搞定,显得十分臃肿。
JDK7之后,java提供了一种自动关闭资源的try块,来简化程序,try块程序执行结束后,
会自动关闭相关的资源,这里的try块允许独立存在,也可以接catch块与finally块。
JDK7将许多资源类进行改写,包括IO类、Connection、Statement等等,
让他们全部实现了AutoCloseable或Closeable接口。

相关的资源类必须实现AutoCloseable或Closeable接口,以及实现close()。

public class ExceptionDemo3 {
	public static void main(String[] args) throws Exception {
		//jdk7的会自动关闭资源的try块
		try (PrintStream ps = new PrintStream(new FileOutputStream("aaa.txt"));) {
			ps.println("abc");
		} 
	}
}

常见异常类

Java 语言定义了一些异常类在 java.lang 标准包中。
由于 java.lang 包是默认加载到所有的 Java 程序的,
所以大部分从运行时异常类继承而来的异常都可以直接使用。

在Java中提供了一些异常用来描述经常发生的错误,对于这些异常,
有的需要程序员进行捕获处理或声明抛出,
有的是由Java虚拟机自动进行捕获处理。

常见unchenck异常

RuntimeException以及其子类

异常名字(英文)异常名称(中文)描述
ArrayIndexOutOfBoundsException数组下标越界异常数组索引越界异常,当对数组的索引值为负数或大于等于数组大小时抛出。
ArithmeticException算术条件异常整数除零等。
NullPointerException空指针异常当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
IllegalArgumentException非法参数异常表明向方法传递了一个不合法或不正确的参数。
ClassCastException类型转换异常当试图将对象强制转换为不是实例的子类时,抛出该异常。
NumberFormatException数字转换异常字符串转换为数字抛出的异常,当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。

常见chenck异常

除了RuntimeException以及其子类之外的类

异常名字(英文)异常名称(中文)描述
ClassNotFoundException找不到类异常当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。
FileNotFoundException文件未找到异常所需要的文件不存在。
NoSuchFieldException属性未找到异常所需要的属性不存在。
NoSuchMethodException方法未找到异常所需要的方法未不存在。
IllegalAccessException非法访问某类异常拒绝访问一个类的时候,抛出该异常。

自定义异常

异常类从哪里来?
1.Java语言本身定义的一些基本异常类型;
2.用户通过继承Exception类或者其子类自己定义的异常;
Exception类及其子类是Throwable一种形式,它指出了合理的应用程序想要捕获的条件。

如果Java提供的异常类型不能满足程序设计的需要,我们可以定义自己的异常类型。
我们可以通过判断自定义异常类,来做不同的异常处理,例如XXX异常需要短信报警,
YYY异常需要记录log,ZZZ异常需要去刷数据等等。

定义自己的异常类(这种异常类可以包含一个“普通”类所包含的任何东西)

如果你想写一个运行时异常类(unchecked exception),
那么需要继承 RuntimeException 类或其子类。

public class YangException extends RuntimeException {
     /**
      *
      */
     private static final long serialVersionUID = -1998686844673228031L;
     private String reason;
     private int port;

     public YangException(String reason, int port) {
          this.reason = reason;
          this.port = port;
     }

     public String getReason() {
          return reason;
     }

     public void setReason(String reason) {
          this.reason = reason;
     }

     public int getPort() {
          return port;
     }

     public void setPort(int port) {
          this.port = port;
     }
}

跟其他的异常一样处理

public class YangExceptionMainDemo {
     public static void main(String[] args) {
          try {
              eat();
          } catch (YangException e) {
              e.printStackTrace();
          }
     }

     public static void eat(){
          throw new YangException("hahaha",8080);
     }
}


异常使用建议

在日常的开发工作中,总结了一些所谓的经验,仅供参考。

  1. 不要滥用异常
    异常也需要耗费内存,过度使用异常机制不利于性能,尤其是高并发场景。
    抛出异常首先要创建一个新的对象。
    Throwable接口的构造函数调用名为fillInStackTrace()的本地(Native)方法,fillInStackTrace()方法检查堆栈,收集调用跟踪信息。
    只要有异常被抛出,VM就必须调整调用堆栈,因为在处理过程中创建了一个新的对象。
    因此异常捕获是一件很”昂贵“的事情。
    异常机制确实方便好用,并不代表可以不节制的去滥用,能尽量不走异常机制的错误,
    尽量不走异常机制,例如:参数合法性校验,程序执行逻辑错误,逻辑控制等等。
    因此建议,对于那些我们全部能掌控的异常场景就不用异常机制,出乎意料外的场景再使用异常机制。

  2. 不要把try块设计的过大
    我们经常爱把一坨代码扔进try块中,因为方便对吗?但这样并不利于文异问题分析查找。

  3. 异常处理尽量放在高层进行
    尽量将异常统一抛给上层调用者,由上层调用者统一之时如何进行处理。
    如果在每个出现异常的地方都直接进行处理,会导致程序异常处理流程混乱,
    不利于后期维护和异常错误排查。由上层统一进行处理会使得整个程序的流程清晰易懂。
    异常情况,不用挨个在controller里各种封装了,直接把抛出来的异常放到AOP里封装,
    两种自定义exception,一个是走json的,一个是走页面跳转的,就是抛出来一个自定义异常,
    然后封装成“系统内部错误”,不能让用户看到我们的具体出错信息。
    不用每个方法都throws了,也不用每个方法都try catch了,直接写一个自定义异常,让他继承至RuntimeException。

  4. 切忌使用空catch块
    在捕获了异常之后什么都不做,相当于忽略了这个异常。千万不要使用空的catch块,
    空的catch块意味着你在程序中隐藏了错误和异常,并且很可能导致程序出现不可控的执行结果。
    如果你非常肯定捕获到的异常不会以任何方式对程序造成影响,最好用Log日志将该异常进行记录,
    以便日后方便更新和维护。

  5. 避免多次在日志信息中记录同一个异常
    只在异常最开始发生的地方进行日志信息记录(或者最外层)。
    很多情况下异常都是层层向上抛出的,如果在每次向上抛出的时候,
    都Log到日志系统中,则会导致无从查找异常发生的根源。


总结

如果在执行try块的代码时出现了异常,系统会自动生成一个Exception对象,该对象提交给java运行时环境,这个过程被称为抛异常。抛异常后,系统会寻找处理异常的catch块,这个过程被称为捕获异常。

Java异常处理的目的是提高程序的健壮性,你可以在catch和finally代码块中给程序一个修正机会,
使得程序不因异常而终止或者流程发生以外的改变。同时,通过获取Java异常信息,
也为程序的开发维护提供了方便,一般通过异常信息就很快就能找到出现异常的问题&代码所在。


作业

编写一个方法,入参为一个整型变量。

输入1则抛出空指针异常;
输入2则抛出数组下标越界异常;
输入3则抛出IO异常;
否则不抛异常,输出:“今天没有异常耶”。

不管是否有异常,都要输出:“方法正在呗调用”
异常需要在调用者的方法处理,

空指针异常则输出"给jack打电话"
IO指针异常则输出"给sean打电话"
数组下标越界异常则输出"给clarck打电话"

  • 1
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 精致技术 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值