day18
- 异常
1.1 异常的概述
异常: 程序在执行的过程中,发生问题,不符合实际运行场景,程序中出现了错误,称为异常
异常在Java中,JDK将异常封装成了一些异常的类,当异常发生时,创建一个异常的类对象,表示一种异常情况,对象中描述了异常的发生情况,异常的具体信息,代码的错误的地点
异常处理: 代码中可以针对异常进行处理, 抛出异常,声明异常,捕获异常,代码终止…
1.2 异常的体系
Throwable : 所有的Error错误和Exception异常的父类,来自 java.lang.Throwable
– Error : 错误,表示严重的错误,在代码中无法进行处理,只能修改代码
–Exception : 异常,表示不太严重的错误,在代码中可以避免,也可以进行处理
– RuntimeException : 运行时异常,代码中如果发生了运行时异常,代码不需要做任何的异常的声明或者是处理,就让它发生.Java系统定义,如果发生了RuntimeException,代码没有继续向下执行的必要,想让代码停止
–编译异常 : 编译异常出现,eclipse会提示,必须进行处理或者异常声明
1.3 JVM默认处理异常机制
代码
package com.zgjy.exception;
public class ExceptionJVM处理 {
public static void main(String[] args) {
int[] arr = {1,2,3};
getArr(arr);
System.out.println(“main方法执行完毕”);
}
public static void getArr(int[] arr) {
int i = arr[5];
System.out.println(i);
System.out.println(“获取数组元素成功”);
}
}
1.4 异常的手动处理
- 异常声明(throws): 指代码中发生了异常,没有真正的处理异常,只是将异常的信息再方法上进行了声明,提醒方法的调用者,方法可能是会有异常发生的方法. 目的就是为了让方法的调用者进行的提前把控和处理
举例: 大门,贴了标语: 内有恶犬 - 异常的处理: 指异常的捕获机制,将异常获取到,处理异常,处理完毕,代码还能继续运行
1.5 throw关键字
throw : 表示异常的抛出
使用场景: 代码中发生了一些不符合正常流程的场景,你可以将这些场景发生时会出现的错误,通过throw关键字抛出,throw关键字先创建一个异常对象,然后抛出异常对象信息到方法的调用者处
throw关键字的定义方式:
throw new Exception或者Exception中任何一个子类();
说明:
- throw关键字写在方法的内部
- throw后创建一个异常对象
- throw每次只能创建出一个对象,只能抛出一个异常
- 一个方法内部,可以使用多次的throw关键字进行异常的抛出
- 方法执行到throw关键字抛出异常后,方法中的代码不再继续执行
代码
package com.zgjy.exception;
public class ThrowExceptionDemo {
public static void main(String[] args) {
//int[] arr = null;
int[] arr = {1,2,3};
getArr(arr);
}
public static void getArr(int[] arr) {
/*
* 方法参数是int[] arr
* 1. arr 为 null NullPointerException
* 2. arr length ----- 0 ArrayIndexOutOfBoundsException
* 3. arr length ------ 6
*
* */
if( arr == null ) {// 错误场景,可以抛出异常
// 异常的构造方法中 ,带有String类型字符串的构造
// 将异常的信息输出到控制台上
// 异常的抛出后,方法中的代码不再向下执行
throw new NullPointerException("数组不能为null");
}
if( arr.length < 6 ) {
throw new ArrayIndexOutOfBoundsException(“数组长度小于6,不能获取到对应的索引元素”);
}
int u = arr[5];
System.out.println(u);
System.out.println(“获取到了数组中的元素”);
}
}
1.6 throws关键字
throws : 表示异常的声明
使用场景: 方法内部发生了异常
- 运行时异常(RuntimeException): 在方法内部发生,可以不用异常的声明和处理,有可以进行异常的声明和处理
- 编译异常: 在方法内部发生,一定需要处理或者将异常在方法上面进行声明
throws声明异常的方式:
修饰符 返回值类型 方法名(参数列表) throws 异常类型1,异常类型2…{
方法功能;
}
代码
package com.zgjy.exception;
import java.io.FileNotFoundException;
public class ThrowsExceptionDemo1 {
public static void main(String[] args) throws FileNotFoundException{
int[] arr = {1,2,3};
// getArr(arr);
// main方法调用了带有编译异常的方法,需要进行异常的声明或者处理
getFile("C:\\a.txt");
}
// 方法内部抛出的是编译异常: 必须进行声明或者处理
// 方法内部抛出什么异常,在方法上声明神什么异常
// throws 声明之后的功能: 提示方法的调用者,方法有可能会出现异常问题,需要提前进行提示
// 好使得调用者提前进行处理和把控
public static void getFile(String s) throws FileNotFoundException{
if(!s.equals("D:\\a.txt")) {
throw new FileNotFoundException("文件D:\\a.txt不存在");
}
}
// 方法内部抛出的是运行时异常:不需要声明和处理
public static void getArr(int[] arr) throws NullPointerException,ArrayIndexOutOfBoundsException{
/*
* 方法参数是int[] arr
* 1. arr 为 null NullPointerException
* 2. arr length ----- 0 ArrayIndexOutOfBoundsException
* 3. arr length ------ 6
*
* */
if( arr == null ) {// 错误场景,可以抛出异常
// 异常的构造方法中 ,带有String类型字符串的构造
// 将异常的信息输出到控制台上
// 异常的抛出后,方法中的代码不再向下执行
throw new NullPointerException("数组不能为null");
}
if( arr.length < 6 ) {
throw new ArrayIndexOutOfBoundsException(“数组长度小于6,不能获取到对应的索引元素”); }
int u = arr[5];
System.out.println(u);
System.out.println("获取到了数组中的元素");
}
}
1.7throw 和 throws关键字的区别
-
功能不同 :
throw : 表示抛出异常
throws : 声明异常 -
定义位置不同 :
throw 定义在方法内部
throws 定义在方法上 -
定义的内容不同 :
throw 每次创建并且抛出一个异常
throws 可以声明多个异常 -
代码执行到throw关键字,证明一定会有一个异常发生
代码执行到throws关键字,throws只做异常的声明,异常不一定会发生
1.8异常的处理机制
try…catch
try…catch…finally
try…finally
1.8.1 try…catch异常处理方式
语法格式:
try{
// 可能会发生异常的代码
}catch(可能发生的异常类型 异常名){
// 针对异常的处理方式
}
说明:
- try : 检测,检测代码是否发生了异常,如果发生异常,抛出给catch
- catch : 捕获,捕获异常,获取try代码块中可能会发生的异常
- catch后面的小括号: 写的是try代码块中可能会发生的异常类
- catch的大括号中,写明了针对于异常的处理方式: 可以写任何逻辑
try…catch的执行过程:
- 执行try代码块中的内容
- try中没有发生异常,catch代码块不执行,整个try…catch结束,代码继续运行
- try中发生了异常,try会检测异常,检测到异常后,将异常抛出,抛给catch进行异常捕获,
- catch小括号中定义的异常类型与try中发生的异常类型匹配,捕获住异常,执行catch中大括号里面的内容
- catch小括号中定义的异常与try中发生的异常类型不匹配,catch无法捕获住异常,JVM进行异常的默认处理机制
- 如果catch中大括号执行完毕,代码继续执行,接着try…catch语句之后继续执行
代码
package com.zgjy.exception;
public class TryCatchDemo {
public static void main(String[] args) {
int[] arr = {1,2,3};
try {
getArr(arr,4);
System.out.println("try执行完毕");
}catch(ArrayIndexOutOfBoundsException ex) {
System.out.println("我catch执行了");
}
System.out.println("main方法执行结束");
}
public static void getArr(int[] arr,int x) {
if( arr.length <= x) {
// throw将异常抛给了方法的调用者main
// throw执行后,getArr方法后面的所有代码不再执行
throw new ArrayIndexOutOfBoundsException("数组长度不够");
}
int i = arr[x];
System.out.println(i);
}
}
1.8.2 多catch异常处理方式
语法结构:
try{
// 可能会发生异常的代码
}catch(可能发生的异常类型1 异常名1){
// 异常1的处理方式
}catch(可能发生的异常类型2 异常名2){
// 异常2的处理方式
}…
说明:
- try代码块中,可能发生多个异常
- 那就需要catch捕获多个异常,写出多个catch语句,每一个catch语句,捕获一个异常
多catch的执行过程:
- 如果try代码块中没有发生异常,多个catch代码块都不执行,代码顺序运行
- 如果try中发生了异常,try将异常抛出,抛给catch代码块进行捕获,从上到下进行catch异常的匹配,如果匹配到了一个符合的catch,执行对应catch中的异常处理逻辑,其他的catch都不再匹配运行
- catch代码块执行结束,整个try…catch都结束,代码从try…catch之后继续执行
- 如果多个catch中的异常类型与try中抛出的异常类型都不匹配,没有将异常捕获住,需要JVM进行异常的默认处理机制(停止代码)
注意:
- 多catch中,如果捕获的多个异常之间具有子父类的继承关系,就要求,父类的异常必须要在子类异常之后进行捕获,否则代码提示错误,错误原因是因为: 通过多态的表达式,父类异常可以捕获到所有的子类异常,于是下面的子类异常永远没有使用的场景,因此报错
- 可以使用一个父类的Exception捕获住所有的异常情况,因此catch可以只写捕获一个Exception即可
代码
package com.zgjy.exception;
public class MoreCatchException {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
//int[] arr = null;
try {
getArr(arr,-5);
}
/*catch(ArrayIndexOutOfBoundsException ex) {
ex.printStackTrace();
System.out.println(“我捕获到了一个越界异常”);
}catch(NullPointerException ex) {
System.out.println(“我捕获到了一个空指针异常”);
}*/
catch(Exception ex) {// Exception ex = new NullPointerException("数组不能为null")
System.out.println("捕获到一个大哥异常");
}
}
public static void getArr(int[] arr,int x) throws Exception{
if(arr == null) {
throw new NullPointerException("数组不能为null");
}
if( arr.length <= x) {
// throw将异常抛给了方法的调用者main
// throw执行后,getArr方法后面的所有代码不再执行
throw new ArrayIndexOutOfBoundsException("数组长度不够");
}
if( x < 0 ) {
// 代码中抛出了一个父类异常,包含了运行时异常和编译异常,一定需要处理
throw new Exception("索引值不能大于0");
}
int i = arr[x];
System.out.println(i);
}
}
1.8.3 try…catch…finally异常处理方式
语法结构:
try{
// 可能会发生异常的代码
}catch(可能会发生的异常类型 异常名){
// 异常的处理
}…finally{
}
说明:
- finally : 一定会执行的,不论执行的是try代码块或者是catch代码块,finally都一定会执行
如果在执行finally之前,停止虚拟机finally也不会执行(停止虚拟机后,所有代码都不执行了) - 如果有一定需要执行的代码,请你讲代码写到finally中,例如: IO流关闭资源,一定要做的,放置在finally中
- try…catch…finally语法结构中,如果try或者catch中有return语句,在执行return语句之前,先检测,是否有finally,如果有finally,先执行finally中的语句,然后再通过return结束方法
代码
package com.zgjy.exception;
public class TryCatchFinallyDemo {
public static void main(String[] args) {
int[] arr = {1,2,3};
getArr(arr,1);
}
public static int getArr(int[] arr,int x) {
try {
int i = arr[x];
System.out.println("i的值为:"+i);
return i;
} catch (Exception e) {
// 打印异常信息
e.printStackTrace();
}finally {
System.out.println("finally已经执行了");
}
return 0;
}
}
1.8.4 try…finally语法结构
语法格式:
try{
// 可能发生异常的代码
}finally{
// 一定会执行的代码
}
说明:
- 无论try中是否有异常,finally一定会执行
- 没有catch语句,不能进行异常的捕获,如果try代码块中发生异常,只能通过LVM默认的异常处理机制异常处理
代码
package com.zgjy.exception;
public class TryCatchFinallyDemo {
public static void main(String[] args) {
int[] arr1 = null;
// 严格意义上try...finally不属于异常的处理
try {
getArr2(arr1);
}finally {
System.out.println("finally一定执行");
}
System.out.println("main方法执行结束");
}
public static void getArr2(int[] arr) {
if( arr == null) {
throw new NullPointerException("数组不能为空");
}
System.out.println(arr[2]);
}
}
1.9 常用的异常信息输出
在通过try…catch语句进行异常的处理,catch中通常都是需要将异常信息打印出来
Throwable 类中,有方法,进行异常信息的打印
- getMeassage() : 打印异常的简短信息,返回值类型String类型
- toString() : 打印出异常类和异常信息(比getMessaeg信息更加明确),返回值类型String
- printStackTrace() : 将异常的详细信息进行输出,实际开发使用比较多,返回值类型 void
代码
package com.zgjy.exception;
public class Exceptiontest {
public static void main(String[] args){
// 前台数据: 客户姓名 客户密码
// 从数据库中获取到客户姓名 : admin
// 从数据库中获取到用户密码 : 123
// 前台传输的数据 : String admi String 123
/*if(!“admin”.equals(“admi”)) {
throw new Exception(“用户名输入错误”);
}
if(!"123".equals("123")) {
throw new Exception("用户密码输入错误");
}*/
try {
getArr();
}catch(Exception ex) {
// 1. 打印异常信息
/*String s = ex.getMessage();
System.out.println(s);*/
/* 2. toString
* String s = ex.toString();
System.out.println(s);*/
// 3. 打印异常的完整信息
ex.printStackTrace();
}
System.out.println("----");
}
public static void getArr() throws Exception{
int[] arr = null;
if( arr == null ) {
throw new Exception("shuzu不能为null");
}
}
}
1.10 自定义异常
自己定义一个类,这个类是一个异常类
为什么要定义异常类: JDK中异常很多,但是有一些异常情况JDK没有给出,例如: 数字正负数问题
自定义异常实现步骤:
- 定义一个类,JDK中的异常都是使用Exception为结尾,以Exception为结尾
- 自定义类需要继承Exception类或者RuntimeException,就是一个异常的子类
- 继承Exception ,那么自定义的类就是一个编译异常类,要求发生编译异常,代码必须要声明或者是处理
- 继承RuntimeException, 那么自定义类就是一个运行时异常类,发生时,不需要进行处理和声明
- 在类中写出构造方法,带有String类型参数的构造方法; 顺便将空参数构造方法添加上
代码
package com.zgjy.exception;
// 自定义的异常类
public class MyException extends Exception{
public MyException() {
}
public MyException(String s) {
// 调用父类Exception中的构造方法,带有一个String类型的参数
// 异常在进行抛出时,就能将s所输入的字符串打印出来
super(s);
}
}
package com.zgjy.exception;
public class TestMyException {
public static void main(String[] args) {
try {
getArr();
} catch (MyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(“自定义异常测试成功”);
}
public static void getArr() throws MyException{
int[] arr = null;
if(arr == null) {
throw new MyException("数租不能为空");
}
}
}
- File类
2.1 File类的概述
File类: 表示一个文件或者是一个文件夹的径路的类,来自java.io.File
路径: 能确定一个文件或文件夹具体位置的一个字符串,D:\0708Java系统班\day18\笔记
实际代码中,需要针对系统中文件或文件夹做操作
举例: 新增一个文件;新增文件夹,删除文件… 查看一下文件夹下都有哪些文件
路径分类:
- 绝对路径: 带有根目录的路径,没有二义性的路径
Windows操作系统中, 带有盘符的路径 D:\0708Java系统班\day18\笔记
Linux操作系统,带有/开头 - 相对路径: 相对某一个路径来说,不是一个具体的路径
a/a.txt
eclipse中,相对路径的文件,求取绝对路径: 当前项目工程的根目录
D:\0708Workspace\day18\a\a.txt (可能这个路径是不存在的)
2.2 File类构造方法
- File(String path): 将一个String类型的路径转换成一个File类对象
- File(String parten,String child) : 将parten+child 拼接成一个完整字符串,再转换成File类对象
- File(File parten,String child) : 将File文件对象和String文件路径,转换成一个File对象
代码
package com.zgjy.file;
import java.io.File;
public class FileConstructor {
public static void main(String[] args) {
// 1. File(String path)
File file = new File(“D:\a”);
System.out.println(file);// D:\a ---- 文件
// 2. File(String p,String c)
File file2 = new File("D:\\", "eclipse.exe");
System.out.println(file2);// D:\eclipse.exe
// 3. File(File p,String child)
File file3 = new File(file, "JDK.zip");
System.out.println(file3);// D:\a\JDK.zip
}
}
2.3 File类中的创建方法
- createNewFile(): 当File所表示的文件不存在是,创建一个文件,路径和文件名就是File中内容,创建一个空的文件,返回值类型boolean类型,创建成功返回true.否则返回false
- mkdir() : 创建一个文件夹路径,只能创建一层文件夹
- mkdirs(): 可以同时创建多级的文件夹路径,返回值类型boolean,创建成功返回true,否则返回false
代码
package com.zgjy.file;
import java.io.File;
import java.io.IOException;
public class FileCreate {
public static void main(String[] args) throws IOException {
File file = new File(“D:\aa\hello.txt”);
boolean b = file.createNewFile();
System.out.println(b);
File file2 = new File("D:\\aa\\b\\c");
boolean b1 = file2.mkdirs();
System.out.println(b1);
}
}
2.4 File类的删除功能
delete() : 将File文件所表示的文件路径进行删除,返回值类型boolean,删除成功返回true,否则返回false ; delete不走回收站,直接将文件删除掉
- 删除一个文件
- 删除一个文件夹: 如果文件夹是空,可以删除成功;如果文件夹中还有别的文件或者文件夹,删除失败
代码
package com.zgjy.file;
import java.io.File;
public class FileDelete {
public static void main(String[] args) {
File file = new File(“D:\aa\hello.txt”);
// 1. 删除一个文件
boolean b = file.delete();
System.out.println(b);
// 2. 删除一个文件夹
//1) 文件不为空
File file1 = new File("D:\\aa");
boolean b2 = file1.delete();
System.out.println(b2);//false
//2) 删除一个空的文件夹
File file2 = new File("D:\\aa\\b\\c");
boolean b3 = file2.delete();
System.out.println(b3);// true
}
}
2.5 File类的修改功能
renameTo(File f) : 修改File文件的路径名称为f所表示的路径,返回值类型boolean,修改成功返回true,否则返回false
- file文件与参数f的路径一致,只是名称不一致,renameTo就相当于修改文件名
- file文件与参数f的路径不同,相当于先做剪切到f的路径下,再进行重命名
代码
package com.zgjy.file;
import java.io.File;
public class FileRename {
public static void main(String[] args) {
/File f = new File(“D:\aa\b\new.txt”);
// renameTo : 修改文件的路径名称
// 1) 修改后的文件路径与原文件路径保持一致,改文件名
boolean b = f.renameTo(new File(“D:\aa\b\old.txt”));
System.out.println(b);/
// 2) 修改后的路径与源文件路径不一致,相当于剪切文件后再重命名
File f1 = new File("D:\\aa\\b\\old.txt");
boolean b = f1.renameTo(new File("D:\\where.txt"));
System.out.println(b);
}
}
2.6 File类的判断功能
- isFile() : 判断当前的File文件所表示的路径是不是一个文件类型,返回值boolean类型,是文件返回true,否则返回false
- isDirectory() : 判断当前的File文件所表示的路径是不是一个文件夹(目录)类型,返回值boolean类型,是文件夹返回true,否则返回false
- exists(): 判断File文件所表示的路径是否真实存在的,返回值boolean类型,存在返回true,不存在返回false
代码
package com.zgjy.file;
import java.io.File;
public class FilePanDuan {
public static void main(String[] args) {
// 定义一个文件路径
File file = new File(“D:\where.txt”);
// 1. 判断file是否是一个文件
boolean b = file.isFile();
System.out.println(b);// true
// 2. 判断file是否是一个文件夹(目录)
System.out.println("++++文件夹判断结果: "+file.isDirectory());//false
// 3. exists() : 判断file文件是否存在
System.out.println("-----文件存在判断:"+file.exists());// true
// 定义一个文件夹路径
File file1 = new File("D:\\aa");
boolean b1 = file1.isFile();
System.out.println(b1);// false
System.out.println("++++文件夹判断结果: "+file1.isDirectory());//true
File file2 = new File("H:\\aa");
System.out.println("-----文件存在判断:"+file2.exists());// false
}
}
2.7 File类的获取功能
- getAbsolutePath(): 表示获取File文件对象的绝对路径,返回值类型是String类型
- 如果File文件本身就是表示的是一个绝对路径,直接将路径转换成字符串输出
- 如果File文件表示一个相对路径,将当前项目工程根目录作为父路径拼接到相对路径前面(拼接后的这个文件路径不存在)
- getPath(): 获取File文件的路径,返回值类型String类型,File文件中写的什么路径就转换成对应的String类型
- getName() :获取File文件对象最后那一部分名称(文件或者是文件夹的名称)
- list() : 将File文件所表示的路径下的所有的文件和文件夹获取到,以String类型的字符串的方式获取到,返回值类型是String[]
- listFiles():将File文件所表示的路径下的所有的带有绝对路径的文件和文件夹获取到,以File类型的文件的方式获取到,返回值类型是File[]
- length(): 求文件内容的大小,结果字节表示
- 只能衡量文件的大小,不能衡量文件夹的大小
代码
package com.zgjy.file;
import java.io.File;
public class FileGet {
public static void main(String[] args) {
// 绝对路径文件类型,在Windows系统中,带有盘符的文件
File file = new File("D:\\where.txt");
// 1. getAbsolutePath() : 获取文件绝对路径
String abPath = file.getAbsolutePath();
System.out.println(abPath);// D:\where.txt
// 相对路径文件,路径并不具体
File file1 = new File("where.txt");
String abPath1 = file1.getAbsolutePath();
// 2)如果File文件表示一个相对路径,
// 将当前项目工程根目录作为父路径拼接到相对路径前面(拼接后的这个文件路径不存在)
System.out.println(abPath1);// D:\0708Workspace\day18\where.txt
// 2. getPath():
String path = file.getPath();
System.out.println(path);//D:\where.txt
String path2 = file1.getPath();
System.out.println(path2);//where.txt
// 3. getName():
File file2 = new File("D:\\aa\\b");
// 获取文件的名字
System.out.println(file.getName());// where.txt
// 获取文件夹名字
System.out.println(file2.getName());//b
System.out.println("---------");
//4. list():
File file3 = new File("D:\\Develop\\Java\\jdk1.8.0_191");
String[] ss = file3.list();
for(String f : ss) {
System.out.println(f);
}
System.out.println("+++++++++");
File[] ff = file3.listFiles();
for(File f : ff) {
System.out.println("****"+f);
}
}
}
2.8 File类在实际开发中的使用(扩展)
场景: 系统中每日都需要对账
你与谁对账: 1) 你所在的系统,数据库中存储交易的流水(每一笔的交易金额)信息,计算出来
2) 核心系统,就专门账务处理,划账都由核心系统完成
对账过程:
- 对账时间,3:15对账
- 怎么进行对账: 核心3:15之间将一个txt文件放置到系统的指定文件夹目录下
D:\compare\core.txt
读文件之前:
- 先判断文件是否存在 exists()
- 如果文件存在,判断文件大小 length() > 0 有文件了,有内容
- 到了3:15,你的系统.到指定路径下将文件下载下来(IO流读下来)
场景2: 你需要给其他系统提供文件
卖产品,网上银行销售,需要将产品信息以txt的形式,每天都同步给网上银行端
- 每天指定的时间 8:00 ,上传文件(IO写)
- 将文件放置在与网上银行商定好的一个指定路径下
- 判断指定路径是否存在 exists(),
- 不存在, 创建路径 mkdirs
- 没有文件存在,先创建文件 createNewFile
- 通过IO流写文件内容
扫一扫
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
