Throwable异常

异常处理

概述

异常: 就是指程序出现了不正常的情况

用来封装错误信息的对象。

组成结构：类型，提示，行号。

异常的继承结构

查看Java的API文档可知, Java中所有错误和异常的顶级父类是Throwable类

Throwable类下有两个子类, 分别是Error和Exception, 两者的区别是:

1. Error: 是指不需要捕获的严重问题, 通常是java程序以外的问题, 比如硬件问题或者内存不足导致的问题等
   因此, 如果java程序中出现了Error, 我们无需处理。

2. Exception: 称为异常类, 它表示程序本身可以处理的问题

Exception下有很多异常子类, 其中有一个异常子类是RuntimeException类, 这里还可以将异常分为两大类:

1. 编译时异常:
   其他异常类以及不是RuntimeException子类的异常类都是检查异常(也叫编译时异常)
   在编写完程序后, Java编译器会对其进行检查, 如果检查出此类异常, 就必须要显式处理, 否则程序将无法进行编译。
   例如:ClassNotFoundException、
   FileNotFoundException、
   SQLException等都是编译时异常。

2. 运行时异常:
   RuntimeException以及子类被称为未经检查的异常(也叫运行时异常)
   这类异常通常在编写完程序后没有问题, 但是运行程序才出现异常, 需要我们回来修改代码进行解决的异常
   这类异常无需显式处理, 当然也可以像编译时异常一样处理
   例如:IndexOutOfBoundsException、
   ArithmeticException、
   NullPointerException、
   ClassCastException 等都是运行时异常。

判断一个异常是不是运行时异常, 可以通过检查这个异常类是不是RuntimeException的子类, 或者检查这个异常是否只有在程序运行时才会出现!

虚拟机的默认处理方式

如果程序在运行时出现了问题，而我们又没有处理该问题，最终虚拟机会做默认的处理，而这种默认处理方式为:

1. 将异常的名称(类型)、异常的原因以及异常出现的位置等信息输出在了控制台（Console窗口）

2. 将程序停止运行（这意味着，出现异常的代码后面的代码将不会再执行）

异常示例-1：

package exception;
​
/**
 * 异常示例
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        //没有报错,表示没有编译期异常
        //执行代码,报错了,说明有运行时异常
        int i = 1/0;
        System.out.println("hahaha");
    }
}
运行结果:
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at exception.ExceptionDemo.main(ExceptionDemo.java:10)
异常示例-2：
package exception;
​
/**
 * 异常示例
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,2,3,4,5,6};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println(arr[5]);
        System.out.println(arr[6]);
​
    }
}

运行结果:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
    at exception.ExceptionDemo2.main(ExceptionDemo2.java:16)

如果程序出现了异常, 需要我们自己处理, 有两种方案:

1. 使用try…catch…进行处理(捕获异常)
2. 使用throws进行处理(抛出异常)

异常处理之try…catch…处理

try…catch处理异常的格式为:

try{
  可能出现异常的代码;
}catch(异常类型 变量名){
  异常处理代码; 
  //当try中的代码出现了异常并且这个异常能和catch中的异常类型匹配上, 才会执行catch
  //反之, 如果出现的异常和catch中的异常类型不匹配, 就不会执行catch
}

执行流程为:

1. 程序执行到try{}中的代码时, 如果出现了异常, 将会自动产生一个异常对象, 该异常对象将会被提交给java运行时系统;

2. 当Java运行时系统接收到异常对象时, 回到catch()中寻找匹配的异常类型, 找到后就进入catch{}中进行异常的处理;

3. 执行完毕后, 程序还可以继续执行try…catch之后的代码

代码案例1

package exception;
​
/**
 * try{
 * 可能出现异常的代码
 * }catch(异常类型 异常的变量名){
 * 异常处理代码
 * }
 */
public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        try {//包裹可能会出现问题的代码
            //String str = null;
            //String str = "";
            String str = "a";
            System.out.println(str.length());
            System.out.println(str.charAt(0));
            //这里执行时,一定会出现数字格式异常
            System.out.println(Integer.parseInt(str));
            //try语句块中某处出错了,这句代码之后的内容不会执行
            System.out.println("老安到此一游");
// 选中要注释的代码,ctrl+/ 快速注释
        } catch (NullPointerException e) {
            //只有try中出现了空指针异常,才会执行这部分代码
            System.out.println("出现了空指针,并在这里得到了解决");
            //catch可以定义多个,针对不同的异常可以有不同的处理方案,此时,可以分别捕获分别处理
        } catch (StringIndexOutOfBoundsException e) {
            System.out.println("出现了字符串下标越界异常,并在这里得到了解决");
            //直接捕获异常超类,那么try中不论出现什么异常,都可以进行捕获,经常用来兜底
        } catch (Exception e) {
            System.out.println("出现了异常,并在这里得到了解决");
        }
        //合并捕获异常,当不同的异常处理手段相同时,可以使用这种方式
        //}catch (NullPointerException|StringIndexOutOfBoundsException e){
​
        System.out.println("程序结束了");
    }
}

finally块

作用就是确保一定要执行某些代码

代码案例

package exception;
​
/**
 * finally块
 * finally块是异常处理机制中最后一块,它可以直接跟在try语句块之后,或者最后一个catch之后
 * finally块特点:
 * 只要程序可以执行到try语句块中,无论是否出现异常,都会最终执行finally块中的内容.
 * 因此我们会将一些必须要执行的内容比如:资源的释放等操作放在finally块中确保执行
 */
public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了!");
        //选中要包裹的代码,然后crtl+alt+T,选择try/catch
        try {
            //此处一定有空指针异常
            String str = null;
            System.out.println(str.length());
            return;//程序执行到return会直接结束方法
        } catch (Exception e) {
            System.out.println("出错了!");
        } finally {//只要程序走到try中,此部分代码一定执行
            System.out.println("finally中的代码执行了!");
        }
        System.out.println("程序结束了");
    }
}

代码案例2

package exception;
​
import java.io.FileNotFoundException;
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.txt");
            fos.write(1);
        } catch (IOException e) {
            System.out.println("出错了!在这里得到了解决");
        } finally {
            try {
                if (fos!=null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

代码案例3

package exception;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
/**
 * JDK7之后,java推出了自动关闭特性.
 * 使得我们在源代码中异常处理机制在IO应用中得到了简化
 * 使用方式:
 * 1:将流对象的创建放在try后的()中
 * 2:try要捕获的其余业务代码依旧还是放在try代码块中
 */
public class AutoCloseableDemo {
    public static void main(String[] args) {
        try (
                FileOutputStream fos = new FileOutputStream("fos.txt");
        ) {
            fos.write(1);
        } catch (IOException e) {
            System.out.println("程序出错了!");
        }
    }
}

throw关键字

当程序发生错误而无法处理的时候,会抛出对应的异常对象,除此之外,在某些时刻,您可能会想要自行抛出异常,例如字异常处理结束后,再将异常抛出,让下一层异常处理块来捕捉,若想要自行抛出异常,您可以使用"throw"关键字,并生成执行的异常对象后抛出.

例如:throw new ArithmeticException();

代码案例

Person

package exception;
​
/**
 * 这个类测试异常的抛出
 */
public class Person {
    private int age;
    //alt+insert
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age<0||age>100){
            //如果抛出的异常不是RuntimeException,需要我们在方法后添加所抛出的异常类型
            //此处,判断年龄是否符合逻辑,只有运行时,才能判断
            throw new RuntimeException("年龄不合法!");
        }
        this.age = age;
    }
}
ThrowDemo
package exception;
​
/**
 * 异常的抛出
 * throw关键字可以主动对外抛出一个异常
 * 通常需要抛异常的情况:
 * 1:当前代码片段出现了异常,但是该异常不应该在当前代码片段被解决时,可以抛出
 * 2:程序可以运行,但是不满足业务要求时,可以对外抛出一个异常告知(满足语法但是不满足业务)
 */
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        try {
            p.setAge(2000);//语法满足,但是不满足业务
        } catch (Exception e) {
            System.out.println("出错了!");
            p.setAge(18);
        }
        System.out.println("此人的年龄:"+p.getAge());
    }
}

异常处理之throws处理

程序中会声明许多的方法,这些方法中可能会因某些错误而引发异常,但是不希望直接在这个方法中处理这些异常,而希望调用这个它的方法来统一处理,这时候可以使用throws关键字来声明这个方法将会抛出的异常

throws 处理异常的格式为:

...方法名() throws 异常类名 {
  方法体
}

代码案例

Person

package exception;
​
/**
 * 这个类测试异常的抛出
 */
public class Person {
    private int age;
    //alt+insert
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws Exception{
        if (age<0||age>100){
            /*
             * 如果抛出的异常不是RuntimeException,需要我们在方法后添加所抛出的异常类型,都是编译器的要求,因为我们此时抛出异常,都是编译器就需要处理的异常
             */
            //此处,判断年龄是否符合逻辑,只有运行时,才能判断
            //throw new RuntimeException("年龄不合法!");
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

ThrowDemo

package exception;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
​
/**
 * 异常的抛出
 * throw关键字可以主动对外抛出一个异常
 * 通常需要抛异常的情况:
 * 1:当前代码片段出现了异常,但是该异常不应该在当前代码片段被解决时,可以抛出
 * 2:程序可以运行,但是不满足业务要求时,可以对外抛出一个异常告知(满足语法但是不满足业务)
 */
public class ThrowDemo {
    public static void main(String[] args) throws FileNotFoundException {
        Person p = new Person();
        try {
            p.setAge(2000);//语法满足,但是不满足业务
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("此人的年龄:"+p.getAge());
    }
}

throws的重写规则

代码案例

package exception;
​
import java.awt.*;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
​
/**
 * 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(){}
    //重写方法可以抛出父类异常的子类 FileNotFoundException继承IOException
    //public void doSome() throws FileNotFoundException {}
    //不允许抛出父类方法没有抛出(一点关系都没有)的异常
    //public void doSome() throws SQLException {}
    //不允许抛出父类的异常的超类
    //public void doSome() throws Exception {}
}

异常常用方法

代码案例

package exception;
​
import java.io.FileOutputStream;
​
/**
 * 异常常用方法
 */
public class ExceptionApiDemo {
    public static void main(String[] args) {
        try {
            String str = "abc";
            System.out.println(Integer.parseInt(str));
        } catch (Exception e) {
            //用来在控制台输出异常信息,便于程序员解决bug
            //打印异常信息
            e.printStackTrace();
            //message 消息 获取错误信息
            String message = e.getMessage();
            System.out.println("错误信息:"+message);
        }
    }
}

自定义异常

代码案例

IllegalAgeException

package exception;
​
/**
 * 自定义异常:通常使用来表达业务错误
 * 1:类名一定要见明知义
 * 2:自定义异常继承Exception类()直接继承或者间接继承
 * 3:提供所继承的类的构造器 alt+insert Constructor 全选回车
 * 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);
    }
}

Person

package exception;
​
/**
 * 这个类测试异常的抛出
 */
public class Person {
    private int age;
    //alt+insert
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws IllegalAgeException{
        if (age<0||age>100){
            /*
             * 如果抛出的异常不是RuntimeException,需要我们在方法后添加所抛出的异常类型,都是编译器的要求,因为我们此时抛出异常,都是编译器就需要处理的异常
             */
            //此处,判断年龄是否符合逻辑,只有运行时,才能判断
            //throw new RuntimeException("年龄不合法!");
            throw new IllegalAgeException("年龄超过范围:"+age);
        }
        this.age = age;
    }
}

ThrowDemo

package exception;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
​
/**
 * 异常的抛出
 * throw关键字可以主动对外抛出一个异常
 * 通常需要抛异常的情况:
 * 1:当前代码片段出现了异常,但是该异常不应该在当前代码片段被解决时,可以抛出
 * 2:程序可以运行,但是不满足业务要求时,可以对外抛出一个异常告知(满足语法但是不满足业务)
 */
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        try {
            p.setAge(2000);//语法满足,但是不满足业务
        } catch (IllegalAgeException e) {
            e.printStackTrace();
        }
        System.out.println("此人的年龄:"+p.getAge());
    }
}

总结: 什么时候需要try…catch异常, 什么时候需要throws异常?

1. 如果这个异常是方法内部的代码造成的异常, 而不是因为调用者的传参导致的异常(也就是说这个异常和调用者没有关系), 通常需要我们try…catch异常

2. 如果这个异常是调用者的传参导致的异常, 则将异常throws抛出(就是将异常抛给调用者)

3. 不要在main方法上throws抛出异常, 因为这样会将异常抛给虚拟机, 而虚拟机是不会帮我们处理异常的!(虚拟机会按照默认方式处理:输出异常信息以及终止程序执行!)

扩充内容–JAVA常见异常

Java.io.NullPointerException

• null 空的，不存在的
• NullPointer 空指针

空指针异常，该异常出现在我们操作某个对象的属性或方法时，如果该对象是null时引发。

String str = null;
str.length();//空指针异常

上述代码中引用类型变量str的值为null，此时不能通过它调用字符串的方法或引用属性，否则就会引发空指针异常。

解决办法:

找到为什么赋值为null，确保该对象的值不能为null再操作属性或方法即可。

java.lang.NumberFormatException: For input string: “xxxxx”

• Number 数字
• Format 格式

数字格式异常，该异常通常出现在我们使用包装类将一个字符串解析为对应的基本类型时引发。

String line = "123.123";//小数不能转换为整数!
int d = Integer.parseInt(line);//抛出异常NumberFormatException
System.out.println(d);

上述代码中由于line的字符串内容是"123.123".而这个数字是不能通过包装类Integer解析为一个整数因此出现该异常。注:非数字的字符出在解析时也会出现该异常。

解决办法:

确保解析的字符串正确表达了基本类型可以保存的值

String line = "123";
int d = Integer.parseInt(line);
System.out.println(d);//123

java.lang.StringIndexOutOfBoundsException

• index 索引，下标
• Bounds 边界
• OutOfBounds 超出了边界

字符串下标越界异常。该异常通常出现在String对应的方法中，当我们指定的下标小于0或者大于等于字符串的长度时会抛出该异常。

String str = "thinking in java";
char c = str.charAt(20);//出现异常
System.out.println(c);

解决办法:

指定下标时的范围应当在>=0并且<=字符串的长度。

java.io.InvalidClassException

• Invalid 无效的
• Class 类

无效的类异常，该异常出现在使用java.io.ObjectInputStream在进行对象反序列化时在readObject()方法中抛出。这通常是因为反序列化的对象版本号与该对象所属类现有的版本号不一致导致的。

可以通过在类上使用常量:

static final long serialVersionUID = 1L;

来固定版本号，这样序列化的对象就可以进行反序列化了。

JAVA建议我们实现Serializable接口的类主动定义序列化版本号,若不定义编译器会在编译时 根据当前类结构生成版本号,但弊端是只要这个类内容发生了改变,那么再次编译时版本号就会改变,直接的后果就是之前序列化的对象都无法再进行反序列化.

如果自行定义版本号,那么可以在改变类内容的同时不改变版本号,这样一来,反序列化以前的 对象时对象输入流会采取兼容模式,即:当前类的属性在反序列化的对象中还存在的则直接还原,不存在的就是用该属性的默认值

出现该异常的解决办法:

1. 首先使用上述常量固定版本号
2. 重新序列化对象(将对象通过ObjectOutputStream重新序列化并写出)
3. 再进行反序列化即可

需要注意，之前没有定义序列化版本号时序列化后的对象都无法再反序列化回来，所以若写入了文件，可将之前的那些文件都删除，避免读取即可。

java.io.NotSerializableException

• NotSerializable 不能序列化

不能序列化异常，该异常通常出现在我们使用java.io.ObjectOutputStream进行对象序列化(调用writeObject)时。原因时序列化的对象所属的类没有实现java.io.Serializable接口导致

出现该异常的解决办法:

将序列化的类实现该接口即可

java.io.UnsupportedEncodingException

• Unsupported 不支持的
• Encoding字符集

不支持的字符集异常，该异常通常出现在使用字符串形式指定字符集名字时，犹豫字符集名字拼写错误导致。例如

PrintWriter pw = new PrintWriter("pw.txt", "UFT-8");

上述代码中，字符集拼写成"UFT-8"就是拼写错误。
常见的字符集名字:

• GBK:我国的国标编码，其中英文1个字节，中文2字节

• UTF-8:unicode的传输编码，也称为万国码。其中英文1字节，中文3字节。

• ISO8859-1:欧中的字符集，不支持中文。

java.io.FileNotFoundException

• File 文件

• NotFound 没有找到

文件没有找到异常，该异常通常出现在我们使用文件输入流读取指定路径对应的文件时出现

FileInputStream fis = new FileInputStream("f1os.dat");

上述代码如果指定的文件f1os.dat文件不在当前目录下，就会引发该异常：

java.io.FileNotFoundException: f1os.dat (系统找不到指定的文件。)

注:

抽象路径"f1os.dat"等同于"./f1os.dat"。因此该路径表示当前目录下应当有一个名为f1os.dat的文件。

还经常出现在文件输出流写出文件时，指定的路径无法将该文件创建出来时出现

FileOutputStream fos = new FileOutputStream("./a/fos.dat");

上述代码中，如果当前目录下没有a目录，那么就无法在该目录下自动创建文件fos.dat，此时也会引发这个异常。

其他API上出现该异常通常也是上述类似的原因导致的。

解决办法:

在读取文件时，确保指定的路径正确，且文件名拼写正确。

在写出文件时，确保指定的文件所在的目录存在。

java.net.ConnectException: Connection refused: connect

• connection 连接

• refused 拒绝

连接异常,连接被拒绝了.这通常是客户端在使用Socket与远端计算机建立连接时由于指定的地址或端口无效导致无法连接服务端引起的.

System.out.println("正在连接服务端...");
Socket socket = new Socket("localhost",8088);//这里可能引发异常
System.out.println("与服务端建立连接!");

解决办法:

• 检查客户端实例化Socket时指定的地址和端口是否正常

• 客户端连接前,服务端是否已经启动了

java.net.BindException: Address already in use

• bind 绑定
• address 地址
• already 已经
• Address already in use 地址已经被使用了

绑定异常,该异常通常是在创建ServerSocket时指定的服务端口已经被系统其他程序占用导致的.

System.out.println("正在启动服务端...");
ServerSocket serverSocket = new ServerSocket(8088);//这里可能引发异常
System.out.println("服务端启动完毕");

解决办法:

• 有可能是重复启动了服务端导致的,先将之前启动的服务端关闭

• 找到该端口被占用的程序,将其进程结束

• 重新指定一个新的服务端口在重新启动服务端

java.net.SocketException: Connection reset

• socket 套接字
• net 网络
• reset 重置

套接字异常,链接重置。这个异常通常出现在Socket进行的TCP链接时，由于远端计算机异常断开(在没有调用socket.close()的之前直接结束了程序)导致的。

解决办法:

• 无论是客户端还是服务端当希望与另一端断开连接时，应当调用socket.close()方法，此时会进行TCP的挥手断开动作。

• 这个异常是无法完全避免的，因为无法保证程序在没有调用socket.close()前不被强制杀死。

java.lang.InterruptedException

• interrupt 中断

中断异常.这个异常通常在一个线程调用了会产生阻塞的方法处于阻塞的过程中,此时该线程的interrupt()方法被调用.那么阻塞方法会立即抛出中断异常并停止线程的阻塞使其继续运行.

例如:

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
}

如果线程t1调用Thread.sleep(1000)处于阻塞的过程中,其他线程调用了t1线程的inerrupt()方法,那么t1调用的sleep()方法就会立即抛出中断异常InterruptedException并停止阻塞.

java.util.NoSuchElementException

• such 这个

• Element 元素

没有这个元素的异常.该异常通常发生在使用迭代器Iterator遍历集合元素时由于没有先通过hasNext()方法判断存在下一个元素而贸然通过next()获取下一个元素时产生(当集合所有元素都经过迭代器遍历一遍后还使用next获取).

while(it.hasNext()){
            String str = (String)it.next();
            //这里就可能产生NoSuchException异常
            System.out.println(it.next());
        }

上述代码中循环遍历时,每次调用hasNext()确定存在下一个元素时,循环里面连续调用过两次next()方法,这意味着第二次调用next()方法时并没有判断是否还存在.所以在最后会出现异常.

解决办法:

保证每次调用next()方法前都确定hasNext()为true才进行即可.

java.util.ConcurrentModificationException

• Concurrent 并发

• Modification 修改

并发修改异常.这个异常也经常出现在使用迭代器遍历集合时产生.

当我们使用一个迭代器遍历集合的过程中,通过集合的方法增删元素时,迭代器会抛出该异常.

while(it.hasNext()){
    //出现ConcurrentModificationException
    String str = (String)it.next();
    if("#".equals(str)){
        c.remove(str);//遍历过程中不要通过集合方法增或删元素
    }
    System.out.println(str);
}

解决办法:

使用迭代器提供的remove()方法可以删除通过next()获取的元素.

while(it.hasNext()){
            String str = (String)it.next();
            if("#".equals(str)){
//                c.remove(str);
                it.remove();
            }
            System.out.println(str);
        }

java.lang.UnsupportedOperationException

support 支持

unsupported 不支持的

operation 操作

不支持的操作异常.该异常出现在很多的API中.

例如:常出现在我们对数组转换的集合进行增删元素操作时抛出.

String[] array = {"one","two","three","four","five"};
System.out.println("array:"+ Arrays.toString(array));
List<String> list = Arrays.asList(array);//将数组转换为一个List集合
System.out.println("list:"+list);
​
list.set(0,"six");
System.out.println("list:"+list);
//对该集合的操作就是对原数组的操作
System.out.println("array:"+ Arrays.toString(array));
​
//由于数组是定长的,因此任何会改变数组长度的操作都是不支持的!
list.add("seven");//UnsupportedOperationException