Java 异常 File

异常

异常是什么

程序中可能出现的问题。

异常体系的最上层父类是谁？异常分为几类？

父类：Exception

异常分为两类：编译时异常，运行时异常

编译时异常和运行时异常的区别

编译时异常：没有继承RuntimeException的异常，直接继承于Exception,编译阶段就会错误提示

运行时异常：RuntimeException本身和子类，编译阶段没有错误提示，运行时出现的

异常的作用

异常是用来查询bug的关键参考信息

异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况

异常的处理方式

1.JVM默认处理方式

2.自己处理（捕获异常）

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        int[]arr={1,3,4,5,6};
        //好处：可以让程序继续进行
        try {
            System.out.println(arr[10]);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界");
        }

        System.out.println("hello");

    }
}

如果try里没问题，不执行catch

如果try里面有多个问题，可以写多个对应的catch（如果多个异常，异常中存在父子关系，父类一定写在下面）

如果没有相应catch，交给虚拟机处理

异常的常见方法

getMessage

toString

printStackTrace

public class Main {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try {
            System.out.println(arr[10]);
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();//打印不会影响程序进行
        }
        System.out.println("hello");
    }
}

抛出异常

public class Main {
    public static void main(String[] args) {
        //定义一个方法求最大值
        int arr[]=null;
        int max= 0;
        try {
            max = getmax(arr);
        } catch (NullPointerException e) {
            System.out.println("空指针异常");
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界异常");
        }
        System.out.println(max);
    }
    public static int getmax(int arr[]){
        if(arr==null){
            throw new NullPointerException();
        }
        if(arr.length==0){
            throw new ArrayIndexOutOfBoundsException();
        }
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max)
                max=arr[i];
        }
        return max;
    }
}

自定义异常

1.定义异常类

2.写继承关系

3.空参构造

4.带参构造

File

File对象表示一个路径

File的常见成员方法（判断，获取）

import java.io.File;

public class Main {
    public static void main(String[] args) {
        //判断
        File f1=new File("C:\\Users\\86158\\Desktop\\abc.txt");
        System.out.println(f1.isDirectory());//是否是文件夹
        System.out.println(f1.isFile());//是否是文件
        System.out.println(f1.exists());//是否存在

        File f2=new File("C:\\Users\\86158\\Desktop");
        System.out.println(f2.isDirectory());
        System.out.println(f2.isFile());
        System.out.println(f2.exists());

        File f3=new File("C:\\Users\\86158\\Desktop\\abc.txt");
        long len=f3.length();
        System.out.println(len);//返回文件大小（不能是文件夹）
        File f4=new File("C:\\Users\\86158\\Desktop\\abc.txt");
        String absolutePath = f4.getAbsolutePath();//返回文件的绝对路径
        System.out.println(absolutePath);

        File f5=new File("abc.txt");
        String absolutePath1 = f5.getAbsolutePath();//返回文件的绝对路径
        System.out.println(absolutePath1);

        //下面是获取方法
        //getPath 返回定义文件时使用的路径
        //getName 获取名字
        //lastModified 返回最后修改时间
    }
}

File的常见成员方法（创建，删除）

创建

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //1.createNewFile
        //不存在返回真
        //反之假
        //父级不存在有异常
        File f1=new File("C:\\Users\\86158\\Desktop\\abc.txt");
        boolean newFile = f1.createNewFile();
        System.out.println(newFile);

        //2.mkdir 创建文件夹
        File f2=new File("C:\\Users\\86158\\Desktop\\add");
        boolean mkdir = f2.mkdir();
        System.out.println(mkdir);

        //3.mkdirs 创建多级文件夹
        File f3=new File("C:\\Users\\86158\\Desktop\\add1");
        boolean mkdirs = f3.mkdirs();
        System.out.println(mkdirs);
    }
}

删除

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        File f1=new File("C:\\Users\\86158\\Desktop\\jk");
        boolean delete = f1.delete();
        System.out.println(delete);
    }
}

File的成员方法（获取并遍历）

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        File f=new File("C:\\Users\\86158\\Desktop\\cs");
        File[] files = f.listFiles();
        for(File file:files){
            System.out.println(file);
        }
    }
}

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        //1.listRoots 列出所有盘符
        File[] files = File.listRoots();
        System.out.println(Arrays.toString(files));

        //2.list() 获取当前路径下所有内容（仅仅是名字）
        File f1=new File("D:\\course");
        String[] list = f1.list();
        for(String s:list){
            System.out.println(s);
        }

        //3.list() 过滤一下(我没写对？？！)
        File f2=new File("D:\\course");
        String[] list1 = f2.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File src=new File(dir,name);
                return src.isFile()&&name.endsWith(".txt");
            }
        });
        System.out.println(list1);
    }
}