第二十天 IO-异常file类【悟空教程】

Java帮帮

发布于 2018-07-26 15:35:58

7840

发布于 2018-07-26 15:35:58

文章被收录于专栏：Java帮帮-微信公众号-技术文章全总结Java帮帮-微信公众号-技术文章全总结

第二十天 IO-异常&file类【悟空教程】

第20天 IO

第1章异常

1.1 异常概念

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

1.2 异常分类

异常的根类是Throwable，其下有两个子类：Error与Exception，平常所说的异常指Exception。

严重错误Error，无法通过处理的错误
编译时异常Exception，编译时无法编译通过。如日期格式化异常
运行时异常RuntimeException，是Exception的子类，运行时可能会报错，可以不处理。如数学异常

import java.text.ParseException;

import java.text.SimpleDateFormat;

* 异常 : 本身还是类, 你看见的异常,都是虚拟机给你抛出的异常对象. 当程序有问题时,异常信息就是你的救命稻草.

* 通过异常信息,来修改你的程序,才能保证你程序的正确.

* 异常就是你程序中的问题. 难免的. 所以当你遇到异常信息的时候, 最好记录下来.

* 异常名字:

* 异常原因:

* 异常解决方案:

异常分类:

Throwable

| Error 大问题 , 程序无法解决

| Exception 小问题 , 需要你来解决.

| 编译期异常. 你在编译期,必须处理.

| 运行期异常. 程序运行起来,才可能报出异常.程序运行之前,不一定要处理.

但是,如果出现了异常,必须处理.

public class Demo {

public static void main(String[] args) throws ParseException {

System.out.println(10 / 0 );

System.out.println("over");

new SimpleDateFormat().parse("ss");

}

1.3 异常基本操作

创建异常对象（JDK已定义的异常会自动创建对象，自定义异常需要手动创建）
抛出异常（JDK已有定义的异常会自动抛出异常，自定义异常需要手动抛出）
处理异常：

捕获处理，将异常获取，使用try/catch做分支处理

try{

需要检测的异常；

} catch(异常对象) {

异常处理代码

可以调用异常的方法

通常我们只使用一个方法：printStackTrace打印异常信息

}

声明抛出处理，出现异常后不处理，声明抛出给调用者处理。

方法声明上加throws 异常类名

注意：异常处理，指处理的一种可能性，即有了异常处理的代码，不一定会产生异常。如果没有产生异常，则代码正常执行，如果产生了异常，则中断当前执行代码，执行异常处理代码。

1.3.1 异常的处理方式一: try ... catch

* 异常的处理方式1: try ... catch

* try{

* 可能有异常的代码

* }catch(Exception e){

* 处理异常.

* }

* 可以 catch 多个异常信息.

* 异常的处理方式2 : try ...finally

* try中: 可能异常的代码,出现异常,抛给虚拟机,程序终止.

* finally中的代码,会在终止之前 ,运行(关闭资源的操作).

* 异常处理方式3 : try ...catch ...finally

public class Demo {

public static void main(String[] args) {

try {

System.out.println(10 / 0 );

} catch (Exception e) {

// TODO: handle exception

e.printStackTrace(); // 打印异常信息

}

System.out.println("over");

}

1.3.2 异常的处理方式一: try ... catch 练习：

public class Demo2 {

public static void main(String[] args) {

int[] arr = {1,2,3};

method(arr);

}

private static void method(int[] arr ) {

try {

// 可能出现异常的地方

System.out.println(arr[5]);

} catch (Exception e) {

System.out.println("不好了, 报了异常啦, 我的天啊!!!!");

System.out.println(e);

String message = e.getMessage();

System.out.println(message);

e.printStackTrace();

}

1.3.3 异常的处理方式一: try ... catch 扩展：

import java.util.ArrayList;

public class Demo3 {

public static void main(String[] args) {

ArrayList<Object> arrayList = null;

printArrayList(arrayList );

}

private static void printArrayList( ArrayList list ) {

try {

System.out.println(10 / 0 );

for (Object object : list) {

System.out.println(object);

}

} catch (NullPointerException e) {

// TODO: handle exception

e.printStackTrace();

} catch (ArithmeticException e) {

// TODO: handle exception

System.out.println("算错啦");

} catch (Exception e) {

// TODO: handle exception

}

System.out.println("over");

}

1.3.4 异常处理方式二：try ...finally

public class Demo4 {

public static void main(String[] args) {

try {

System.out.println(10 / 0 );

} finally {

System.out.println("==========");

}

System.out.println("over");

}

1.3.5 异常处理方式三： try ...catch ...finally

public class Demo5 {

public static void main(String[] args) {

try {

System.out.println( 10 / 0 );

}catch(Exception e ){

System.out.println("算错了");

} finally {

System.out.println("关闭资源");

}

System.out.println("over");

}

1.4 异常方式详解

1.4.1 抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1,创建一个异常对象。封装一些提示信息(信息可以自己编写)。
2,需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象；

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数);

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

下面是异常类ArrayIndexOutOfBoundsException与NullPointerException的构造方法

学习完抛出异常的格式后，我们通过下面程序演示下throw的使用。

编写工具类，提供获取数组指定索引处的元素值

class ArrayTools{

//通过给定的数组，返回给定的索引对应的元素值。

public static int getElement(int[] arr,int index) {

若程序出了异常，JVM它会打包异常对象并抛出。但是它所提供的信息不够给力。想要更清晰，需要自己抛出异常信息。

下面判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。这时就会结束当前方法的执行，并将异常告知给调用者。这时就需要通过异常来解决。

if(arr==null){

throw new NullPointerException("arr指向的数组不存在");

}

if(index<0 || index>=arr.length){

throw new ArrayIndexOutOfBoundsException("错误的角标，"+index+"索引在数组中不存在");

}

int element = arr[index];

return element;

}

测试类

class ExceptionDemo3 {

public static void main(String[] args) {

int[] arr = {34,12,67}; //创建数组

int num = ArrayTools.getElement(null,2);// 调用方法，获取数组中指定索引处元素

//int num = ArrayTools.getElement(arr,5);// 调用方法，获取数组中指定索引处元素

System.out.println("num="+num);//打印获取到的元素值

}

1.4.2 声明异常throws

声明：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

声明异常格式：

修饰符返回值类型方法名(参数) throws 异常类名1,异常类名2… { }

声明异常的代码演示：

class Demo{

如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明。

public void show(int x)throws Exception {

if(x>0){

throw new Exception();

} else {

System.out.println("show run");

}

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

多个异常的情况，例如:

public static int getElement(int[] arr,int index) throws NullPointerException, ArrayIndexOutOfBoundsException {

if(arr==null){

throw new NullPointerException("arr指向的数组不存在");

}

if(index<0 || index>=arr.length){

throw new ArrayIndexOutOfBoundsException("错误的角标，"+index+"索引在数组中不存在");

}

int element = arr[index];

return element;

}

1.4.3 捕获异常try…catch…finally

捕获：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理

捕获异常格式：

try {

//需要被检测的语句。

}

catch(异常类变量) { //参数。

//异常的处理语句。

}

finally {

//一定会被执行的语句。

}

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

演示如下：

class ExceptionDemo{

public static void main(String[] args){ //throws ArrayIndexOutOfBoundsException

try {

int[] arr = new int[3];

System.out.println( arr[5] );// 会抛出ArrayIndexOutOfBoundsException

当产生异常时，必须有处理方式。要么捕获，要么声明。

}

catch (ArrayIndexOutOfBoundsException e) { //括号中需要定义什么呢？try中抛出的是什么异常，在括号中就定义什么异常类型。

System.out.println("异常发生了");

} finally {

arr = null; //把数组指向null，通过垃圾回收器，进行内存垃圾的清除

}

System.out.println("程序运行结果");

}

1.5 异常注意事项

多异常处理

捕获处理：

1多个异常分别处理

2多个异常一次捕获多次处理

3多个异常一次捕获一次处理

声明抛出异常：

声明上使用,一次声明多个异常

运行时异常被抛出可以不处理。即不捕获也不声明抛出
如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集
父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
当多异常处理时，捕获处理，前边的类不能是后边类的父类
在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。

方法中已经出现返回语句返回值A，再在finally中修改A值，则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了

代码演示:

void show(){ //不用throws

try{

throw new Exception();//产生异常，直接捕获处理

}catch(Exception e){

//处理方式

}

一个try 多个catch组合 :

对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。

void show(){ //不用throws

try{

throw new Exception();//产生异常，直接捕获处理

}catch(XxxException e){

//处理方式

}catch(YyyException e){

//处理方式

}catch(ZzzException e){

//处理方式

}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

try finally 组合:

对代码进行异常检测，检测到异常后因为没有catch，所以一样会被默认jvm抛出。异常是没有捕获处理的。但是功能所开启资源需要进行关闭，所有finally。只为关闭资源。

void show(){//需要throws

try{

throw new Exception();

}finally {

//释放资源

}

声明抛出异常：

声明上使用,一次声明多个异常

import java.text.ParseException;

import java.text.SimpleDateFormat;

* 异常的第二种处理方式: 声明 throws .

* throws + 异常类名字. 说明 : 这个方法可能有异常 .

public class Demo6 {

public static void main(String[] args) throws ParseException , IndexOutOfBoundsException , Exception {

System.out.println(10 / 0 );

new SimpleDateFormat().parse("ss");

}

1.6 自定义异常

在上述代码中，发现这些异常都是JDK内部定义好的，并且这些异常不好找。书写时也很不方便，那么能不能自己定义异常呢？

之前的几个异常都是java通过类进行的描述。并将问题封装成对象，异常就是将问题封装成了对象。这些异常不好认，书写也很不方便，能不能定义一个符合我的程序要求的异常名称。既然JDK中是使用类在描述异常信息，那么我们也可以模拟Java的这种机制，我们自己定义异常的信息，异常的名字，让异常更符合自己程序的阅读。准确对自己所需要的异常进行类的描述。

1.6.1 自定义异常类的定义

通过阅读异常源代码：发现java中所有的异常类，都是继承Throwable，或者继承Throwable的子类。这样该异常才可以被throw抛出。

说明这个异常体系具备一个特有的特性：可抛性：即可以被throw关键字操作。

并且查阅异常子类源码，发现每个异常中都调用了父类的构造方法，把异常描述信息传递给了父类，让父类帮我们进行异常信息的封装。

例如NullPointerException异常类源代码：

public class NullPointerException extends RuntimeException {

public NullPointerException() {

super();//调用父类构造方法

}

public NullPointerException(String s) {

super(s);//调用父类具有异常信息的构造方法

}

现在，我们来定义个自己的异常，即自定义异常。

格式：

Class 异常名 extends Exception{ //或继承RuntimeException

public 异常名(){

}

public 异常名(String s){

super(s);

}

自定义异常继承Exception演示

class MyException extends Exception{

为什么要定义构造函数，因为看到Java中的异常描述类中有提供对异常对象的初始化方法。

public MyException(){

super();

}

public MyException(String message) {

super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。

}

自定义异常继承RuntimeException演示

class MyException extends RuntimeException{

为什么要定义构造函数，因为看到Java中的异常描述类中有提供对异常对象的初始化方法。

MyException(){

super();

}

MyException(String message) {

super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。

}

1.6.2 自定义异常的练习

定义Person类，包含name与age两个成员变量。

在Person类的有参数构造方法中，进行年龄范围的判断，若年龄为负数或大于200岁，则抛出NoAgeException异常，异常提示信息“年龄数值非法”。

要求：在测试类中，调用有参数构造方法，完成Person对象创建，并进行异常的处理。

自定义异常类

class NoAgeException extends Exception{

NoAgeException() {

super();

}

NoAgeException(String message) {

super(message);

}

Person类

class Person{

private String name;

private int age;

Person(String name,int age) throws NoAgeException {

//加入逻辑判断。

if(age<0 || age>200) {

throw new NoAgeException(age+",年龄数值非法");

}

this.name = name;

this.age = age;

}

//定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。

public String toString() {

return "Person[name="+name+",age="+age+"]";

}

测试类

class ExceptionDemo{

public static void main(String[] args) {

try {

Person p = new Person("xiaoming",20);

System.out.println(p);

}

catch (NoAgeException ex){

System.out.println("年龄异常啦");

}

System.out.println("over");

}

总结一下，构造函数到底抛出这个NoAgeException是继承Exception呢？还是继承RuntimeException呢？

继承Exception，必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行。
继承RuntimeExcpetion,不需要throws声明的，这时调用是不需要编写捕获代码的，因为调用根本就不知道有问题。一旦发生NoAgeException，调用者程序会停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码。

import java.util.ArrayList;

* 自定义异常: 一般情况下用于你业务当中异常处理. 但是通常懒得出处理.

* 定义类,继承异常类. Exception就是编译期异常. RuntimeException 运行期异常.

public class Demo {

public static void main(String[] args) throws AgeIllegalException {

// fun();

ArrayList<Object> arr =null;

arr.size();

}

private static void fun() throws AgeIllegalException {

//创建 Person 对象

Person person = new Person();

person.setAge(150);

System.out.println(person.getAge());

}

public class Person {

String name;

int 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 AgeIllegalException {

if (age >= 0 && age <= 130) {

this.age = age;

} else {

// 抛异常

throw new AgeIllegalException("年龄非法啦");

}

* 年龄非法异常.

public class AgeIllegalException extends Exception {

public AgeIllegalException() {

super();

// TODO Auto-generated constructor stub

}

public AgeIllegalException(String message) {

super(message);

// TODO Auto-generated constructor stub

}

第2章 File类

2.1 IO与File概述

2.1.1 IO概述

当使用集合持有数据时，这些数据都存在于内存中，一旦程序运行结束，这些数据将会从内存中清除，下次再想使用这些数据，已经没有了。如果希望将数据永久地保存下来，可以使用IO，将这些数据持久化存储起来。要把数据持久化存储就需要把内存中的数据存储到内存以外的其他持久化设备（硬盘，光盘，U盘）上。

此时需要数据的输入（in）输出（out）。

数据输入输出相关的类均在io包下。

2.1.2 File类

数据需要持久化存储到最适合的地方硬盘文件上，Java提供了File类来表示文件。每个File对象就代表硬盘上的一个文件或者文件夹。

虽然File类封装的为文件路径或者文件夹路径。但是通过路径可以找到对应的文件或者文件夹，所以File类简介仍代表文件或文件夹。

2.1.3 绝对路径与相对路径

下边我们即将要学习的File类的构造方法中，可以使用文件或者文件夹所在路径字符串作为参数，这个字符串可以是文件/目录的“绝对路径”也可以是“相对路径”。

绝对路径：从盘符开始到文件的全路径

File file = new File(“C:\\XXX\project”);

File file = new File(“C:\\XXX\project\myfile.txt”);

相对路径：从某个参照物路径开始到指定文件所经过的路径

File file = new File(“myfile.txt”);

2.1.4 File类的常见方法

2.1.4.1 File类的构造函数

构造方法摘要

File(File parent, String child)

根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname)

通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child)

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri)

通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

import java.io.File;

* File 类 :文件和文件夹路径名的抽象表示形式。

* String s = "C:\Users\youcai\Desktop\斗地主图解2.PNG"

* File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

public class Demo {

public static void main(String[] args) {

//fun();

String parent = "C:\\Users\\youcai\\Desktop";

String child = "斗地主图解.PNG";

//创建File 对象

File file = new File(parent, child);

System.out.println(file.exists());

// 通过父级File 对象,创建子级文件

File parent_file = new File(parent);

File file2 = new File(parent_file, child);

System.out.println(file2.exists());

}

private static void fun() {

//创建一个File 对象

File f = new File("C:\\Users\\youcai\\Desktop\\斗地主图解.PNG");

System.out.println(f.exists());

File f2 = new File("C:\\Users\\youcai\\Desktop\\斗地主图解2.PNG");

System.out.println(f2.exists());

}

2.1.4.2 File类的获取

import java.io.File;

* File 的方法

* 绝对路径 : "C:\\Users\\youcai\\Desktop\\斗地主图解.PNG"; 从盘符开始

* 相对路径 : 相对与谁就在谁的下面. 我们程序中,相对的是项目, 所以aaa.txt文件, 就是项目下的aaa.txt

public class Demo2 {

public static void main(String[] args) {

//fun();

String s = "aaa.txt";

File file = new File(s);

System.out.println(file.exists());

// 获取绝对路径

System.out.println(file.getAbsolutePath());

// 获取路径

System.out.println(file.getPath());

//获取文件名称

System.out.println(file.getName());

//获取文件大小 byte 作为单位.

System.out.println(file.length()); //

}

private static void fun() {

String pathname = "C:\\Users\\youcai\\Desktop\\斗地主图解.PNG";

//创建 File 对象

File file = new File(pathname);

// 文件是否存在

System.out.println(file.exists());

// 获取绝对路径

System.out.println(file.getAbsolutePath());

// 获取路径

System.out.println(file.getPath());

//获取文件名称

System.out.println(file.getName());

//获取文件大小 byte 作为单位.

System.out.println(file.length()); //20882

}

2.1.4.3 文件/文件夹的创建删除等

经常上面介绍，我们知道可以通过File获取到文件名称，文件路径(目录)等信息。

接下来演示使用File类创建、删除文件等操作。

我们进行方法的演示

public class FileMethodDemo2 {

public static void main(String[] args) throws IOException {

// 对文件或者文件加进行操作。

File file = new File("e:\\file.txt");

// 创建文件，如果文件不存在，创建 true 如果文件存在，则不创建 false。如果路径错误，IOException。

boolean b1 = file.createNewFile();

System.out.println("b1=" + b1);

//-----------删除文件操作-------注意：不去回收站。慎用------

boolean b2 = file.delete();

System.out.println("b2="+b2);

//-----------需要判断文件是否存在------------

boolean b3 = file.exists();

System.out.println("b3="+b3);

//-----------对目录操作创建，删除，判断------------

File dir = new File("e:\\abc");

//mkdir()创建单个目录。//dir.mkdirs();创建多级目录

boolean b4 = dir.mkdir();

System.out.println("b4="+b4);

//删除目录时，如果目录中有内容，无法直接删除。

boolean b5 = dir.delete();

//只有将目录中的内容都删除后，保证该目录为空。这时这个目录才可以删除。

System.out.println("b5=" + b5);

//-----------判断文件，目录------------

File f = new File("e:\\javahaha");// 要判断是否是文件还是目录，必须先判断存在。

// f.mkdir();//f.createNewFile();

System.out.println(f.isFile());

System.out.println(f.isDirectory());

}

2.1.4.4 listFile()方法介绍

文件都存放在目录（文件夹）中，那么如何获取一个目录中的所有文件或者目录中的文件夹呢？那么我们先想想，一个目录中可能有多个文件或者文件夹，那么如果File中有功能获取到一个目录中的所有文件和文件夹，那么功能得到的结果要么是数组，要么是集合。我们开始查阅API。

方法演示如下：

public class FileMethodDemo3 {

public static void main(String[] args) {

File dir = new File("e:\\java_code");

//获取的是目录下的当前的文件以及文件夹的名称。

String[] names = dir.list();

for(String name : names){

System.out.println(name);

}

//获取目录下当前文件以及文件对象，只要拿到了文件对象，那么就可以获取其中想要的信息

File[] files = dir.listFiles();

for(File file : files){

System.out.println(file);

}

注意：在获取指定目录下的文件或者文件夹时必须满足下面两个条件

1，指定的目录必须是存在的，

2，指定的必须是目录。否则容易引发返回数组为null，出现NullPointerException

2.1.5 Flie类方法遍历（完整遍历）

import java.io.File;

* File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

public class Demo {

public static void main(String[] args) {

// fun1();

File file = new File("E:\\CloudMusic.zip");

File[] listFiles = file.listFiles();

for (File f : listFiles) {

if (f.isDirectory()) {

// 文件夹

File[] listFiles2 = f.listFiles();

for (File f2 : listFiles2) {

String absolutePath = f2.getAbsolutePath();

System.out.println(absolutePath);

}

}else {

// 文件

String absolutePath = f.getAbsolutePath();

System.out.println(absolutePath);

}

private static void fun1() {

File file = new File("E:\\迅雷下载");

System.out.println(file.exists());

// 遍历

File[] listFiles = file.listFiles();

for (File f : listFiles) {

String absolutePath = f.getAbsolutePath();

//System.out.println(f.getAbsolutePath());

if (absolutePath.endsWith(".exe")) {

System.out.println(absolutePath);

}

第3章本日学习作业

3.1 知识点相关题：

3.1.1 File对象方法练习

定义测试类，在测试类中定义main()方法，按以下要求编写代码：

在项目根目录下建立文件：demo02.txt，里面添加一些内容；
使用这个文件构造一个File对象，调用File的相关方法获取以下信息：

1.文件的绝对路径；

2.文件名；

3.文件大小；

4.此File对象的路径名

package day10_Test基础练习题;

import java.io.File;

public class Test002 {

/*

 * 定义测试类，在测试类中定义main()方法，按以下要求编写代码：

l在项目根目录下建立文件：demo02.txt，里面添加一些内容；

l使用这个文件构造一个File对象，调用File的相关方法获取以下信息：

1.文件的绝对路径；

2.文件名；

3.文件大小；

4.此File对象的路径名；

 */

public static void main(String[] args) {

File file = new File("demo01.txt");

//1.文件的绝对路径

String absolutePath = file.getAbsolutePath();

System.out.println("文件的绝对路径："+absolutePath);

//2.文件名字

String name = file.getName();

System.out.println("文件的名字："+name);

//3.文件的大小

long totalSpace = file.getTotalSpace();

System.out.println("文件的大小："+totalSpace);

//4.此File对象的路径名

String path = file.getPath();

System.out.println("文件的路径名："+path);

}

}

3.1.2 判断File是否是文件或者目录，删除文件

定义测试类，在测试类中定义main()方法，按以下要求编写代码：

构造一个File对象，指向项目根目录下的demo03.txt（此文件不存在）；
判断，如果文件不存在，就创建这个文件，打印创建结果；
判断这个File对象是否是一个文件，打印结果；
判断这个File对象是否是一个目录，打印结果；
删除这个文件

package day10_Test基础练习题;

import java.io.File;

import java.io.IOException;

public class Test003 {

/*

 * 定义测试类，在测试类中定义main()方法，按以下要求编写代码：

l构造一个File对象，指向项目根目录下的demo03.txt（此文件不存在）；

l判断，如果文件不存在，就创建这个文件，打印创建结果；

l判断这个File对象是否是一个文件，打印结果；

l判断这个File对象是否是一个目录，打印结果；

l删除这个文件；

 */

public static void main(String[] args) throws IOException {

File file = new File("demo03.txt");

if(! file.exists()){

file.createNewFile();

}

if(file.isFile()){

System.out.println("是一个文件");

}else{

System.out.println("不是一个文件");

}

if(file.isDirectory()){

System.out.println("是一个目录");

}else {

System.out.println("不是一个目录");

}

}

}

3.1.3 File对象，判断：如果是文件，打印：”文件(绝对路径)”否则，打印：”目录(绝对路径)

定义类，定义main()方法，按以下要求编写代码：

构造一个File对象，指向你D盘的某个目录；
获取此目录下所有的文件/目录的名称，并打印。(list())
获取此目录下所有的文件/目录的File对象，遍历这个数组，获取每个File对象，判断：如果是文件，打印：”文件(绝对路径)”否则，打印：”目录(绝对路径)

package day10_Test基础练习题;

import java.io.File;

public class Test005 {

/*

 * 定义类，定义main()方法，按以下要求编写代码：

l构造一个File对象，指向你D盘的某个目录；

l获取此目录下所有的文件/目录的名称，并打印。(list())

l获取此目录下所有的文件/目录的File对象，遍历这个数组，获取每个File对象，判断：如果是文件，打印：”文件(绝对路径)”

否则，打印：”目录(绝对路径)”

 */

public static void main(String[] args) {

File file = new File("D:\\kaifa");

String[] list = file.list();

//获取此目录下所有的文件/目录的名称

/*for (String string : list) {

System.out.println(string);

}*/

//获取此目录下所有的文件/目录的File对象

File[] listFiles = file.listFiles();

for (File file2 : listFiles) {

if(file2.isDirectory()){

System.out.println("这个是目录");

System.out.println(file2.getPath());

}else{

System.out.println("这是一个文件");

System.out.println(file2.getAbsolutePath());

}

}

}

}

3.1.4 异常：try…catch…语句

要求：

1) 掌握try…catch…语句的用法：

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

从控制台接收一个整数；
使用try…catch…监控这一过程，如果用户输入了非数字，在catch语句中向用户打印：请输入一个整数！

(catch捕获的异常：InputMismatchException)

3.1.5 异常：try…catch…finally…语句

要求：

1) 掌握finally语句的用法：

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

定义一个方法：print(int[] arr)，可以打印一个int数组的内容，在方法内按以下步骤编写代码：
- 在try代码块内遍历数组，打印每个元素；
- 在catch代码块内监控并捕获空指针异常：NullPointerException，如果异常，打印：错误，数组引用为NULL。
- 在finally代码块内打印：方法执行完毕！

3.1.6 异常：多catch语句

要求：

1) 掌握多catch语句的用法：

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

在try代码块内：请用户分别输入两个整数，计算两个整数的除法，打印结果；
在两个catch代码块内：监控并捕获两种异常：

1. InputMismatchException：用户输入的非数字

2. ArithmeticException:算术运算异常在每个catch内打印一些提示信息。

3.1.7 异常：Throwable中的常用方法

要求：

1) 掌握Throwable中的常用方法；

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

在try代码块中：接收两个整数，并做除法运算；
在catch代码块中：监控除数为零的异常情况，并调用以下方法获取异常信息：

1. 调用“异常对象”的getMessage()方法获取异常信息，并打印；

2. 调用“异常对象”的toString()方法获取异常信息，并打印；

3. 调用“异常对象”的printStackTrace()方法直接打印堆栈异常；

4. 请说明三种方法有哪些不同？

3.1.8 异常：自定义异常

要求：

1) 掌握自定义异常：

题目：

1) 自定义异常类，MonthException，并且继承自Exception，添加一个带String参数的构造方法：public MonthException(String msg){

super(msg);

}

2) 定义测试类，定义main()方法，按以下要求编写代码：

定义一个方法，接收1—7的星期值，返回：中文表示的星期字符串。
- 方法内判断参数如果不在1—7的范围内，抛出MonthException否则返回中文表示的星期字符串；

3.2 代码题

3.2.1 自定义一个Person类，其中有字段age，并提供相应的set get 方法，age业务逻辑上不可以使用 <= 0 的数字

需求：如果使用setAge 为age赋值时，如果设置的是非法的数据，那么抛出一个自定义的编译期异常（AgeException），然后测试，调用setAge方法，并进行try catch 处理。

答案：

public class AgeException extends Exception {

public AgeException() {

super();

}

 

public AgeException(String message) {

super(message);

}

}

 

public class Person {

private String name;

private int age;//0

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 >= 200){

/*AgeException ageExce = new AgeException();

throw ageExce;//抛出异常

*/  

//throw new AgeException();

throw new AgeException("年龄非法，不可以是负数或超出200");

} else {

this.age = age;

}

}

}

 

 

public class Demo00_Exception {

public static void main(String[] args) {

Person p = new Person();

try {

p.setAge(-100);

} catch (AgeException e) {

//System.out.println("年龄非法!");

e.printStackTrace();

}//收到一个异常

System.out.println(p.getAge());

}

}

3.2.2 使用键盘录入模拟从银行取钱，假设余额是3000元，如果录入的数据大于余额，通过自定义运行时异常给出提示。

答案：

//银行ATM异常

class ATMException extends RuntimeException {

public ATMException() {

super();

}

 

public ATMException(String message) {

super(message);

}

}

 

//银行取款机

class ATM {

//取款方法

public static int getMoney(int money) {

if (money>3000) {

throw new ATMException("余款不足，请重新输入！");

} else {

System.out.println("正在出款："+money);

return money;

}

}

}

 

public class ExceptionTest {

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

System.out.println("请输入取款金额:");

int money = sc.nextInt();



//银行ATM取款

int result = ATM.getMoney(money);

System.out.println("取到金额："+result);



}

}

3.2.3 在try语句块中：从控制台接收两个数；计算第一个数除以第二个数，并打印结果；使用catch语句监控并处理：除数为零的异常情况，并打印：错误，除数不能为零！

public class Demo {

 

public static void main(String[] args) {

 

try {

Scanner sc = new Scanner(System.in);

System.out.println("请输入第一个数：");

int i1 = sc.nextInt();

System.out.println("请输入第二个数：");

int i2 = sc.nextInt();

 

int a = i1 / i2;

System.out.println("i1 / i2 的值是："+a);

} catch (Exception e) {

System.out.println("错误，除数不能为零！");

}

}

}

本文参与腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2018-06-07，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自 Java帮帮微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

其他