2020-08-13

最新推荐文章于 2020-09-19 13:35:53 发布

鹿秀儿

最新推荐文章于 2020-09-19 13:35:53 发布

阅读量140

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_49331059/article/details/107985053

版权

笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

IO流

IO流概述及其前奏

IO流概述

IO流用来处理设备之间的数据传输
上传文件和下载文件

IO流前奏

File表示的是IO流将要操作的文件，所以先要学习File类
在常见的操作文件（上传文件和下载文件）的过程中可能出现问题，我们需要对应的代码进行处理，所以要学习异常

异常

异常的概述和分类

异常的概述

异常就是java程序在运行过程中出现错误

异常的分类

运行期异常：可以选择解决或不解决
Error：无法解决
编译器异常：必须解决，不解决不能运行

异常的继承体系

异常的基类：Thorwable

严重问题：Error，不予处理，因为这种问题一般是很严重的问题，例如：内存溢出
非严重问题：Exception

编译时异常：非RuntimeException

运行期异常：RuntimeException

JVM默认是如何处理异常的

JVM默认是如何处理异常的

main函数收到这个问题时，有两种处理方式：

自己将该问题处理，然后继续运行
自己没有针对的处理方式，只有交给调用main的jvm来处理

jvm有一个默认的异常处理机制，就将该异常进行处理，并将该异常的名称，异常的信息，异常出现的位置打印在了控制台上，同时将程序停止运行

public class MyTest {
    public static void main(String[] args) {
        //JVM默认处理异常的方式
        int a=0;
        int b=7;
        System.out.println(b / a);
        System.out.println("这个不重要");
        System.out.println("这个也不重要");
        /*Exception in thread "main" java.lang.ArithmeticException（除数为0的异常）: / by zero
        at study.luxiuer.demo.MyTest.main(MyTest.java:11)*/
    }
}

try…catch的方式处理异常1

异常处理的两种方式

try…catch…finally
throws

try…catch处理异常的基本格式

try {

可能出现问题的代码；

}catch （异常名变量名）{

针对问题的处理；

}finally{

释放资源；

}

变形格式

try {

可能出现问题的代码；

}catch （异常名变量名）{

针对问题的处理；

}

注意事项

try中的代码越少越好
catch中要做处理，哪怕一条输出语句也可以。（不能讲异常信息隐藏）

public class MyTest {
    public static void main(String[] args) {
        //自己捕获并处理异常
        //我们可以使用try catch 来进行异常的捕获处理
        int a=0;
        int b=7;
        //try 里面放的是你认为有可能会出现异常的代码
        try {
            System.out.println(b / a);
         //catch(ArithmeticException e) catch 小括号里面定义的是，你将要捕获的何种异常
        }catch (ArithmeticException e){
            //catch 大括号里面 放的是，一旦发生你捕获的这种异常，你的处理方式是什么
            e.printStackTrace();
            /*java.lang.ArithmeticException: / by zero
            at study.luxiuer.demo.MyTest.main(MyTest.java:12)*/
            System.out.println("除数为0了");
        }
        System.out.println("这个不重要");
        System.out.println("这个也不重要");
    }
}
//注意的有两点：1.try里面尽可能放的是，有可能出现问题的代码。
//2.一旦发生异常，异常的处理，不能空处理，即便你打印一句话提示一下，都行

try…catch的方式处理异常2

try {

可能出现问题的代码；

}catch （异常名1 变量名1）{

对异常的处理方式；

}catch （异常名2 变量名2）{

对异常的处理方式；

}…

注意事项

能明确的尽量明确，不要用大的来处理
平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面

public class MyTest {
    public static void main(String[] args) {
        //但凡出现一个异常，处理异常后下面的代码不执行
        int[] arr={2,3};
        int a=1;
        int b=0;
        arr=null;
        //1.你能明确的异常，尽量明确，不要拿一个最大的异常一捕了之。
        //2.捕获多个异常时，大的异常，放在最后面，平级关系的异常，谁前谁后无所谓。
        try{
            System.out.println(arr.length);
            System.out.println(a / b);
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e){
            System.err.println("角标越界异常");
        }catch (ArithmeticException e){
            System.err.println("除数为0了");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
            //空指针异常
        } catch (Exception e) {
            //exception是异常的父类，有子父关系时放在最后
            System.out.println("其他异常");
        }
        System.out.println("这个不重要");
        System.out.println("这个也不重要");
    }
}

JDK7针对多个异常的处理方案

JDK1.7中对多个catch的变形格式

try {

可能出现问题的代码；

}catch （异常名1 | 异常名2 | … 变量名）{

对异常的处理方案；

}

好处：简化了代码
弊端：对多个异常的处理方式是一致的
注意事项：多个异常之间只能是平级的关系，不能出现子父类的继承关系

public class MyTest {
    public static void main(String[] args) {
        int[] arr = {2, 3};
        int a = 1;
        int b = 0;
        arr = null;
        //1.你能明确的异常，尽量明确，不要拿一个最大的异常一捕了之。
        //2.捕获多个异常时，大的异常，放在最后面，平级关系的异常，谁前谁后无所谓。
        try {
            System.out.println(arr.length);
            System.out.println(a / b);
            System.out.println(arr[3]);
            //JDK1.7 提供的这种语法，不推荐
        } catch (ArrayIndexOutOfBoundsException| ArithmeticException | NullPointerException  e) {
            if(e instanceof ArrayIndexOutOfBoundsException ){

            }else if(e instanceof ArithmeticException){

            }else if(e instanceof NullPointerException){

            }else{

            }
        }
        System.out.println("这个不重要");
        System.out.println("这个也不重要");

    }
}
//注意事项：1.处理方式是一致的。（实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理）
//2.多个异常间必须是平级关系

编译期异常和运行期异常的区别

编译期异常和运行期异常的区别

Java中的异常被分为两大类：编译时异常和运行时异常

所有的RuntimeException类及子类的实例被称为运行时异常，其他的异常就是编译时异常

编译时异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译（无法运行，会报错）
运行时异常：无需显示处理，也可以和编译时异常一样处理（可以运行）

Throwable的几个常见方法

Throwable的几个常见方法

getMessage（）：获取异常信息，返回字符串

public class MyTest {
    public static void main(String[] args) {
        int a=5;
        int b=0;
        try {
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println(e.getMessage());
            //   / by zero
        }
    }
}

toString（）：获取异常类名和异常信息，返回字符串

public class MyTest {
    public static void main(String[] args) {
        int a=5;
        int b=0;
        try {
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println(e.toString());
            //java.lang.ArithmeticException: / by zero
        }
    }
}

printStackTrace（）：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void

public class MyTest {
    public static void main(String[] args) {
        int a=5;
        int b=0;
        try {
            System.out.println(a / b);
        }catch (ArithmeticException e){
            e.printStackTrace();
            /*java.lang.ArithmeticException: / by zero
            at study.luxiuer.demo.MyTest.main(MyTest.java:8)*/
        }
    }
}

throws的方式处理异常

throws的方式处理异常

定义功能方法时，需要把出现的问题暴露出来让调用者去处理

那么就通过throws在方法上标识

编译时异常的抛出

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        while (true){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个整数");
            if (sc.hasNextInt()){
                int i = sc.nextInt();
                System.out.println(i);
                break;
            }else{
                System.out.println("输入类型不正确");
            }
        }
    }
}

运行时异常的抛出

import java.util.InputMismatchException;
import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {
        while (true){
            Scanner sc = new Scanner(System.in);
            try {
                System.out.println("请输入一个整数");
                int i = sc.nextInt();
                System.out.println(i);
                break;
            }catch (InputMismatchException e){
                System.out.println("输入类型不正确");
            }
        }
    }
}

throw的概述以及和throws的区别

throw的概述：在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出

throws和throw的区别

throws

用在方法声明后面，跟的是异常类名

可以跟多个异常类名，用逗号隔开

表示抛出异常，由该方法的调用者来处理

throws表示出现异常的一种可能性，并不一定会发生这些异常
throw

用在方法体内，跟的是异常对象名

只能抛出一个异常对象名

这个异常对象可以是编译期异常对象,可以是运行期异常对象

表示抛出异常，由方法体内的语句处理

throw则是抛出了异常，执行throw则一定抛出了某种异常

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int a = sc.nextInt();
        System.out.println("请输入第二个整数");
        int b = sc.nextInt();
        double t=chufa(a,b);
    }

    private static double chufa(int a, int b) {
        double t=0;
        if (b==0){
            throw new ArithmeticException("除数为0");
        }else {
            t=a/b;
        }
        return t;
    }
}

finally关键字的特点及作用

finally关键字的特点

被finally控制的语句体一定会执行（前提 jvm没有停止）

特殊情况：在执行到finally之前jvm退出了（比如System.exit（0））

finally的作用

用于释放资源，在IO流操作和数据库操作中会见到

public class MyTest {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println("除数为0啦");
            //除数为0啦
        }finally {
            System.out.println("我还是会执行");
            //我还是会执行
        }
    }
}

public class MyTest {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println("除数为0啦");
            //除数为0啦
            //jvm退出了
            System.exit(0);
        }finally {
            System.out.println("jvm退出啦，我执行不了啦");
        }
    }
}

finally关键字的面试题

final，finally和finalize的区别
- final：是一个状态修饰符，可以用来修饰类，变量，成员方法
  
  被修饰的类不能被子类继承，修饰的变量其实是一个常量不能被再次赋值
  
  修饰的方法不能被子类重写
- finally：用在try…catch…语句中；作用：释放资源；特点：始终被执行(JVM不能退出)
- finalize：Obejct类中的一个方法，用来回收垃圾
如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后

会执行，在return前

public class MyTest {
    public static void main(String[] args) {
        try {
            System.out.println(23 / 0);
        } catch (Exception e) {
            System.out.println("catch了");
            return ;
        }finally {
            System.out.println("finally了");
        }
    }
}
//catch了
//finally了

自定义异常概述和基本使用

为什么需要自定义异常

因为在以后的开发过程中，我们可能会遇到各种问题，

而Jdk不可能针对每一种问题都给出具体的异常类与之对应。

为了满足需求，我们就需要自定义异常。

自定义异常概述

需要将我们自定义的异常类纳入到我们的异常体系中

继承自Exception
继承自RuntimeException

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生成绩（0-100）");
        int score = sc.nextInt();
        if (score > 100 || score < 0) {
            throw new MyException("成绩不合法");

        } else {
            System.out.println("成绩合法");
        }
    }
    
}
class MyException extends RuntimeException {
    public MyException(String s) {
        
    }
}

自定义异常练习

需求：从银行取钱，发现钱不够，给出提示

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        double mymoney = 2000;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要取款的金额");
        double money = sc.nextDouble();
        quqian(mymoney, money);
    }

    private static void quqian(double mymoney, double money) {
        if (mymoney < money) {
            throw new NoMoney("余额不足");
        } else {
            System.out.println("取款成功，当前余额" + (mymoney - money) + "元");
        }
    }
}

class NoMoney extends RuntimeException {
    public NoMoney(String s) {
        System.err.print(s);
    }
}

异常的注意事项及如何使用异常处理

异常注意事项（针对编译期异常）

子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类，或者子类不抛出异常也是可以的。（父亲坏了，儿子不能比父亲更坏）
如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常，或者子类不抛出异常也是可以的
如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws

如何使用异常处理

原则：如果该功能内部可以将问题处理，用try，如果处理不了，交由调用者处理，这是用throws
区别：

后续程序需要继续运行就try

后续程序不需要继续运行就throws

如果JDK没有提供对应的异常，需要自定义异常

File类

File类的概述和构造方法

File类的概述

查看API
文件和目录路径名的抽象表示形式
这个File类可以用来表示文件，也可以用来表示目录

构造方法

File（String pathname）：根据一个路径得到File对象

import java.io.File;
public class MyTest {
    public static void main(String[] args) {
        File f = new File("E:\\luxiuer\\text");
        File file = new File("E:\\luxiuer\\text\\xiuer.txt");
        System.out.println(f);//E:\luxiuer\text
        System.out.println(file);//E:\luxiuer\text\xiuer.txt
    }
}

File（String parent，String child）：根据一个目录和一个子文件/目录得到File对象

import java.io.File;
public class MyTest {
    public static void main(String[] args) {
        File f = new File("E:\\luxiuer\\text","luxiuer.txt");
        System.out.println(f);//E:\luxiuer\text\luxiuer.txt
    }
}

File（File parent，String child）：根据一个父File对象和一个子文件/目录得到File对象

import java.io.File;
public class MyTest {
    public static void main(String[] args) {
        File f = new File("E:\\luxiuer\\text");
        File file = new File(f, "xiuer.txt");
        System.out.println(f);//E:\luxiuer\text
        System.out.println(file);//E:\luxiuer\text\xiuer.txt
    }
}

File类的创建功能

创建功能

public boolean createNewFile（）：创建一个新的文件如果存在这样的文件，就不创建了

import java.io.File;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        File f = new File("E:\\luxiuer.txt");
        boolean b = f.createNewFile();
        //创建成功返回true，之前有同名文件返回false
        System.out.println(b);
    }
}

public boolean mkdir（）：创建文件夹如果存在这样的文件夹，就不创建了；注意这个方法只能创建单层目录，如果创建多层目录得一层一层创建

import java.io.File;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        File f = new File("E:\\xiuer");
        boolean b = f.mkdir();
        创建成功返回true，之前有同名文件夹返回false
        System.out.println(b);
    }
}

public boolean mkdirs（）：创建文件夹,如果父文件夹不存在，会帮你创建出来，可以创建多层目录，当然也可以创建单层目录

import java.io.File;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        File f = new File("E:\\lu\\xiu\\er");
        //直接创建多层目录
        boolean b = f.mkdirs();
        System.out.println(b);
    }
}

注意事项：如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下

相对路径：没有带盘符的路径（工程包下）
绝对路径：带有盘符的路径

File类的删除功能

删除功能

public boolean delete（）：删除文件或者文件夹

注意：删除文件夹时，这个文件夹是空文件夹；如果这个文件夹里面有文件，则不能删除

import java.io.File;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        File f = new File("E:\\xiuer");
        boolean b = f.delete();
        System.out.println(b);
    }
}

注意事项：Java中的删除不走回收站。要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

File类的重命名功能

重命名功能

public boolean renameTo（File dest）：把文件重命名为指定的文件路径

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

public class MyTest {
    public static void main(String[] args) throws IOException {
        File f = new File("E:\\luxiuer.txt");
        File file = new File("E:\\xiuer.txt");
        File ff = new File("E:\\lu\\xiuer.txt");
        f.renameTo(file);
        //路径相同重命名
        file.renameTo(ff);
        //路径不同改名并剪切
    }
}

File类的判断功能

public boolean isDirectory（）：判断是否是目录
public boolean isFile（）：判断是否是文件
public boolean exists（）：判断是否存在
public boolean canRead（）：判断是否可读
public boolean canWrite（）：判断是否可写
public boolean isHidden（）：判断是否隐藏
public boolean isAbsolute（）：判断是否使用的是绝对路径

File类的获取功能

public String getAbsolutePath（）：获取绝对路径
public String getPath（）：获取相对路径
public String getParent（）：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null
public File getParentFile（）：返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null
public long getTotalSpace（）：返回此抽象路径名指定的分区大小。返回总容量单位字节
public long getFreeSpace（）：返回此抽象路径名指定的分区中未分配的字节数。返回剩余容量单位字节
public String getName（）：获取名称
public long length（）：获取长度。字节数
public long lastModified（）：获取最后一次的修改时间，毫秒值
public String[ ] list（）：获取指定目录下的所有文件或者文件夹的名称数组
public File[ ] listFiles（）：获取指定目录下的所有文件或者文件夹的File数组

输出指定目录下指定后缀的文件名

import java.io.File;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        //封装
        File file = new File("E:\\test");
        //获取指定目录下的所有文件或者文件夹的File数组
        File[] files = file.listFiles();
        //遍历数组
        for (File f : files) {
            //查找文件后缀
            if(f.getName().endsWith(".pdf")){
                //获取文件名
                System.out.println(f.getName());
            }
        }
    }
}

文件名称过滤器的概述及使用

文件名称过滤器的概述

public String[ ] list（FilenameFilter filter）
public File[ ] listFiles（FilenameFilter filter）

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\test");
        File[] files = file.listFiles(new FilenameFilter() {
            //过滤器
            @Override
            public boolean accept(File dir, String name) {
                File dd=new File(dir, name);
                return dd.isFile()&&dd.getName().endsWith(".pdf");
            }
        });
        for (File f : files) {
            System.out.println(f.getName());
        }
    }
}

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
public class MyTest {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\test");
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File dd) {
                return dd.isFile()&&dd.getName().endsWith(".pdf");
            }
        });
        for (File f : files) {
            System.out.println(f.getName());
        }
    }
}

完

鹿秀儿

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2020-08-13

IO流IO流概述及其前奏IO流概述IO流用来处理设备之间的数据传输上传文件和下载文件IO流前奏File表示的是IO流将要操作的文件，所以先要学习File类在常见的操作文件（上传文件和下载文件）的过程中可能出现问题，我们需要对应的代码进行处理，所以要学习异常异常异常的概述和分类异常的概述异常就是java程序在运行过程中出现错误异常的分类运行期异常：可以选择解决或不解决Error：无法解决编译器异常：必须解决，不解决不能运行异常的继承体系异常的基类：Thorwabl
复制链接

扫一扫