异常处理和File类-11月16日讲课内容
异常
Throwable 类
Throwable 类是Java语言中所有错误和异常的顶级父类，直接子类为 Error 和 Exception
构造方法
// 无参构造：构造一个新的 throwable 对象，其详细信息为null
public Throwable()
// 有参构造：使用指定的详细信息(message)构造一个新的 throwable 对象
public Throwable(String message)成员方法
// 返回此 throwable 对象的详细信息字符串
public String getMessage()
// 返回一个简要信息描述
public String toString()
// 打印此 throwable 对象及其详细信息字符串到标准错误流(控制台)
public void printStackTrace()案例代码
public class Test {
public static void main(String[] args) {
Throwable throwable1 = new Throwable();
System.out.println(throwable1.getMessage());
System.out.println(throwable1.toString());
throwable1.printStackTrace();
Throwable throwable2 = new Throwable("错误信息！！！");
System.out.println(throwable2.getMessage());
System.out.println(throwable2.toString());
throwable2.printStackTrace();
}
}Error
Error 类是 Throwable 的子类，它指出了一个合理的应用程序不应该试图捕捉的严重问题
【注意】Error 结尾的是严重问题，无法解决
Exception
Exception 类及其子类是一种 Throwable 的子类，指示了一个合理的应用程序可能想要捕获的条件。
【注意】Exception 结尾的是我们可以处理的，一般我们需要关注的是 RuntimeException
异常处理
异常处理分为两种：捕获和抛出
有能力处理就进行捕获，没有就抛出
捕获
格式：
try {
// 有可能出现问题的代码，存在一定隐患的代码
} catch (异常类型 变量名) {
// 对应当前异常类型的处理方式
} finally {
// 无论是否捕获，都会执行，常用于释放资源
}案例代码
public class Test {
public static void main(String[] args) {
int num1 = 0;
int num2 = 20;
int ret = 0;
/*
* 除数不能为0
*/
try {
ret = num2 / num1;
} catch (ArithmeticException e) {
e.printStackTrace();
}
System.out.println(ret);
}
}结果
java.lang.ArithmeticException: / by zero
at code.exception.Test.main(Test.java:11)
0【注意】
1、代码中出现异常，JVM会终止代码运行，如果使用try catch捕获处理异常，JVM会认为当前代码中不存在异常，可以继续运行。 2、try - catch代码块中声明的都是局部变量，需要提前声明 3、try - catch捕获处理异常，可以处理多种异常情况 4、代码中存在多种隐患，存在多个异常情况，try - catch捕获有且只能处理第一个出现异常的代码，因为JVM从异常代码开始直接进入异常捕获阶段 5、Exception作为Java中所有异常的超类，在捕获异常处理时如果直接使用Exception进行捕获处理，无法具体到对某一个异常来处理 6、Exception可以作为try - catch 最后一个，用于处理其他异常捕获之后没有对症方式遗留问题
抛出
关键字:
throw
在方法内特定条件下抛出指定异常，后面跟异常类型的对象
throws
在【方法声明】位置，告知调用者，当前方法有哪些异常抛出，后面跟异常的类型
用于处理非当前方法操作问题，导致出现的异常，一般情况下是用于处理方法运行过程中因为参数传入，参数处理，运算结果导致的问题，抛出异常。
throw是一个稍微高级的参数合法性判断案例代码
public class TestThrows {
public static void main(String[] args) {
try {
test(1, 0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
/**
* 测试方法，打印两个数的差
*
* @param num1 第一个参数，被除数
* @param num2 第二个参数，除数
* @throws ArithmeticException 如果除数为0，抛出异常
*/
public static void test(int num1, int num2) throws ArithmeticException {
if (0 == num2) {
throw new ArithmeticException("除数不能为0");
}
System.out.println(num1 / num2);
}
}结果
java.lang.ArithmeticException: 除数不能为0
at code.exception.TestThrows.test(TestThrows.java:23)
at code.exception.TestThrows.main(TestThrows.java:7)【注意】
1、throw 和 throws 必须同时出现，并且体现在注释上
2、代码如果运行到throw抛出异常，之后的代码不再运行，之后的代码是成为无法抵达的代码
3、代码中存在多种隐患，按照隐含的情况，分门别类处理，不能在同一个条件内抛出两个异常。并且在方法的声明位置，throws之后，不同的异常，使用逗号隔开
4、当调用带有异常抛出的方法时，对于方法抛出的异常，有两种处理方式，可以捕获处理，也可以抛出处理。异常分类
运行时异常
RuntimeException：代码运行过程中出现的异常，没有强制处理的必要性，因为JVM会处理RuntimeException异常，即报错其他异常
强制要求处理，不管是捕获处理还是抛出处理，都需要进行操作，如果未处理就会报错自定义异常
继承自 Exception 或者 RuntimeException，只需要提供无参构造和一个带参构造即可
【注意】如果继承自Exception，调用抛出了此异常的方法需要手动对其捕获或者抛出
自定义异常类
public class MyException extends Exception {
public MyException() {}
public MyException(String message) {
super(message);
}
}测试
public class Test {
public static void main(String[] args) {
try {
buy(false);
} catch (MyException e) {
e.printStackTrace();
}
}
/**
* 买方法，当没有女朋友的时候，抛出异常
* @param hasGirlFriend boolean类型，是否有女朋友
* @throws MyException 自定义单身狗异常
*/
public static void buy(boolean hasGirlFriend) throws MyException {
if (false == hasGirlFriend) {
throw new MyException("你还没有女朋友");
}
System.out.println("买一送一");
}
}结果
code.myexception.MyException: 你还没有女朋友
at code.myexception.Test.buy(Test.java:19)
at code.myexception.Test.main(Test.java:6)注意
1、父类的方法有异常抛出，子类的重写方法在抛出异常的时候必须要小于等于父的异常
2、父类的方法没有异常抛出，子类的重写方法不能有异常抛出
3、父类的方法抛出多个异常，子类的重写方法必须比父少或者小总结
1、异常的存在是非常有必要的，可以帮助我们定位和解决问题
2、异常的处理方式：捕获和抛出
3、自定义异常一定要有无参构造和有参构造
4、后期会遇到大量的异常，一般使用快捷键就能搞定
Eclipse：Ctrl + 1
Idea：Alt + Enter
File 类
文件和目录路径名的抽象表示形式，提供了对文件和文件夹的增删改查的方法
构造方法
File(String pathName);
根据指定的文件路径，或者文件夹路径，创建对应的File类对象。路径可以是相对路径，可以是绝对路径
File(String parent, String childName);
根据指定的父目录文件夹路径，和子文件或者子文件夹的名字，创建对应的File类对象
File(File parent, String childName);
根据指定的父目录File类对象，和子文件或者子文件夹的名字，创建对应的File类对象【注意】如果是文件必须要有后缀名，否则就是文件夹
案例代码
public class Test {
public static void main(String[] args) {
File file1 = new File("D:/aaa");
File file2 = new File("D:/aaa", "1.txt");
File file3 = new File(file1, "1.txt");
System.out.println(file1); // D:\aaa
System.out.println(file2); // D:\aaa\1.txt
System.out.println(file3); // D:\aaa\1.txt
}
}创建方法
boolean createNewFile();
通过File类对象调用，创建File类对象中对应地址的普通文件，创建成功返回true，创建失败返回false;
失败原因:
1. 路径不合法，路径不存在，路径错误。
2. 对应文件夹没有写入权限。
3. 对应文件已存在。
4. 磁盘坏道，电脑蓝屏。
boolean mkdir();
通过File类对象创建，创建File类对象中对应的文件夹，创建成功返回true，失败返回false
失败原因:
1. 路径不合法，路径不存在，路径错误。
2. 对应文件夹没有写入权限。
3. 对应文件夹已存在。
4. 磁盘坏道，电脑蓝屏。
boolean mkdirs();
创建文件夹过程中可以完成中间路径
boolean renameTo(File dest);
通过File类对象调用，转为目标dest指定File类对象，可以操作普通文件，可以操作文件夹。移动或者重命名案例代码
public class Test {
public static void main(String[] args) throws IOException {
File file1 = new File("C:/Users/CJF/Desktop/啥啥啥.txt");
boolean createNewFile = file1.createNewFile();
System.out.println(createNewFile);
File file2 = new File("C:/Users/CJF/Desktop/啥啥啥");
boolean mkdir = file2.mkdir();
System.out.println(mkdir);
File file3 = new File("C:/Users/CJF/Desktop/啥啥啥/afaf/aggr/htedfgb/er");
boolean mkdirs = file3.mkdirs();
System.out.println(mkdirs);
File file4 = new File("C:/Users/CJF/Desktop/什么鬼.txt");
boolean renameTo = file1.renameTo(file4);
System.out.println(renameTo);
}
}删除方法
boolean delete();
通过File类对象调用，删除File类对象对应的文件或者文件夹。
注意事项:
1. 从磁盘中直接抹掉数据，不经过回收站，慎用
2. 删除操作只针对于空文件夹操作，不能删除非空文件夹
void deleteOnExit();
程序退出之后，删除调用该方法File类对象，对应的普通文件或者文件夹。
用于缓冲文件，缓存问题，日志文件案例代码
public class Test {
public static void main(String[] args) throws IOException {
File file = new File("C:/Users/CJF/Desktop/Test.txt");
System.out.println(file.createNewFile()); // true
System.out.println(file.delete()); // true
file.deleteOnExit();
}
}获取方法
前三个方法和文件或者文件夹是否存在无关。
String getPath();
获取File类对象中保存的路径
String getName();
获取File类对象操作对应的文件名或者文件夹名
String getParent();
获取File类对象操作文件或者文件夹的上级目录
String getAbsolutePath();
获取当前File类对象对应路径的绝对路径
long length();
获取当前【文件】的占用磁盘空间字节数
根据不同的系统环境，文件夹调用length方法 0L 或者 4096L
long lastModified();
获取当前文件夹上一次修改时间的【时间戳】
是从计算机元年1970-01-01 00:00:00 到修改时间的秒数案例代码
public class Test {
public static void main(String[] args) {
File file = new File("D:/aaa/bbb/ccc/1.txt");
System.out.println(file.getPath()); // D:\aaa\bbb\ccc\1.txt
System.out.println(file.getParent()); // D:\aaa\bbb\ccc
System.out.println(file.getName()); // 1.txt
System.out.println(file.length()); // 0
System.out.println(file.lastModified());// 0
System.out.println(new File(".").getAbsolutePath()); // D:\Qfeng\day27\.
}
}判断方法
boolean isFile();
判断当前File类对象对应的是不是普通文件。
boolean isDirectory();
判断当前File类对象对应的是不是文件夹。
boolean exists();
判断当前File类对象对应的内容是否存在。
boolean isAbsolute();
判断当前File类对象保存的路径是不是绝对路径。
boolean isHidden();
判断当前File类对象对应的文件是不是一个隐藏文件。案例代码
public class TestFileDecide {
public static void main(String[] args) {
File file = new File("D:/Adobe");
System.out.println(file.exists()); // true
System.out.println(file.isFile()); // false
System.out.println(file.isDirectory()); // true
System.out.println(file.isAbsolute()); // true
System.out.println(file.isHidden()); // false
}
}列表方法
static File[] listRoots();
获取Windows操作系统下的所有盘符
Linux中没有什么作用。
String[] list();
获取File类对象对应文件夹中所有子文件或者子文件夹名字，String类型数组
File[] listFiles();
获取File类对象对应文件夹中所有子文件或者子文件夹的File类对象数组案例代码
public class Test {
public static void main(String[] args) {
File file = new File("C:/Users/CJF/Desktop");
String[] list = file.list();
for (String fileName : list) {
System.out.println(fileName);
}
File[] listFiles = file.listFiles();
for (File file2 : listFiles) {
System.out.println(file2);
}
File[] listRoots = File.listRoots();
for (File file2 : listRoots) {
System.out.print(file2 + "\t"); // C:\ D:\ E:\
}
}
}FilenameFilter 文件名过滤器接口
实现此接口的类实例可用于过滤文件名。
boolean accept(File dir, String name);
dir是当前操作获取文件列表的文件夹File类对象
name是当前文件夹下的文件名或者文件夹名案例代码
public class Test {
public static void main(String[] args) {
File file = new File("D:/EclipseWorkSpace/rx1901/src/com/fc/za/file");
String[] fileNameArray = file.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(".java");
}
});
for (String fileName : fileNameArray) {
System.out.println(fileName);
}
}
}扩展：匿名内部类格式
匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与内部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类
不使用匿名内部类
public class Demo7 {
public static void main(String[] args) {
File file = new File("D:/EclipseWorkSpace/rx1901/src/com/fc/za/file");
// 传入一个接口的实现类
String[] list = file.list(new JavaFilter());
// 对结果进行增强for循环
for (String string : list) {
System.out.println(string);
}
}
}
// 此接口用于过滤指定的文件名，需要重写accept方法
class JavaFilter implements FilenameFilter {
// 过滤以 .java 结尾的文件
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(".java");
}
}使用匿名内部类
public class Demo7 {
public static void main(String[] args) {
File file = new File("D:/EclipseWorkSpace/rx1901/src/com/fc/za/file");
/*
* 匿名内部类，常用于我们的参数传递，
* 用来创建一个没有名字的类的对象
*
* 写法：new 类名或者接口名() {}
*
* 如果是接口，直接在{}里面实现方法的重写
*/
String[] list2 = file.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(".java");
}
});
for (String string : list2) {
System.out.println(string);
}
}
}