Java的异常机制和File类的认识与理解

学习笔记输出来源：拉勾教育Java就业急训营

修改时间：2021年1月4日
作者：pp_x
邮箱：pp_x12138@163.com

异常

异常概念

• java,.lang.Throwable是Java语言中错误（Error）和异常（Exception）的超类
• 其中Error类主要用于描述Java虚拟机无法解决的严重错误，通常无法编码解决，如：jvm挂掉了
• Exception类主要用于描述因编程错误或偶然外在因素导致的轻微错误，通常通过编码可以解决，如：0作为除数等。

异常的分类

• java,lang.Exception类是所有异常的超类，主要分为两种
  RuntimeException：运行时异常（非检测异常）
  IOException和其他异常（检测异常），就是指再编译阶段都能被编译器检测出来的异常
• 其中RuntimeException类的主要子类：
  ArithmeticException类 - 算术异常
  ArrayIndexOutOfBoundsException类 - 数组下标越界异常
  *NullPointerException *- 空指针异常
  *ClassCastException *- 类型转换异常
  NumberFormatException - 数字格式异常
• 注意
  当程序执行过程中发生异常但又没有手动处理时，则由Java虚拟机采用默认方式处理异常，而默认处理方式就是：打印异常的名称、异常发生的原因、异常发生的位置以及终止程序。

异常的捕获

• 语法格式
  try {
  编写可能发生异常的代码; }
  catch(异常类型 引用变量名) {
  编写针对该类异常的处理代码；
  }
  …
  finally {
  编写无论是否发生异常都要执行的代码；
  }

public static int test() {
        try {
            int[] arr = new int[5];
            System.out.println(arr[5]);
            return 0;
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
            return 1;
        } finally {
            return 2; // 提交结束方法并返回数据   最后返回2
        }
    }

• 执行流程
  执行流程
  try {
  a;
  b; - 可能发生异常的语句
  c;
  }catch(Exception ex) {
  d;
  }finally {
  e;
  }
  当没有发生异常时的执行流程：a b c e;
  当发生异常时的执行流程：a b d e;

package com.lagou.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionCatchTest {

    public static void main(String[] args) {

        // 创建一个FileInputStream类型的对象与d:/a.txt文件关联，打开文件
        FileInputStream fis = null;
        try {
            System.out.println("1");
            // 当程序执行过程中发生了异常后直奔catch分支进行处理
            fis = new FileInputStream("d:/a.txt");
            System.out.println("2");
        } catch (FileNotFoundException e) {
            System.out.println("3");
            e.printStackTrace();
            System.out.println("4");
        }
        // 关闭文件
        try {
            System.out.println("5");
            fis.close();
            System.out.println("6");
        } /*catch (Exception e) {
            e.printStackTrace();
        }*/ catch (IOException e) {
            System.out.println("7");
            e.printStackTrace();
            System.out.println("8");
        } catch (NullPointerException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("世界上最真情的相依就是你在try我在catch，无论你发神马脾气我都默默承受并静静的处理，到那时再来期待我们的finally！");
        // 当程序执行过程中没有发生异常时的执行流程：1 2  5 6  世界上...
        // 当程序执行过程中发生异常又没有手动处理空指针异常时的执行流程：1 3 4  5  空指针异常导致程序终止
        // 当程序执行过程中发生异常并且手动处理空指针异常时的执行流程： 1 3 4 5 世界上...

        // 手动处理异常和没有处理的区别：代码是否可以继续向下执行
    }
}

异常的抛出

• 基本概念：
  有些特殊情况，异常不能处理或不便于处理，就可以将该异常转移给该方法的调用者，即叫做异常的抛出，当方法执行产生异常时，底层生成一个异常类的对象抛出，此时异常代码后续的代码就不再执行。
• 语法格式
  访问权限 返回值类型 方法名称(形参列表) throws 异常类型
  public void show() throws IOException{}
• 方法重写的原则
  a.要求方法名相同、参数列表相同以及返回值类型相同，从jdk1.5开始支持返回子类类型；
  b.要求方法的访问权限不能变小，可以相同或者变大；
  c.要求方法不能抛出更大的异常；
• 注意：
• 若父类没有进行异常的抛出，则子类中重写的方法只能进行异常的捕获
• 若一个方法内部又以递进的方式调用了其他方法，建议这些方法使用抛出异常的方式，最外部的方法使用捕获异常的方式

package com.lagou.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionThrowsTest {

    public static void show() throws IOException {
        FileInputStream fis = new FileInputStream("d:/a.txt");
        System.out.println("我想看看你抛出异常后是否继续向下执行？？？");
        fis.close();
    }

    public static void test1() throws IOException {
        show();
    }

    public static void test2() throws IOException {
        test1();
    }

    public static void test3() throws IOException {
        test2();
    }

    // 不建议在main方法中抛出异常   JVM负担很重
    public static void main(String[] args) /*throws IOException*/ {
        try {
            show();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("------------------------------------");
        try {
            test3();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

自定义异常

• 基本概念
  当需要再程序中表达某种不合理的情况时，而Java官方又没有给针对性的异常，这时候需要自定义异常并加以描述
• 实现流程
  1、自定义xxxException异常类继承Exception类或者子类。
  2、提供两个版本的构造方法，一个是无参、一个是以字符串作为形参的构造方法
• 异常的产生
  throw new 异常类型(实参);
  自定义异常

package com.lagou.exception;

public class AgeException extends Exception {

    static final long serialVersionUID = 7818375828146090155L; // 序列化的版本号  与序列化操作有关系

    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }
}

测试该异常类的类

package com.lagou.exception;

public class    Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) /*throws AgeException */{
        setName(name);
        setAge(age);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) /*throws AgeException */{
        if (age > 0 && age < 150) {
            this.age = age;
        } else {
            //System.out.println("年龄不合理哦！！！");
            try {
                throw new AgeException("年龄不合理哦！！！");
            } catch (AgeException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Throw和Throws的区别

• 使用的位置不同：throw是写在方法体里面。throws则是用在方法头上面。
• 作用不同：throw就是直接抛出一个异常，而throws则是说我这个方法可能会抛出一个异常

File类

基本概念

• java.io.File类主要用于描述文件或目录路径的抽象表示信息，可以获取文件或目录的特征信息。

常用的方法

方法声明	功能描述
File(String pathname)	根据参数指定的路径名来构造对象
File(String parent, String child)	根据参数指定的父路径和子路径来构造对象
File(File parent, String child)	根据参数指定的父抽象路径和子路径信息构造对象
boolean exists()	判断文件是否存在
String getName()	返回文件名
long length()	返回文件的长度
long lastModified()	返回该文件最后一次修改时间（毫秒值）
String getAbsolutePath()	返回文件所在的绝对路径
boolean delete()	删除文件（删除目录时要求空目录）
boolean createNewFile()	创建新的空文件
boolean mkdir()	创建新目录
boolean mkdirs()	创建新的多级目录
File[] listFiles()	返回目录里的所有内容
boolean isFile()	判断是否为文件
boolean isDirectory()	判断是否为目录
File[] listFiles(FileFilter filter)	根据筛选器来筛选内容

案例

遍历指定目录及子目录的所有内容并打印

File f3 = new File("d:/捣乱");
        // 获取目录f3下的所有内容并记录到一维数组中
        File[] filesArray = f3.listFiles();
        // 遍历数组
        for (File tf: filesArray) {
            String name = tf.getName();
            // 判断是否为文件，若是则直接打印文件名称
            if (tf.isFile()) {
                System.out.println(name);
            }
            // 若是目录，则使用[]将目录名称括起来
            if (tf.isDirectory()) {
                System.out.println("[" + name + "]");
            }
        }
        //递归方法
        public static void show(File file) {
        // 获取目录f3下的所有内容并记录到一维数组中
        File[] filesArray = file.listFiles();
        // 遍历数组
        for (File tf: filesArray) {
            String name = tf.getName();
            // 判断是否为文件，若是则直接打印文件名称
            if (tf.isFile()) {
                System.out.println(name);
            }
            // 若是目录，则使用[]将目录名称括起来
            if (tf.isDirectory()) {
                System.out.println("[" + name + "]");
                show(tf);
            }
        }
    }
    show(new File("d:/捣乱"));

案例二

使用递归删除多级目录

public class DeleteTest{
    public static void main(String[] args) {
        File file = new File("D:\\删除测试");
        deleteFile(file);
    }
    public static void deleteFile(File file){
        File[] files = file.listFiles();
        //先清除文件夹的所有内容
        for (File f1 : files) {
            if(f1.isFile()){
                f1.delete();
            }else {
                deleteFile(f1);
            }
        }
        //然后删除文件夹
        file.delete();
    }
}