Java基础进阶_day05_(异常)

Java基础进阶_day05_(异常)

1. 异常

1.1 异常概述

概念: 程序出现了不正常的现象.
异常分类

# Throwable类是Java语言中所有错误或异常的超类,Throwable有两个子类Error和Exception.
  * 严重问题:Error,内出溢出等,修正代码;
  * 一般问题:Exception,Exception分为两种
 编译期异常:除RuntimeException外的Exception,必须处理;
 运行期异常:RuntimeException,一般不进行处理,需要修正代码.
  * 异常处理本质: 当程序出现异常,我们如果不进行处理,Java虚拟机会做出默认的处理(将异常的名称和原因显示在控制台).

1.2 异常的处理

1.2.1 异常处理的分类

# 编译期异常:必须进行处理,否则无法编译通过;
# 运行期异常:调用者可以不用处理该方法抛出的异常.
 Java程序中可以使用try...catch...fianlly和throws方式处理异常.

1.2.2 try…catch…finally处理异常

处理异常的格式

# try...catch...finally方式(finally可以省略,catch可以有多个):
  * 格式1: 
 try{
 可能出现问题的代码;
 }catch(异常类名 变量名){
 针对问题的处理代码;
 }fially{
 释放资源;
 }
  * 格式2: 
 try{
 可能出现问题的代码;
 }catch(异常类名 变量名){
 针对问题的处理代码;
 }
  * 格式3: 异常类名间是平级关系
 try{
 可能出现问题的代码;
 }catch(异常类名1 变量名1){
 针对问题的处理代码1;
 } catch(异常类名2 变量名2){
 针对问题的处理代码2;
 }...
 fially{
 释放资源;
 }
  * 格式4: 此格式是为了释放资源
 try{
 可能出现问题的代码;
 }fially{
 释放资源;
 }
  * 格式5: JDK1.7版本开始
 try{
 可能出现问题的代码;
 } catch(异常类名1 | 异常类名2... 变量名){
 针对问题的处理代码;
 }fially{
 释放资源;
 }
 catch中的异常类名间必须是平级关系,不能是子父类关系.

注意事项

# try里面的代码越少越好(Java虚拟机会开辟资源进行管理这些代码);
# catch中一般要求给出处理或提示;
# try里面的某一语句出现异常,则直接执行对应的catch语句,出现异常语句后面的代码不会执行;
# catch中的异常类能明确的一定要明确到具体的异常类,如果不能确定异常出现的种类,可以直接使用Exception类;
# 多个catch中的异常类时,平级(同属于一个父类)的异常类无先后顺序,不平级的异常类(子父类关系),父类在后,子类在前(如果父类异常在前(多态),子类异常就无法执行,没有意义).

案例代码

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class ExceptionDemo {
    public static void main(String[] args) {
        // 异常分类
        method();
        // 异常处理
        method2();
    }
    // 异常分类
    public static void method() {
        // 编译期异常(a.txt文件可能不存在),必须进行处理
        // FileWriter fw = new FileWriter("a.txt");报错

        // 运行期异常(除数为零),可以不用处理
        int result = 10 / 0;
    }
    // 异常处理(编译期异常和运行期异常)
    public static void method2() {
        // try方式处理异常
        // 编译期异常,格式1
        try {
            // 可能出现异常的语句
            FileWriter fw = new FileWriter("a.txt");
            FileReader fr = new FileReader("a.txt");
            // 如果上面语句出现了异常,则该try块中下面的所有代码不会执行
            System.out.println("上面的代码没有出现异常");
        } catch (FileNotFoundException e) {
            // 打印出现异常的信息,也可以不打印
            // 创建写文件对象语句可能出现问题的异常
            e.printStackTrace();
            // 可以针对异常问题进行处理
            System.out.println("要读取的文件不存在");
        } catch (IOException e) {
            // 创建写文件可能出现的异常
            e.printStackTrace();
            // 可以针对异常问题进行处理
            System.out.println("要写文件的路径不存在");
        } finally {
            // 这里代码用于处理释放资源,不管会不会处理异常,这里的代码都会执行
            // 只有在此代码块之前推出JVM后,此代码块才不会执行
            System.out.println("释放资源");
        }
        // jdk1.7版本后可以将多个异常放在一个catch语句中,使用|分隔
        // 但是多个异常类间必须是平级关系,不能有继承关系,可以使用父类的异常类代替所有的异常类
        try {
            // 可能出现异常的语句
            FileReader fr = new FileReader("a.txt");
            System.out.println(10 / 0);
            // 如果上面语句出现了异常,则该try块中下面的所有代码不会执行
            System.out.println("上面的代码没有出现异常");
        } catch (FileNotFoundException | ArithmeticException e) {
            e.printStackTrace();
            System.out.println("代码出现异常");
        }
    }
}

1.2.3 throws方式处理异常

# throws方式处理异常:是将异常抛出:定义方法时将可能出现的问题交给调用者去处理,通过在方法声明上使用throws标识.
  * 格式: throws  异常类名    
 注意:这个格式是放在方法声明的括号后面的(异常可以有多个,使用逗号隔开).
  * 抛出异常分类(方法中):
 编译期异常:必须进行处理,否则无法编译通过, 在方法声明上将异常抛出,调用者必须进行异常的处理(调用者可以使用try...catch方式,也可以使用throws抛出);
 运行期异常:调用者可以不用处理该方法抛出的异常.

案例代码

import java.io.FileWriter;
import java.io.IOException;
/* * throws抛出异常 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        // 编译期异常,调用有异常的method方法,必须进行处理
        // 在主方法中一般使用try进行处理,不直接抛给主方法
        // 原因是如果抛给主方法,就是直接让虚拟机处理,
        // 而虚拟机的处理就是终止程序的运行,则出现异常的语句后的语句无法执行
        try {
            method();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 运行期异常,可以不用进行处理,如果处理就使用try方式
        show();
    }
    // 编译期异常,调用method2方法,必须进行异常处理
    // 针对异常可以使用try...catch语句,也可以继续抛出
    public static void method() throws IOException {
        method2();
    }
    // 编译期异常,必须进行处理,抛出后,谁调用谁处理
    public static void method2() throws IOException {
        FileWriter fw = new FileWriter("a.txt");
    }
    // 运行期异常,可以不处理
    public static void show() throws ArithmeticException {
        show2();
    }// 运行期异常,可以不处理
    public static void show2() throws ArithmeticException {
        // 除数不能为零的运行期异常,处理时可以抛出,也可以使用try方式
        System.out.println(10 / 0);
    }
}

1.3 异常类Throwable的常见方法

public String getMessage():返回此异常的详细消息字符串.
public String toString():返回此异常的简短描述. 结果是以下字符串的串联：
      此对象的类的name;
      ": "(冒号和一个空格);
      调用此对象getLocalizedMessage()方法的结果.
public void printStackTrace():将此异常的类名和异常信息及异常出现的位置的信息输出在控制台.

案例代码

/* * 异常类的常见方法 */
public class ExceptionDemo1 {
    public static void main(String[] args) {
        // 异常类的常见方法
        method();
    }
    // 异常类的常见方法
    public static void method() {
        try {
            // 运行期异常(除数为零),可以不用处理
            int result = 10 / 0;
        } catch (Exception e) {
            // public String getMessage():返回此异常的详细消息字符串.
            System.out.println(e.getMessage());
            // public String toString():返回此异常的简短描述.
            System.out.println(e.toString());
            // public void printStackTrace():
            // 将此异常的类名和异常信息及异常出现的位置的信息输出在控制台.
            e.printStackTrace();
        }
    }
}

1.4 自定义异常

# 自定义异常类:定义异常类继承异常类(编译期异常Exception和运行时异常RuntimeException).
  * 自定义异常类只需要继承异常类,然后给出无参构造方法和有参构造方法(参数为错误信息,super传递给父类)即可;
  * 使用throw关键将自定义异常抛出(throw new 自定义异常类名(自定义异常信息);).

案例代码

/* * 自定义异常类 */
public class ExceptionDemo3 {
    public static void main(String[] args) {
        // 使用自定义异常类,编译期异常类
        int age = 16;
        if(age < 18) {
            try {
                // 编译异常语句,可以使用try方式和throws方式处理
                throw new MyException("您的年龄不满18岁,禁止上网");
            } catch (MyException e) {
                e.printStackTrace();
            }
        }
        // 使用自定义异常类,运行时异常类,
        // 可以不处理,可以使用try或者throws处理
        if(age < 18) {
            try {
                // 运行异常语句,可以使用try方式和throws方式处理
                throw new MyException("您的年龄不满18岁,禁止上网");
            } catch (MyException e) {
                e.printStackTrace();
            }
        }
        // 使用系统的异常类,自己给出异常提示信息
        if(age < 18) {
            try {
                // 异常语句,可以使用try方式和throws方式处理
                // 自定义错误信息
                throw new RuntimeException("您的年龄不满18岁,禁止上网");
            } catch (RuntimeException e) {
                e.printStackTrace();
            }
        }
    }
}
// 自定义异常类,编译期异常类
class MyException extends Exception {
    // 自定义异常类,只需要创建构造方法,将异常提示信息传递给父类即可
    public MyException() {
        super();
    }
    public MyException(String message) {
        super(message);
    }
}
// 自定义异常类,运行时异常类
class MyException2 extends RuntimeException {
    // 自定义异常类,只需要创建构造方法,将异常提示信息传递给父类即可
    public MyException2() {
        super();
    }
    public MyException2(String message) {
        super(message);
    }
}

1.5 throw关键字

# 在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,就用throw把异常对象抛出.
# 使用:在方法中的代码对可能出现问题的语句进行判断,如果是异常情况就用(throw 异常类对象)将异常抛出.

1.6 finally关键字

# fianlly关键字:使用try语句的一部分.
  * 特点:被finally控制的语句一定会执行;
  * 注意事项:如果程序执行到finally语句体之前,虚拟机退出了,finally控制的语句就不会执行了;
  * 作用:用于释放资源(IO操作和数据库操作).

1.7 throws和throw的区别

# throws:被动抛出异常
  * 用在方法声明后面,紧跟着是抛出的异常类名;
  * 可以有多个异常类名,用逗号隔开;
  * 表示抛出异常,由该方法的掉用者进行处理;
  * 表示出现异常的一种可能性,并不一定会发生异常.
# throw:主动抛出异常
  * 用在方法体内,紧跟的是异常对象名;
  * 只能抛出一个异常对象名;
  * 表示抛出异常,由该方法体内的语句进行处理;
  * 表示程序抛出了异常,执行throw语句则表示程序一定出现了异常.

1.8 final,finally,finalize的区别

# final:可以修饰类(该类不能被继承),变量(该变量是常量),方法(该方法不能被重写);
# finally:异常处理try语句的一部分,用于释放资源;
# finalize:是Object类的一个方法,用于垃圾回收.

1.9 异常的使用

# 原则:如果功能模块内部能处理则使用try语句,如果不能处理就使用throws将异常抛出给虚拟机处理.
  * try语句和throws区别:
 前者是处理异常,异常处理代码块后的代码可以继续执行(try中的代码块出现异常的语句后的代码不再执行);
 后者是遇到异常将异常抛给虚拟机并停止程序的执行,异常语句的后续代码不会执行.

转载于:https://my.oschina.net/u/3481752/blog/898605