java SE_5
异常（Exception）
1. Exception
-
java异常结构中定义有Throwable, Exception 和 Error 是其派生的两个子类。其中Exception表示由于网络故障，文件损坏，设备错误，用户输入非法等情况导致的异常，而Error表示java运行时环境出现的错误，例如jvm内存资源耗尽。
-
异常分为两种：
- 编译时异常（编译的时候，就需要处理这个异常。）
- 运行时异常。（RuntimeException ，运行的时候才会抛异常）
- 程序运行过程中，由某些特定操作引发的异常，被称为运行时异常。
-
异常出来就是当异常发生的时候妥善地终止程序，避免灾难性后果的发生，具体的操作通常包括:
-
通知：向用户通知异常的发生。
-
恢复：保存重要的数据，恢复文件， 回滚事务等
-
退出：以更好的方式结束程序的运行
-
-
测试：
public class ExceptionDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的操作：");
String s = scanner.nextLine();
double money = 5000; // 余额
System.out.println("你的余额：" + money);
try { // 尝试执行这个代码，代码执行可能会抛出异常。如果抛出异常，执行catch语句块。如果没有异常，就跳过catch语句块。
money -= 500; // 取钱
//String s = null; // java.lang.NullPointerException
s.charAt(0); // java.lang.StringIndexOutOfBoundsException
System.out.println("从ATM取出500块钱");
} catch (Exception e) {
money = 5000; // 取钱不成功，保证余额不变。
System.out.println("操作有误，取钱失败" + money);
}
System.out.println("余额：" + money);
}
}
2. try…catch
-
try{…}语句包裹了一段代码，该段代码就是捕获异常的范围。
-
在执行try语句块的过程中，该段代码可能会抛出一种或多种异常，catch语句块可以分别对不同的异常做处理。
-
如果try语句块没有发生，那么所有的catch语句都被忽略，不被执行。
-
测试：
class ExceptionDemo1 {
public static void main(String[] args) {
//这个异常就被抛出去，由于这里是main方法，这个异常就被抛给jvm, jvm就把异常的堆栈信息，打印到控制台。
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个整数：");
int result = 0;
try {
int x1 = sc.nextInt();
int x2 = sc.nextInt();
result = x1 / x2;
} catch (ArithmeticException e) {
e.printStackTrace();//提示自己，具体是什么异常，就可以参考这个异常，修改程序。
System.out.println("输入数据有误.");
}
System.out.println("result：" + result);
}
}
- catch语句块中是对异常处理的代码，针对不同的异常，可以写多个不同的catch语句块，但是只会执行其中的一个catch语句块。
- 当有多个catch语句的块的时候，应该先捕获小类型异常（子异常），再捕获大类型异常（父异常）；因为先捕获父异常，子异常就永远都执行不到，会出现报错；如果发生的异常没有被catch捕获到，就会抛出异常，从而终止操作。
- 测试：
class ExceptionDemo2 {
public static void main(String[] args) {
//***多个catch ,只会执行其中的一个catch语句块。
//这里发生的异常，没有被catch到，所有程序就抛出异常，后续代码无法执行。
try {
String s = null;
System.out.println(s.length()); // 空指针异常
int[] k = {1, 2, 3, 4};
System.out.println(k[k.length]); //数组越界异常
String s1 = "100a";
int b = Integer.parseInt(s1); // 格式化异常
} catch (NullPointerException e) {
System.out.println("空指针:" + e.getMessage());
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界:" + e.getMessage());
} catch (NumberFormatException e) {
System.out.println("数据格式化异常:" + e.getMessage());
} catch (RuntimeException e) {
System.out.println("运行时异常。" + e.getMessage());
} catch (Exception e) {
//Exception是所有异常类的父类。向上造型。 //但只能收到异常，但不能对异常分类
}
System.out.println("欢迎使用!");。
}
}
3. throw & throws
1.throw
-
当程序发生异常，不能处理的时候，会抛出对应的异常。
-
可以通过throw 语句 ，将异常抛出，那么被抛出的异常，可以让其他代码来捕获这个异常。如果需要自行抛出异常，需要使用“throw”关键字，并且要创建出抛出的异常类的对象。 throw new XXException();
-
测试：
//程序员可以使用throw主动抛出某个异常类型。
//语法规则:throw new XXException();
//定义方法的时候，可以选择使用throw抛出异常
class ExceptionDemo3 {
public static void main(String[] args) {
try {
String s = null;
s.length();
} catch (NullPointerException e) {
System.out.println(e.getMessage());
throw new NullPointerException(); // 抛出异常
}
/*
throw new NullPointerException ( ); //抛出异常
System.out.println("-----------"); //编译错误。throw之后的代码不能执行到。*/
}
2.throws
- 类中有很多方法，当在类中的方法中使用到了throw 语句抛出了异常，那么在这些方法的声明过程中，需要使用throws 关键字，声明该方法抛出的异常。
- 如果在方法声明的时候，使用throws抛出了异常，那么在调用方法的时候，就需要捕获异常，或者继续抛出异常。
class ExceptionDemo3 {
public static void main(String[] args) {
try {
setSex("男");
} catch (RuntimeException e) {
System.out.println("性别错误");
}
setSex("男生");
setSex("男生");
try {
int k = age(100); // age有编译期异常，需要捕获，或者继续抛出。
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
public static void setSex(String sex) {
if ("男生".equals(sex) || "女生".equals(sex)) {
System.out.println("这是一个:" + sex);
return;
}
throw new RuntimeException(); // RuntimeException--运行时异常。(编译的时候不管，运行的时候才检查。)
}
//人类的年龄
public static int age(int data) throws Exception { // throws-- 方法签名的时候使用， 可以抛出多个异常。
if (data > 120 || data < 0) {
// 使用了throw 抛出异常，就不需要return。
throw new Exception("年龄需要在0~120"); // Exception 包含了运行时异常和非运行时异常。
}
return data;// 正常的年龄。
}
public static int age(int data, String birth) throws Exception {
if (data > 120 || data < 0) {
//使用了throw抛出异常，就不需要return.
throw new Exception("年龄需要在0~120"); // Exception包含了运行时异常和非运行时异常。
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
sdf.parse(birth);
return data; //正常的年龄。
}
}
4. finally语句块
- finally语句为异常处理提供一个统一的出口，使得在控制流程转到其他程序其他部分之前，能够对程序的状态做统一管理。
- 无论try语句块中是否有异常，finally语句块的内容都会被执行。
- 通常在finally语句块中完成一些必须要执行的代码。比如： 文件的关闭，数据库的关闭等。
- 测试：
//--- try..catch ..finally : finally语句块的内容始终要执行。
public class ExceptionDemo4 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
try {
System.out.println("请输入一个字符串：");
String s1 = s.next();
System.out.println("请输入一个整数:");
int data = s.nextInt();
} catch (Exception e) {// 不知道异常的具体类型，所以使用向上造型
e.printStackTrace();
throw new RuntimeException();
} finally {
// ***保证正常和异常结束，都能执行到这个代码块。
System.out.println("进入fianlly .关闭流。。。。。");
s.close(); //输入流，流使用之后，需要关闭流。
System.out.println("流关闭了。。。。。");
}
//s.close();//输入流，流使用之后，需要关闭流。
System.out.println("程序结束");
int k = data();
System.out.println("k :" + k);
}
//finally相关的题目
// ** 在try..catch..fianlly一起时候的时候， try. ..catch中的return语句，也不能阻止finally代码块的运行。
public static int data() {
int a = 10;
try {
int k = 1;
int m = 10 / k;
a++;
return a; //如果没有finnally，程序到这里就结束了。但是这里有finally，return无效，就必须执行finally代码块。
} catch (ArithmeticException e) {
a++;
return a; //如果没有finnally，程序到这里就结束了。但是这里有finally，return无效，就必须执行finally代码块。
} finally {
a++;
return a;
}
}
}
5. 自定义异常类
- 程序员可以自定义异常，解决自己程序中的一些特定内容： class GenderException extends Exception{ // 重写异常类的方法 }
- 测试
// *** :主要使用super ()调用父类的构造器函数，使用super .方法名调用父类的方法。
public class ExceptionDemo5 {
public static void main(String[] args) {
try {
throw new GenderException("Hello");
}catch (GenderException e) {
System.out.println(e.getMessage()); // 输出创建对象的事哈，传入的字符串。
e.printStackTrace(); // 打印堆栈信息。
}
}
}
//编译时异常（编译的时候，就需要处理这个异常。）
class GenderException extends Exception {
//1.定义构造函数
public GenderException() {
}
public GenderException(String msg) {
super(msg);
}
//2.重写普通方法
@Override
public String getMessage() {
return super.getMessage(); // 调用父类的方法
}
@Override
public void printStackTrace() {
super.printStackTrace(); // 调用父类的方法
}
}
//运行时异常。（运行的时候才会抛异常）
class GenderException1 extends RuntimeException {}
6. 重写的异常处理
-
如果父类的方法抛出了异常，那么子类重写父类的时候，异常可以如下处理：
- a.不处理异常（重写的时候，不抛出异常）
- b.可以只抛出部分异常
- c.可以抛出异常的子异常
- d. 抛出其他运行时异常
-
但是不可以如下操作：
- a.重写的时候抛出父类方法没有抛出的非运行时异常。
- b.重写的时候抛出父类没有抛的Exception
-
测试
import java.text.ParseException;
public class ExceptionDemo6 {
}
class A {
public void print() throws ParseException, ArithmeticException {
}
}
class B extends A {
/* 可以自己抛出，运行时异常。
public void print1 ( ) throws NullPointerException{
}
不可以自己抛出非运行时异常。
public void print1 ( ) throws ParseException{
}
不可以自己抛出非运行时异常。
public void print1 ( ) throws ParseException{
}*/
/*//子类和父类抛出一样异常。
public void print() throws ParseException {
super.print();
}*/
/*//父类的方法抛出异常，子类选择不抛异常。
public void print() {
}*/
/*抛出了其他运行时异常。
public void print() throws NullPointerException{
}*/
/*
抛出子异常
public void print( ) throwsE{}*/
/*
抛出子父类方法的部分异常
public void prlint(Ithrows ParseException{}
*/
/*
抛出子父类方法的部分异常
public void print ( ) throws NumberFormatException{}
*/
/*编译错误:重写的时候抛出父类没有抛的Exceptionpublic void print( ) throws Exception{
}*/
/*重写的时候抛出父类方法没有抛出的非运行时异常。//编译错误
public void print ( ) throws ParseException{
*/
}
class E extends ParseException {
public E(String s, int errorOffset) {
super(s, errorOffset);
}
}
7. File(文件或目录)
- java.io.File用于表示文件(目录)，程序员可以通过File类在程序中操作硬盘上的文件或目录。
- File类只用于表示文件(目录)的信息(大小，名称等)，不能对文件内容进行访问构造器函数：File(String path)
- 常用方法测试
//File . jdk提供的类，可以表示目录或文件
public class FileDemo1 {
public static void main(String[] args) throws IOException {
//1.创建对象
File file = new File("E:\\Desktop");// 目录
File file1 = new File("E:\\Desktop\\ExceptionDemo3.java");//文件
//2.是否是目录，是否是文件。
System.out.println(file.isDirectory());// true
System.out.println(file1.isFile());// true
//3．找到file1的名字—文件名
System.out.println(file1.getName()); // --文件名
System.out.println(file1.getAbsolutePath()); // --Absolute : 绝对路径。(包含盘符)
//练习:找到file1的后缀名
if (file1.isFile()) {
String fname = file1.getName();
String suffix = fname.substring(fname.lastIndexOf(".") + 1);
System.out.println("后缀名:" + suffix);
} else {
System.out.println("没有后缀名");
}
//使用其他方法:
System.out.println(file1.canRead()); //读
System.out.println(file1.canWrite());//写
System.out.println(file1.canExecute()); //执行
System.out.println(file1.length()); // 41362--字节
//System.out.println(file1.delete());//删除(true-真删除了，false -删除失败)
System.out.println("存在:" + file1.exists());
if (file1.exists()) {//不存在就创造。
boolean newFile = file1.createNewFile();
}
// mkDir ( ) --创建文件夹
//练习:在桌面上，创建一个叫a的文件夹，然后在a文件夹中，创建一个叫)b .txt的文件。
File file2 = new File("E:\\Desktop\\a");
if (!file2.exists()) {
boolean newDir = file2.mkdir();
System.out.println("创建文件夹:" + newDir);
}
File file3 = new File("E:\\Desktop\\a\\b.txt");
if (!file3.exists()) {
boolean newFile = file3.createNewFile();
System.out.println("创建文件:" + newFile);
}
long l = file3.lastModified();
Date d = new Date(l);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("修改时间:" + sdf.format(d));
}
}
- 文件夹中的文件
//**子文件
public class FileDemo2 {
public static void main(String[] args) {
//输出卓面的文件
File file = new File("E:\\Desktop\\");
String[] list = file.list();
System.out.println(Arrays.toString(list));
//File中重写了toString
File[] files = file.listFiles();
System.out.println(Arrays.toString(files));
//遍历数组: 在桌面的文件中,统计出文件的个数,文件夹的个数
int wenJian = 0;
int wenJianJia = 0;
for (File f : files) {
if (f.isFile()) {
wenJian++;
System.out.println("文件--" + f);
} else if (f.isDirectory()) {
wenJianJia++;
System.out.println("文件夹--" + f);
}
}
System.out.println("文件有:" + wenJian + "个" + "文件有夹:" + wenJianJia + "个");
}
}
-
递归查看文件和删除文件
-
定义一个工具类FileUtils , 封装一个删除指定目录中的所有文件的方法。
-
定义一个工具类FileUtils , 封装一个查看指定目录中的所有文件的方法。
-
测试
-
import java.io.File;
/*
工具类: 所有的方法是静态的.
*/
public class FileUtils {
//查看指定文件中的所有文件
public static void seeFile(File file) { // File -- 可能是文件夹,可能是目录
if (file.isDirectory()) {
File[] files = file.listFiles(); // 找到该目录下的所有文件们
for (File f : files) {
seeFile(f); // 递归, 调用自己.
}
} else {
System.out.println(file.getAbsolutePath());
}
}
public static void deleteFile(File file) {
if(file.isFile()){ // 是文件
file.delete(); //删除文件
}else{ // 是文件夹
File[] files = file.listFiles();
for (File f : files) {
deleteFile(f); //清空文件夹
}
file.delete(); //文件夹以清空,删除此文件夹
}
}
}
class Test {
public static void main(String[] args) {
File file = new File("E:\\Desktop\\test");
FileUtils.seeFile(file);
FileUtils.deleteFile(file);
}
}
8. review
1. final, finally, finalize的区别?
-
final可以修饰类，变量，方法，修饰的类不能被继承，修饰的变量不能重新赋值，修饰的方法不能被重写。
-
finally用于抛异常，finally代码块内语句无论是否发生异常，都会在执行finally，常用于一些流的关闭。
-
finalize是一个方法（JDK高版本中不建议使用） ， 属于Object类中的方法，这个方法由垃圾回器调用 ，当我们调用System.gc()的时候 ,由垃圾回收器调用finalize() , 判断这个对象是否可回收。
2. throw , throws 的区别
- throws用于函数声明异常，可以指定多个异常类；throw用于函数内部，抛出具体异常对象。
- throws声明异常可能出现的问题；throw抛出具体问题对象，功能结束并将其传递给调用者。
- throws表示异常可能性，throw则一定抛出异常对象。
- 最后，两者都是消极处理异常的方式，由上层调用函数来处理异常。
3. 常见异常（编译时异常）
-
IOException：（IO异常）I/O操作异常，读写文件可能出现。
-
ParseException：（解析异常）在解析日期、时间等字符串时，如果格式不符合要求，就会抛出此异常。
-
ClassNotFoundException:（类找不到异常）当尝试加载类的时候，如果类不存在，就会抛出此异常。
-
FileNotFoundException: （文件找不到异常）当尝试打开指定文件路径时，如果文件不存在，就会抛出此异常。
-
NullPointerException: （空指针异常）当尝试访问空对象的属性或方法时，会抛出此异常。
-
ArithmeticException: （算术异常）当发生数学运算错误时，如除数为0，会抛出此异常。
-
ClassCastException: （类型转换异常）当发生类型转换错误时，会抛出此异常，例如试图将一个不兼容的对象强制转换为某个类型。
-
ArrayIndexOutOfBoundsException: （数组下标越界异常）数组索引越界异常，当尝试访问数组中不存在的索引时，会抛出此异常。
-
StringIndexOutOfBoundsException: （字符数组下标越界异常）当字符串索引越界时，会抛出此异常
-
NumberFormatException: （字符串无法转换为数字异常）当字符串无法转换为数字时抛出
-
NoSuchMethodException:（没有该方法异常）当访问一个不存在的方法是抛出，例如通过反射调用一个不存在的方法。
-
SQLException:（SQL异常）在执行SQL查询或操作时发生错误
-
IndexOutOfBoundsException:（索引越界异常）当访问集合、数组或字符串等数据结构时，使用了不存在的索引位置时抛出
1146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
