JAVASE——异常
文章目录
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xsvfouvD-1644759423846)(E:\达内\图片\异常1.jpg)]
Java异常可以分为可检测异常,非检测异常。
从继承关系可知:Throwable
是异常体系的根,它继承自Object
。Throwable
有两个体系:Error
和Exception
,Error
表示严重的错误,程序对此一般无能为力,例如:
OutOfMemoryError
:内存耗尽NoClassDefFoundError
:无法加载某个ClassStackOverflowError
:栈溢出
而Exception
则是运行时的错误,它可以被捕获并处理。
某些异常是应用程序逻辑处理的一部分,应该捕获并处理。例如:
NumberFormatException
:数值类型的格式错误FileNotFoundException
:未找到文件SocketException
:读取网络失败
还有一些异常是程序逻辑编写不对造成的,应该修复程序本身。例如:
NullPointerException
:对某个null
的对象调用方法或字段IndexOutOfBoundsException
:数组索引越界
Exception
又分为两大类:
RuntimeException
以及它的子类;- 非
RuntimeException
(包括IOException
、ReflectiveOperationException
等等)
Java规定:
- 必须捕获的异常,包括
Exception
及其子类,但不包括RuntimeException
及其子类,这种类型的异常称为Checked Exception。 - 不需要捕获的异常,包括
Error
及其子类,RuntimeException
及其子类。
注意下面事项:
- catch 不能独立于 try 存在。
- 在 try/catch 后面添加 finally 块并非强制性要求的。
- try 代码后不能既没 catch 块也没 finally 块。
- try, catch, finally 块之间不能添加任何代码
- 在写程序时,对可能会出现异常的部分通常要用try{…}catch{…}去捕捉它并对它进行处理;
- 用try{…}catch{…}捕捉了异常之后一定要对在catch{…}中对其进行处理,那怕是最简单的一句输出语句,或栈输入e.printStackTrace();
- 如果是捕捉IO输入输出流中的异常,一定要在try{…}catch{…}后加finally{…}把输入输出流关闭;
- 如果在函数体内用throw抛出了某种异常,最好要在函数名中加throws抛异常声明,然后交给调用它的上层函数进行处理。
捕获异常
捕获异常使用try...catch
语句,把可能发生异常的代码放到try {...}
中,然后使用catch
捕获对应的Exception
及其子类:
package exception;
/**
* JAVA异常处理机制中的try-catch
* 语法:
* try{
* 可能出现异常的代码片段
* }
* catch(XXXException e){
* 当try中出现XXXException后的解决办法
* }
* 一般子类异常在上,父类异常在下
*/
public class TryException {
public static void main(String[] args) {
System.out.println("程序开始了");
try {
// String str = null;
// String str = "";//这样写就不会走catch
// /*
// 程序开始了
// 0
// 程序结束了
// */
String str = "a";
//这里会出现空指针异常,虚拟机会实例化空指针异常实例并在这里抛出异常NullPointerException
System.out.println(str.length());
System.out.println(str.charAt(0));
System.out.println(Integer.parseInt(str));
//当异常处理完毕后,jvm不会返回再执行下面的语句,而是跳出catch执行catch下面的语句
System.out.println("-------------------");
//ctrl +/ 可全都注释
// }catch(NullPointerException e){
// System.out.println("出现了空指针,并在这里得以解决!");
// //catch可以定义多个,针对不用的异常有不同处理办法时,可以分别捕获并处理
// }catch(StringIndexOutOfBoundsException e){
// System.out.println("出现了字符串下标越界了!并在这里解决!");
//可以合并捕获异常,当不同异常处理手段相同时,可以用这种方式
}catch(NullPointerException | StringIndexOutOfBoundsException e){
System.out.println("出现了空指针或下标越界的处理!");
}catch(Exception e){
System.out.println("兜底的,不知道出现什么异常,是一个超类");
}
System.out.println("程序结束了");
}
}
finally
package exception;
/**
* finally块
* finally是异常处理机制中的最后一块,它可以直接跟在try语句块之后或最后一个catch之后。
*
* finally语句块的特点
* 只要程序可以执行到try语句块,无论是否异常,最终都要执行finally块的代码。
*
* 因此我们会将如释放资源等操作放在finally中确保执行,比如IO操作后的close()调用
*/
public class FinallyDemo {
public static void main(String[] args) {
System.out.println("程序开始了");
//ctrl + alt + t
try {
String str = null;
System.out.println(str.length());
//return;加上此语句后,finally下面的代码不会执行,因此要加上finally保证代码的执行
}catch (Exception e) {
// System.err.println("!!!!!");
// System.out.println("出错了");
// //e.printStackTrace();
}finally{
//无论try中是否有异常,finally一定会执行
System.out.println("finally中的代码执行了");
}
System.out.println("程序结束了");
}
}
IO异常捕获(JDK7之前)
package exception;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 异常处理机制在IO操作中的应用
*/
public class FinallyDemo2 {
public static void main(String[] args) {
FileOutputStream fos = null;
try{
fos = new FileOutputStream("fos.dat");
fos.write(1);
} catch (IOException e) {
System.out.println("出错了!在这里解决了!");
}finally{
try{
if(fos!=null){
fos.close();
}
}catch(IOException e){
e.printStackTrace();
}
}
}
}
IO异常捕获( JDK7 之后)
package exception;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* JDK7后,java推出了自动关闭特性
* 使得我们在源代码中异常处理机制在IO应用中得到简化
* 编译器认可的,在jvm运行的时候会改成JDK7之前的写法
* try(
* 只有实现了AutoCloseable接口的类才可以在这里定义并初始化。
* 并且编译器在编译时会将在这里定义的变量在finally中调用close将其关闭。
* 最终编译器会将当前代码改为FinallyDemo2的样子。
* ){
*
* }
*/
public class AutoCloseDemo {
public static void main(String[] args) {
try(
FileOutputStream fos = new FileOutputStream("fos.dat");
){
fos.write(2);
}catch (IOException e){
System.out.println("出错了");
}
}
}
throws/throw 关键字:
throw是语句抛出一个异常,一般是在代码块的内部,当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常。throw用来对外主动抛出一个异常,通常下面两种情况我们主动对外抛出异常:
-
1:当程序遇到一个满足语法,但是不满足业务要求时,可以抛出一个异常告知调用者。
-
2:程序执行遇到一个异常,但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
-
throw new ArithmeticException();
throws是方法可能抛出异常的声明。(用在声明方法时,表示该方法可能要抛出异常)
throws关键字
当一个方法中使用throw抛出一个非RuntimeException的异常时,就要在该方法上使用throws声明这个异常的抛出。此时调用该方法的代码就必须处理这个异常,否则编译不通过。
当我们调用一个含有throws声明异常抛出的方法时,编译器要求我们必须处理这个异常,否则编译不通过。 处理手段有两种:
- 使用try-catch捕获并处理这个异常
- 在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。 具体选取那种取决于异常处理的责任问题。
package exception;
/**
* 使用当前类测试异常的抛出
*/
public class Person {
private int age;//年龄
public int getAge() {
return age;
}
public void setAge(int age) throws Exception{
if(age < 0 || age > 100){
// throw new RuntimeException("年龄不合法!");
/*
java中除了RuntimeException之外的其他异常throw抛出是编译器要求
必须在方法上使用throws声明该异常的抛出
*/
//PS:虽然使用try-catch也能保证不报错,但是这里没意义!
throw new Exception("年龄不合法");
}
this.age = age;
}
}
package exception;
/**
* 异常的抛出
* throw关键字可以主动抛出一个异常。
* 通常下列情况我们会主动抛出异常:
* 1:当前代码片段出现了异常,但是该异常不应当在当前代码片段被解决时,可以将其抛出
* 2:程序可以运行,但是不满足业务要求时可以对外抛出一个异常告知。(满足语法不满足业务)
*/
public class ThrowDemo {
public static void main(String[] args) {
Person p = new Person();
/*
当我们调用一个含有throws声明异常抛出的方法时,编译器要求我们必须处理该异常
否则编译不通过。
处手段有两种:
1:使用try-catch捕获其声明的异常
2:在当前方法上继续使用throws声明该异常的抛出
*/
try{
p.setAge(10000);//满足语法,但是不满足业务需求
}catch (Exception e){
e.printStackTrace();
}
System.out.println("此人年龄"+p.getAge());
}
}
throw与throws的比较
- throws出现在方法函数头;而throw出现在函数体。
- throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某种异常对象。
- 两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用处理。
throws/throw重写规则
package exception;
import java.awt.*;
import java.io.IOException;
/**
* 子类重写超类含有throws声明异常抛出的方法时对throws的重写规则
*
*/
public class ThrowsDemo {
public void dosome()throws IOException,AWTException{}
}
class SubClass extends ThrowsDemo{
// public void dosome() throws IOException,AWTException{}
//允许抛出部分异常
// public void dosome()throws IOException{}
//允许不再抛出任何异常
// public void dosome(){}
//允许抛出超类方法抛出的子类型异常
// public void dosome()throws FileNotFoundException{}
//不允许抛出额外异常(超类方法没有声明抛出的,或和超类声明抛出的异常没有继承关系的)
// public void dosome()throws SQLException{}
//不允许抛出超类方法抛出异常的超类型异常
// public void dosome()throws Exception{}
}
异常常用方法
package exception;
/**
* 异常常用方法
*/
public class ExceptionApiDemo {
public static void main(String[] args) {
try {
String str = "abc";
System.out.println(Integer.parseInt(str));//NumberFormatException
} catch (Exception e) {
//该方法用来在控制台输出异常的堆栈信息,便于程序员debug
e.printStackTrace();
//message:消息
String message = e.getMessage();//获取错误信息
//message一般用于给用户进行提示,或者记录log日志时使用。
System.out.println(message);
}
}
}
自定义异常
package exception;
/**
* 自定义异常
* 通常使用自定义异常用来表达业务错误
*
* 自定义异常应做到以下几点:
* 1.类名要见名知意
* 2.需要继承Exception(直接或间接均可)
* 3.提供超类中所有的构造器
* Illegal:非法的
*/
public class IllegalAgeException extends Exception{
public IllegalAgeException() {
}
public IllegalAgeException(String message) {
super(message);
}
public IllegalAgeException(String message, Throwable cause) {
super(message, cause);
}
public IllegalAgeException(Throwable cause) {
super(cause);
}
public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
package exception;
/**
* 使用当前类测试异常的抛出
*/
public class Person {
private int age;//年龄
public int getAge() {
return age;
}
public void setAge(int age) throws IllegalAgeException{
if(age<0 | age >100){
/*
java中除了RuntimeException之外的其他异常throw抛出是编译器要求
必须在方法上使用throws声明该异常的抛出
*/
//PS:虽然使用try-catch也能保证不报错,但是这里没意义!
// throw new Exception("输入的年龄不合法");
throw new IllegalAgeException("年龄超过了范围"+age);
}
this.age = age;
}
}
package exception;
/**
* 异常的抛出
* throw关键字可以主动抛出一个异常。
* 通常下列情况我们会主动抛出异常:
* 1:当前代码片段出现了异常,但是该异常不应当在当前代码片段被解决时,可以将其抛出
* 2:程序可以运行,但是不满足业务要求时可以对外抛出一个异常告知。(满足语法不满足业务)
*/
public class ThrowDemo {
public static void main(String[] args) {
Person p = new Person();
/*
当我们调用一个含有throws声明异常抛出的方法时,编译器要求我们必须处理该异常
否则编译不通过。
处手段有两种:
1:使用try-catch捕获其声明的异常
2:在当前方法上继续使用throws声明该异常的抛出
*/
try{
p.setAge(10000);
}catch(IllegalAgeException e){
e.printStackTrace();
}
System.out.println("此人年龄"+p.getAge());
}
}
ic static void main(String[] args) {
Person p = new Person();
/*
当我们调用一个含有throws声明异常抛出的方法时,编译器要求我们必须处理该异常
否则编译不通过。
处手段有两种:
1:使用try-catch捕获其声明的异常
2:在当前方法上继续使用throws声明该异常的抛出
*/
try{
p.setAge(10000);
}catch(IllegalAgeException e){
e.printStackTrace();
}
System.out.println(“此人年龄”+p.getAge());
}
}