Java学习的第二十一天（JavaSE最终篇_异常处理_File文件类）

最新推荐文章于 2023-03-24 12:18:37 发布

飞奔的嗨少

最新推荐文章于 2023-03-24 12:18:37 发布

阅读量172

点赞数

分类专栏： Java修仙之路

本文链接：https://blog.csdn.net/weixin_43908333/article/details/103148391

版权

Java修仙之路专栏收录该内容

91 篇文章 9 订阅

订阅专栏

一、异常机制

1.什么是异常：程序在编译期或运行期所出现的一些错误或者问题
2.异常的打印信息通常包括：1.异常的类型：ArithmeticException；2.异常的原因/by zero；3.异常出现的位置
3.Throwable异常体系结构

二、异常处理的三种方式

1.交给JVM去去处理（异常后面的程序不能再继续执行）
2.捕捉处理try{}catch(){} 可以直接使用快捷键Ctrl+Alt+t添加捕捉处理

try {
	//需要被检测的语句。
}catch(异常类 变量) { //参数。
	//异常的处理语句。
}finally {
	//一定会被执行的语句。
}

3.抛异常（往方法声明上抛）--抛到最后交给JVM去处理

package com.bianyiit.cast;

public class ExceptionDemo1 {
    public static void main(String[] args) throws ArithmeticException{  //处理异常的第三种方式：throws直接抛给主方法去执行
        //JVMException();//处理异常的第一种方式：不作任何处理（不添加throws 异常类型），就直接交给JVM去执行
        //TryCatch(); //处理异常的第二种方式：try{}catch(){}   快捷键ctrl+alt+t
        //MoreTryCatch();//多个异常处理方式 try{}catch(){}catch(){}
        int a=10/0;
    }

    private static void JVMException() {
        //处理异常的第一种方式：不作任何处理，就直接交给JVM去执行
        //int a=10/0;    //java.lang.ArithmeticException
    }

    private static void TryCatch() {
        //处理异常的第二种方式：try{}catch(){}   快捷键ctrl+alt+t
        /*try {
            int a=10/0;
        } catch (ArithmeticException e) {
            //e.printStackTrace();
            System.out.println("算术异常，除数不能为0");
        }*/
    }

    private static void MoreTryCatch() {
        //多个异常处理方式 try{}catch(){}catch(){}
        /*try {
            //int a=10/0;

            String s=null;
            System.out.println(s.length());
        } catch (ArithmeticException e) {
            System.out.println("算术异常，除数不能为0");
        } catch (NullPointerException e) {
            System.out.println("空指针异常");
        }*/
    }
}

三、Finally的使用

1.主要是用来释放资源用的
2.结合try{}catch(){}finally{} 或者try{}finally{}
3.不管有没有异常或者异常有没有进行处理，finally快里面的内容都会执行(除非使用System.exit(1)干掉JVM虚拟机)

package com.bianyiit.cast;

public class FinallyDemo {
    public static void main(String[] args) {
        //TryCatchFinally();
        //TryFinally();
    }

    private static void TryFinally() {
        try{
            System.out.println("申请资源空间");
            int a=10/0;
        }finally {
            System.out.println("释放资源");
            //不管存不存在异常，不管这个异常有没有处理，最终要执行的代码，除非虚拟机被干掉了
            //finally主要用作释放资源用的
        }
    }

    private static void TryCatchFinally() {
        //finally:在异常机构中，是最后执行（资源的释放）
        try{
            System.out.println("先在内存中申请资源空间");
            int a=10/0; //可能会出现异常的代码
        }catch (ArithmeticException e){   //异常的对象
            //具体处理异常的步骤
            System.out.println("除数不能为0");
            //return;   //结束main方法，finally快里面的内容仍然还会执行
            //原因：Java中在结束main方法之前仍然会找到finally，只有执行了finally快之后，才能把main方法结束
            System.exit(1);  //只要干掉虚拟机之后，finally快就不会执行了
        }finally {
            //不管存不存在异常，最终要执行的代码
            System.out.println("释放资源");
        }
    }
}

四、throwable三种常用的方法

String getMessage()  返回此 throwable 的详细消息字符串
// / by zero

String toString()  返回此 throwable 的简短描述
//Exception in thread "main" java.lang.ArithmeticException: / by zero

void printStackTrace()  打印异常的堆栈的跟踪信息
//Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.bianyiit.cast.ExceptionDemo1.main(ExceptionDemo1.java:8)

五、多个异常同时处理时

可以使用多个try catch或者使用一个try 多个catch包起来
注意：如果异常对象存在子父类关系时，父类的异常对象只能放在子类异常对象的后面。如果是同级关系，放前放后都没有关系

六、自定义异常类（规范代码）

这是使用自定义异常类、throws、递归来进行输入的年龄是否符合要求，如果不符合给出提示，并要求重新输入

package com.bianyiit.cast;

import java.util.Scanner;

public class Person {
    String name;
    int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0){
        //自定义抛异常
            //throw new RuntimeException("年龄不能小于0岁");
            throw new AgeException("提示：年龄不能小于0");
        }else if(age>120){
            //throw new RuntimeException("年龄不能大于120岁");
            throw new AgeException("提示：年龄不能大于120");
        }else{
            this.age = age;
        }
    }

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

package com.bianyiit.cast;

public class AgeException extends RuntimeException{
    //自定义异常  要么继承Runtimeexcption变成运行时期异常
    //如果继承Exception 变成编译时期异常
    //定义异常的信息
    String message;
    public AgeException(){

    }
    public AgeException(String message) {
        this.message = message;
    }
	//通过getMessage()来捕获出现的异常
    @Override
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

package com.bianyiit.cast;

import java.util.Scanner;

public class ThrowsExceptionDemo {
    public static void main(String[] args){
        Person p1 = new Person();
        System.out.print("请输入年龄：");
        method(p1);
        System.out.println(p1);
    }

    private static void method(Person p1) {
        Scanner sc=new Scanner(System.in);
        int age = sc.nextInt();
        try{
            p1.setAge(age);
        }catch (RuntimeException e){
            System.out.println(e.getMessage());  //只输出异常的原因（这里是提示：年龄不能小于0/年龄不能大于120）
            System.out.println();
            //异常的具体处理---重新输入年龄
            System.out.print("请再次输入年龄：");
            method(p1);
        }
    }
}
//输出结果：
	请输入年龄：-20
	提示：年龄不能小于0
	
	请再次输入年龄：150
	提示：年龄不能大于120
	
	请再次输入年龄：-25
	提示：年龄不能小于0
	
	请再次输入年龄：28
	Person{name='null', age=28}

七、异常的面试题总结

一、throw和throws的区别

1.throw是在方法体内抛出异常；(谁调用这个方法就抛给谁)
2.throws是在方法声明上声明方法有可能有异常产生
3.throws可以一次性抛出多个异常，而throw只能抛出一个异常

二、 final finally finalize的区别

联系：三者之间没有任何联系
final   用来去修饰类 、方法、变量的，被final修饰过的类不能继承，被final修饰的方法不能重写，被final修饰的变量变成常量
finally  在处理异常的时候一定会执行的代码块，往往可以用来释放资源
finalize   这个Object类中的一个方法名称，这个方法是用来进行垃圾回收的

八、File文件

1.构造函数

File(String pathname): 将一个字符串路径封装成File对象
File(String parent,String child): 传入一个父级路径和子级路径
File(File parent,String child): 传入一个File类型的父级路径和子级路径

package com.bianyiit.file;

import java.io.File;

public class FileDemo1 {
    public static void main(String[] args) {
        //创建文件夹或者文件对象方式1
        File f1=new File("D:\\重要代码Demo\\文件IO对象");
        //创建文件夹或者文件对象方式2
        String s1="D:\\重要代码Demo\\文件IO对象";
        File f2 = new File(s1);
        //创建文件夹或者文件对象方式3
        File f3 = new File("D:\\", "重要代码Demo\\文件IO对象");
        //创建文件夹或者文件对象方式4
        String s2="D:\\";
        String s3="重要代码Demo\\文件IO对象";
        File f4 = new File(s2, s3);
    }
}

2.File类创建和删除功能

boolean createNewFile(): 指定路径不存在该文件时时创建文件,返回true,否则返回false
boolean mkdir(): 当指定的单级文件夹不存在时创建文件夹并返回true，否则返回false  
boolean mkdirs(): 当指定的多级文件夹某一级文件夹不存在时,创建多级文件夹并返回true,否则返回false
boolean delete(): 删除文件或者删除单级文件夹

package com.bianyiit.file;

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

public class FileDemo2 {
    public static void main(String[] args) throws IOException {
        //创建文件对象
        //File f1 = new File("D:\\重要代码Demo\\文件IO对象\\filedemo1.txt");
        //创建文件夹对象
        File f2 = new File("D:\\重要代码Demo\\文件IO对象\\FileDemo1\\File");
        //创建文件
        /*boolean newFile = f1.createNewFile();
        System.out.println(newFile);*/
        //创建单级文件夹
        /*boolean mkdir = f2.mkdir();
        System.out.println(mkdir);*/
        //创建多级文件夹
        /*boolean mkdirs = f2.mkdirs();
        System.out.println(mkdirs);*/
        //删除文件或者删除单级文件夹(只能一个一个的删除文件夹/文件)
        /*boolean delete1 = f1.delete();
        System.out.println(delete1);*/
        boolean delete2 = f2.delete();
        System.out.println(delete2);
    }
}

3.File类的判断功能

boolean exists(): 判断指定路径的文件或文件夹是否存在
boolean isAbsolute(): 判断当前路路径是否是绝对路径
boolean isDirectory(): 判断当前的目录是否存在
boolean isFile(): 判断当前路径是否是一个文件
boolean isHidden(): 判断当前路径是否是隐藏文件

package com.bianyiit.file;

import java.io.File;

public class FileDemo3 {
    public static void main(String[] args) {
        File f1 = new File("D:\\重要代码Demo\\文件IO对象\\FileDemo1");
        File f2 = new File("FileDemo1");
        //判断文件/文件夹是否存在
        boolean exists = f1.exists();
        System.out.println("该文件夹是否存在："+exists);
        //判断当前路径是否是绝对路径
        //绝对路径是以盘符开头的路径  相对路径没有盘符开头的路径
        boolean absolute = f1.isAbsolute();
        System.out.println("D:\\重要代码Demo\\文件IO对象\\FileDemo1是否是绝对路径："+absolute);
        boolean absolute1 = f2.isAbsolute();
        System.out.println("FileDemo1是否是绝对路径："+absolute1);
        //注意：如果创建文件的时候是以相对路径进行创建，那么默认在项目的根目录下面
        //判断当前目录是否存在
        boolean directory = f1.isDirectory();
        System.out.println("D:\\重要代码Demo\\文件IO对象\\FileDemo1是否存在"+directory);
        //判断当前路径是否为文件
        boolean file = f2.isFile();
        System.out.println("是否是一个文件："+file);
        //判断是否隐藏文件
        boolean hidden = f1.isHidden();
        System.out.println("是否隐藏文件："+hidden);
    }
}

4.File类的获取功能和修改名字功能

File getAbsoluteFile(): 获取文件的绝对路径,返回File对象
String getAbsolutePath(): 获取文件的绝对路径,返回路径的字符串
String getParent(): 获取当前路径的父级路径,以字符串形式返回该父级路径
File getParentFile(): 获取当前路径的父级路径,以字File对象形式返回该父级路径
String getName(): 获取文件或文件夹的名称
String getPath(): 获取File对象中封装的路径
long lastModified(): 以毫秒值返回最后修改时间
long length(): 返回文件的字节数
boolean renameTo(File dest):  将当前File对象所指向的路径 修改为 指定File所指向的路径

package com.bianyiit.file;

import java.io.File;
import java.util.Date;

public class FileDemo4 {
    public static void main(String[] args) {
        //File getAbsoluteFile(): 获取文件的绝对路径,返回File对象，如果只单纯使用一个对象，那么就会返回项目路径\\文件文件IO对象
        File f1 = new File("D:\\重要代码Demo\\文件IO对象\\FileDemo1\\a.txt");
        File absoluteFile = f1.getAbsoluteFile();
        System.out.println(absoluteFile);
        //String getAbsolutePath(): 获取文件的绝对路径,返回路径的字符串
        String absolutePath = f1.getAbsolutePath();
        System.out.println(absolutePath);
        //String getParent(): 获取当前路径的父级路径,以字符串形式返回该父级路径
        String parent = f1.getParent();
        System.out.println(parent);
        //File getParentFile(): 获取当前路径的父级路径,以字File对象形式返回该父级路径
        File parentFile = f1.getParentFile();
        System.out.println(parentFile);
        //String getName(): 获取文件或文件夹的名称
        String name = f1.getName();
        System.out.println(name);
        //String getPath(): 获取File对象中封装的路径
        String path = f1.getPath();
        System.out.println(path);
        //long lastModified(): 以毫秒值返回最后修改时间
        long l = f1.lastModified();
        Date date = new Date(l);
        System.out.println(date.toLocaleString());
        //long length(): 返回文件的字节数
        long length = f1.length();
        System.out.println(length);
        //  boolean renameTo(File dest):  将当前File对象所指向的路径 修改为 指定File所指向的路径
        File f2 = new File("D:\\重要代码Demo\\文件IO对象2\\b.txt");  //已经将a.txt从以前的路径迁移到当前路径下了，并且文件名也已经改了
        boolean b = f1.renameTo(f2);
        System.out.println(b);
    }
}
//输出结果：
	D:\重要代码Demo\文件IO对象\FileDemo1\a.txt
	D:\重要代码Demo\文件IO对象\FileDemo1\a.txt
	D:\重要代码Demo\文件IO对象\FileDemo1
	D:\重要代码Demo\文件IO对象\FileDemo1
	a.txt
	D:\重要代码Demo\文件IO对象\FileDemo1\a.txt
	2019-11-19 19:47:25
	0
	true

5.File类的其它获取功能

String[] list(): 以字符串数组的形式返回当前路径下所有的文件和文件夹的名称
File[] listFiles(): 以File对象的形式返回当前路径下所有的文件和文件夹的名称
static File[] listRoots(): 获取计算机中所有的盘符

package com.bianyiit.file;

import java.io.File;

public class FileDemo5 {
    public static void main(String[] args) {
        //String[] list():以字符串数组的形式返回当前路径下所有的文件和文件夹的名称
        File f1 = new File("D:\\重要代码Demo");
        String[] list = f1.list();
        for (String s : list) {
            System.out.println(s);
        }
        //File[] listFiles():以File对象的形式返回当前路径下所有的文件和文件夹的名称
        File[] files = f1.listFiles();
        for (int i = 0; i < files.length; i++) {
            System.out.println(files[i]);
        }
        //static File[] listRoots():获取计算机中所有的盘符
        File[] files1 = File.listRoots();
        for (File file : files1) {
            System.out.println(file);
        }
    }
}
//输出结果：
	WeChatProjects
	workspace
	文件IO对象
	文件IO对象2
	D:\重要代码Demo\WeChatProjects
	D:\重要代码Demo\workspace
	D:\重要代码Demo\文件IO对象
	D:\重要代码Demo\文件IO对象2
	C:\
	D:\

九、File的两个案例

需求：获取“D:\重要代码Demo\文件IO对象”所有的文件/文件夹
主要使用了递归的思想
输入：
   D:\重要代码Demo\文件IO对象
输出：
   D:\重要代码Demo\文件IO对象\1
   D:\重要代码Demo\文件IO对象\1\a
   D:\重要代码Demo\文件IO对象\1\a\a.txt
   D:\重要代码Demo\文件IO对象\3
   D:\重要代码Demo\文件IO对象\4
   D:\重要代码Demo\文件IO对象\FileDemo1
步骤：
1.要获取“D:\重要代码Demo\文件IO对象”所有的文件/文件夹对象
2.判断这个对象是文件还是文件夹
    如果是文件，直接输出就行，如果是文件夹，又要获取此文件夹下面所有的文件和文件夹
3.以此类推下去，一直不停的判断，碰到文件夹就要获取里面所有的文件
    最终获取“D:\重要代码Demo\文件IO对象”下面所有的文件（递归思想）

package com.studentmanage.muludoc;

import java.io.File;

public class AllMuLuDoc {
    public static void main(String[] args) {
        //创建一个文件/文件夹对象
        File file = new File("D:\\重要代码Demo\\文件IO对象");
        Method(file);
    }

    private static void Method(File file) {
        //获取该目录下面的所有的文件和文件夹
        File[] files = file.listFiles();
        //遍历数组，得到单个的文件或者文件夹对象
        for (File file1 : files) {
            //判断file1是文件还是文件夹
            //如果是一个文件夹，要获取此文件夹下面所有的文件和文件夹对象
            if(file1.isDirectory()){
                System.out.println(file1);
                Method(file1);  //重复调用，然后继续获取该目录下面的所有的文件和文件夹
            }else{
            //如果是一个文件的话，直接输出
                System.out.println(file1);
            }
        }
    }
}
//输出结果：
	目录名称：D:\重要代码Demo\文件IO对象\1
	目录名称：D:\重要代码Demo\文件IO对象\1\a
	目录名称：D:\重要代码Demo\文件IO对象\1\a\a.txt
	目录名称：D:\重要代码Demo\文件IO对象\3
	目录名称：D:\重要代码Demo\文件IO对象\4
	目录名称：D:\重要代码Demo\文件IO对象\FileDemo1

删除指定的目录（包括子文件夹）

package com.bianyiit.anli;

import java.io.File;

public class AnLi2 {
    public static void main(String[] args) {
        //删除指定的目录（包含子目录）
        File file = new File("D:\\重要代码Demo\\文件IO对象\\2");
        Method(file);
    }

    private static void Method(File file) {
        if(file.isDirectory()){  //测试此抽象路径名表示的文件是否是一个目录。
            //获取所有的子文件夹和子文件
            File[] files = file.listFiles();
            for (File file1 : files) {
                if(file1.isFile()){
                    System.out.println(file1.getName());
                    file1.delete();
                }else if(file1.isDirectory()){
                    Method(file1);
                }
            }
        }
        System.out.println(file.getName());
        file.delete();
    }
}