黑马程序员---Java基础---异常、File类和递归-CSDN博客

-----------android 培训、java培训、java学习型技术博客、期待与您交流！------------

一、异常：

1、异常的概述：

异常：异常就是Java程序在运行过程中出现的错误。

异常由来：问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。

目的：让我们的程序在出现异常情况时，不至于崩溃。

2、异常处理方案：

方案一：一个异常的情况

try{

//可能出现异常的代码

}catch(异常类型变量名){//异常类型：是try中代码可能出现的异常类型

//如果try中代码出现异常，将调到此处执行；

}

执行流程：

1.无异常：

1).try之前的代码；

2).try中的代码；

3).try...catch...语句之后的代码；

2.有异常：

1).try之前的代码；

2).try中的代码(某一行出现异常：try中的后续代码将不会被执行)

3).JVM判断异常类型；

实例化异常对象；

判断我们程序是否"捕获"?

4).如果程序希望"捕获"：catch(异常类型：就是JVM得到的异常类型，这时，将会执行catch...中的代码；

5).try...catch...的后续代码；

package cn.hebei.sjz_异常;

/*
 * 有异常的情况下，try中执行异常前的语句，异常后的不再执行。
 */
public class Demo1 {
	public static void main(String[] args) {
		int[] array = { 1, 2, 5, 3 };
		try {
			System.out.println("aaa");// aaa
			// 出现异常，后续代码不再执行
			System.out.println(array[4]);
			System.out.println("bbb");
		} catch (java.lang.ArrayIndexOutOfBoundsException e) {
			System.out.println("数组指针越界异常！");// 数组指针越界异常!
		}
		System.out.println("程序结束！");// 程序结束
	}
}

方案二：多个异常的情况

try{

//多行代码，可能产生多种异常

}catch(异常类型1 变量名){

}catch(异常类型2 变量名){

}....

}catch(异常类型n 变量名){

}

注意：

1.在多catch语句中，"异常类型"可以是"平级关系"，也可以是"子父关系"；

2.如果是"子父类关系"，"父类类型的异常"一定要放在catch列表的末尾；

package cn.hebei.sjz_异常_多catch;

/*
 * 1、多catch语句中，”异常类型“可以是”平行关系“，也可以是”子父关系“；
 * 2、”异常类型“是”子父关系“，则”父类异常类型“必须放在catch列表的末尾。
 */
public class Demo {
	public static void main(String[] args) {
		int a = 10;
		int b = 0;
		int[] array = { 1, 2 };
		String s = null;
		try {
			System.out.println(a / b);
			System.out.println(array[2]);
			System.out.println(s.length());
		} catch (ArithmeticException e) {
			System.out.println("异常，除数不能为0");
		} catch (NullPointerException e) {
			System.out.println("空指针异常");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("数组指针越界异常");
		} catch (Exception e) {
			System.out.println("未知异常");
		}
		System.out.println("程序结束！");
	}
}

方案三：JDK7针对多个异常的处理方案
格式：

try{

//代码可能出现多种异常

}catch(异常类型1 | 异常类型2 | 异常类型3 e){

//几种异常的统一的处理方式

}

注意：

1.catch中的多个异常类型是"或"的关系，不能出现"父类异常类型"；

2.可以纵向的使用多个catch语句；

package cn.hebei.sjz_异常_针对多个异常的处理方案;
/*
 * JDK7针对多个异常的处理方案
 * 格式：
 * 		try｛
 * 			代码可能出现多种异常
 * 		｝
 * 		catch（异常类型1 | 异常类型2 | 异常类型3 ...）{
 * 				几种异常统一的处理方式
 * 		｝
 * 注意：1、catch语句中异常类型是“或”的关系，不能出现“父类异常类型”。
 * 		2、可以纵向的使用多个catch语句。
 */
public class Demo {
	public static void main(String[] args) {
		int a = 12;
		int b = 0;
		int[] array = { 1, 3 };
		String s = null;

		try {
			System.out.println(a / b);
			System.out.println(s.length());
			System.out.println(array[3]);
		} catch (ArithmeticException | NullPointerException
				| ArrayIndexOutOfBoundsException e) {
			if (e instanceof ArithmeticException) {
				System.out.println("异常，除数不能为0");
			}
			if (e instanceof NullPointerException) {
				System.out.println("空指针异常");
			}
			if (e instanceof ArrayIndexOutOfBoundsException) {
				System.out.println("数组角标越界异常");
			}
		} catch (Exception e) {
			System.out.println("未知异常");
		}
		System.out.println("程序结束");
	}
}

3、方法内处理异常：
<1>.throws:

1).用在方法的声明处；

2).throws后面跟的"异常类名"，可以有多个；

3).throws表示：此方法"可能"会产生此类型异常。如果产生异常，异常对象是由JVM产生；

4).声明抛出的异常类型：

1>.运行时异常：调用者可以不捕获；

2>.非运行时异常：调用者必须捕获(或者抛出);

<2>.throw:

1).用在方法体内；

2).throw后面跟的"异常对象"，只能有一个；

3).throw表示：抛出了一个"异常对象"。异常对象已经产生了(可以由程序产生，也可以由JVM产生)

4).抛出的异常类型：

1>.运行时异常：方法声明处可以不声明throws此类型异常；调用者也可以不捕获；

2>.非运行时异常：方法声明处必须声明throws此类型异常；调用者必须捕获；

4、finally关键字的特点及作用：

<1>.在异常异常处理过程中，我们有些代码可能需要必须被执行，无论是否发生异常；

例如：

try{

//打开文件；

//写入文件内容；(产生异常)

return xxx;

}catch(异常类型变量名){

//异常处理

}finally{

//无论是否发生异常，都会被执行的代码

//关闭文件；

}

<2>.Java提供了finally语句，表示：无论是否发生异常都会被执行的；

<3>.finally语句可以跟着try...

也可以跟着try...catch....

finally语句之后，不能再有catch语句了；

package cn.hebei.sjz_异常的常用方法;

/*
 * finally关键字
 */
public class Demo1 {
	public static void main(String[] args) {
		int a = 10;
		int b = 2;
		try {
			System.out.println(a / b);
		} finally {
			System.out.println("无论是否产生异常都会处理");
		}
	}
}

二、File类

1、File类的概述

文件和目录路径名的抽象表示形式

2、构造方法

public File(String pathname)：使用一个路径构造一个File(此路径可以是相对路径、绝对路径、文件路径、目录路径、可以存在，也可以不存在)

public File(String parent,String child):使用父目录名，子文件名构造一个File对象；

public File(File parent,String child)：使用代表父目录的File对象和子文件的String构造一个File对象；

package cn.hebei.sjz_File构造方法;

import java.io.File;

/*
 * File类的构造方法
 */
public class Demo {
	public static void main(String[] args) {
		File file = new File("C:\\aaa\\a.txt");// 绝对路径
		File file1 = new File("demo.txt");// 相对路径（项目根目录下）
		File file2 = new File("C:\\aaa", "a.txt");// 作用和file相同
		File file3 = new File("C:\\aaa");
		File file4 = new File(file3, "a.txt");// 跟file2和file相同
	}
}

3、File类的创建功能

public boolean createNewFile():创建文件(如果成功创建返回true，否则(文件已经存在)返回false)

public boolean mkdir()：创建单级目录

public boolean mkdirs()：创建多级目录

package cn.hebei.sjz_File创建;

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

public class Demo {
	public static void main(String[] args) throws IOException {
		//创建文件
		File file = new File("e:\\我的");
		try {
			System.out.println(file.createNewFile());
		} catch (Exception e) {
			e.printStackTrace();
		}
		//创建文件夹
		File file1 = new File("我的");
		System.out.println("创建文件夹：" + file1.mkdir());
		
		File file2 = new File(file1,"wode");
		System.out.println(file2.mkdir());
		
		
		//创建多级目录
		File file3 = new File("我的\\wode\\我\\的\\wo\\de");
		System.out.println(file3.mkdirs());
		
		
	}
}

4、File类的删除功能

public boolean delete():可以删除文件、可以删除目录(一定要是空目录)

package cn.hebei.sjz_File删除;

/*
 * 只能删除文件或单级目录
 */
import java.io.File;

public class Demo {
	public static void main(String[] args) {
		// 删除目录
		File file = new File("我的\\wode");
		System.out.println(file.delete());
		File file1 = new File("我的");
		System.out.println(file1.delete());
		// 删除文件
		File file3 = new File("e:\\我的.txt");
		System.out.println(file3.delete());

	}
}

5、File类的重命名功能

public boolean renameTo(File dest):将当前File对象，重命名到dest表示的路径下；

注意：

1.如果dest和原文件不在同目录下，重命名操作将会相当于"剪切"操作；

2.如果dest和原文件在同目录下，相当于"重命名"

package cn.hebei.sjz_File重命名;

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

/*
 * 重命名功能
 * 
 * public boolean renameTo(File dest):将当前File对象，重命名到dest表示的路径下；
 * 
 * 注意：
 * 1.如果dest和原文件不在同目录下，重命名操作将会相当于"剪切"操作；
 * 2.如果dest和原文件在同目录下，相当于"重命名"
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		try {
			File file = new File("e:\\个人\\作业\\wode");
			System.out.println(file.createNewFile());
		} catch (Exception e) {
		}

		// 重命名到当前路径下 相当于剪切
		File file = new File("e:\\个人\\作业\\wode.txt");
		File dest = new File("wode");
		System.out.println(file.renameTo(dest));

		// 在当前路径下重命名
		File file2 = new File("wode.txt");
		File dest2 = new File("zheshiwode.txt");
		System.out.println(file2.renameTo(dest2));
	}
}

6、File的判断功能

public boolean isDirectory():判断是否是一个目录；

public boolean isFile()：判断是否是一个文件；

public boolean exists()：判断文件/目录是否存在；

public boolean canRead()：判断是否可读；

public boolean canWrite()：判断是否可写；

public boolean isHidden()：判断是否隐藏；

package cn.hebei.sjz_file判断;

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

/*
 * File的判断功能
 */
public class Demo {
	public static void main(String[] args) {
		File file = new File("demo.txt");
		System.out.println("文件是否存在" + file.exists());
		// 创建文件
		if (!file.exists()) {
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		// 判断是否为目录
		System.out.println(file.isDirectory());
		// 判断是否为文件
		System.out.println(file.isFile());
		// File是否可读
		System.out.println(file.canRead());
		// File是否可写
		System.out.println(file.canWrite());
		// 判断是否隐藏
		System.out.println(file.isHidden());
	}
}

7、File类的基本获取功能

public String getAbsolutePath()：获取绝对路径

public String getPath()：获取File封装的路径

public String getName()：获取文件/目录的名称

public long length()：获取文件的大小(单位：字节)

public long lastModified()：最后修改时间(单位：毫秒)

package cn.hebei.sjz_file获取;

import java.io.File;

/*
 * File类的基本获取功能
 */
public class Demo1 {
	public static void main(String[] args) {
		File file = new File("demo01.txt");
		System.out.println("File的绝对路径：" + file.getAbsolutePath());
		System.out.println("File的封装的路径：" + file.getPath());
		System.out.println("文件名称：" + file.getName());
		System.out.println("文件大小：" + file.length() + " 字节");
		System.out.println("最后修改时间：" + file.lastModified() + " 毫秒");
	}
}

8、File类的高级获取功能

public String[] list():如果当前File表示的是一个目录，则返回此目录下所有的子文件/子目录的名称的String[]数组；

public File[] listFiles():如果当前File表示的一个目录，则返回此目录下所有的子文件/子目录的File[]数组；

区别：如果仅仅想获取文件名，使用第一种；

如果需要对子文件/子目录进行进一步的操作，可以使用第二种；

package cn.hebei.sjz_file获取;

import java.io.File;

/*
 * File类的高级获取功能
 */
public class Demo2 {
	public static void main(String[] args) {
		File file = new File("C:\\aaa");
		// 所有String[]数组
		String[] nameArray = file.list();
		for (String fileName : nameArray) {
			System.out.println(fileName);
		}
		// 所有File数组
		File[] fileArray = file.listFiles();
		for (File f : fileArray) {
			System.out.println((f.isDirectory() ? "目录" : "文件") + ":"
					+ f.getAbsolutePath());
		}
	}
}

三、递归

1.递归：方法可以调用本身，叫：方法的递归调用；

2.递归的注意事项：

1).递归必须要有出口，否则就是死递归；

2).递归的层次不能太深，否则堆栈溢出；

3).构造方法不能递归调用:编译错误

package cn.hebei.sjz_递归;

import java.io.File;

/*
 * 用递归遍历指定目录下的所有java文件
 */
public class Demo {
	public static void main(String[] args) {
		// 定义一个指定目录file
		File file = new File("e:\\个人\\20151018");
		listFiles(file);
	}

	// 递归方法
	private static void listFiles(File file) {
		// 列出文件和目录
		File[] arrFile = file.listFiles();
		// 判断是否为空
		if (file != null) {
			// 遍历文件和目录
			for (File f : arrFile) {
				// 判断是否为文件
				if (f.isFile()) {
					// 判断是否为java文件
					if (f.getName().endsWith(".java")) {
						// 是就输出绝对路径
						System.out.println(f.getAbsolutePath());
					}
				} else {// 是目录，再遍历
					listFiles(f);
				}
			}
		}
	}
}