java中的异常和IO流

最新推荐文章于 2024-01-27 16:24:57 发布

我就是新贵

最新推荐文章于 2024-01-27 16:24:57 发布

阅读量263

点赞数

分类专栏： java基础文章标签： java io流

本文链接：https://blog.csdn.net/wobushizhainan/article/details/78065883

版权

java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

异常和IO流

异常
1.异常的概述和分类)
   * A:异常的概述
       * 异常就是Java程序在运行过程中出现的错误。
   * B:异常的分类
       * 通过API查看Throwable
           * Error
               * 服务器宕机,数据库崩溃等
           * Exception
   C:异常的继承体系
       * Throwable
           * Error
           * Exception
               * RuntimeException

2.JVM默认是如何处理异常的
   * A:JVM默认是如何处理异常的
       * main函数收到这个问题时,有两种处理方式:
       * a:自己将该问题处理,然后继续运行
       * b:自己没有针对的处理方式,只有交给调用main的jvm来处理
       * jvm有一个默认的异常处理机制,就将该异常进行处理.
       * 并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行

3.异常处理
   * A:异常处理的两种方式
       * a:try…catch…finally
           * try catch
           * try catch finally
           * try finally
       * b:throws

   * B:try...catch处理异常的基本格式
       * try…catch…finally

4.try...catch的方式处理异常

   * try...catch的方式处理多个异常
   * JDK7以后处理多个异常的方式及注意事项

5.编译期异常和运行期异常的区别
   * A:编译期异常和运行期异常的区别
       * Java中的异常被分为两大类：编译时异常和运行时异常。
       * 所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常

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

6.Throwable的几个常见方法
   * A:Throwable的几个常见方法
       * a:getMessage()
           * 获取异常信息，返回字符串。
       * b:toString()
           * 获取异常类名和异常信息，返回字符串。
       * c:printStackTrace()
           * 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

7.throws的方式处理异常
   * A:throws的方式处理异常
       * 定义功能方法时，需要把出现的问题暴露出来让调用者去处理。
       * 那么就通过throws在方法上标识。

8.throw的概述以及和throws的区别
   * A:throw的概述
       * 在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
   * B:案例演示
       * 分别演示编译时异常对象和运行时异常对象的抛出
   * C:throws和throw的区别
       * a:throws
           * 用在方法声明后面，跟的是异常类名
           * 可以跟多个异常类名，用逗号隔开
           * 表示抛出异常，由该方法的调用者来处理
       * b:throw
           * 用在方法体内，跟的是异常对象名
           * 只能抛出一个异常对象名
           * 表示抛出异常，由方法体内的语句处理

9.finally关键字的特点及作用
   * A:finally的特点
       * 被finally控制的语句体一定会执行
       * 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
   * B:finally的作用
       * 用于释放资源，在IO流操作和数据库操作中会见到

10.finally关键字的面试题
   * A:面试题1
       * final,finally和finalize的区别
   * B:面试题2
       * 如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。

11.自定义异常概述和基本使用
   * A:为什么需要自定义异常
       * 举例：人的年龄
   * B:自定义异常概述
       * 继承自Exception
       * 继承自RuntimeException

12.异常的注意事项及如何使用异常处理
   * A:异常注意事项
       * a:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
       * b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
       * c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
   * B:如何使用异常处理
       * 原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
       * 区别:
           * 后续程序需要继续运行就try
           * 后续程序不需要继续运行就throws

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

IO流
   1.概念
       * IO流用来处理设备之间的数据传输
       * Java对数据的操作是通过流的方式
       * Java用于操作流的类都在IO包中
       * 流按流向分为两种：输入流，输出流。
       * 流按操作类型分为两种：
           * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
           * 字符流 : 字符流只能操作纯字符数据，比较方便。
   2.字节流
       |--InputStream(字节输入流,字节流的抽象父类,抽象类不能直接创建对象,必须使用子类)
           |--FileInputStream(文件字节输入流,就是以字节的形式读取文件内容)
               |--read()每次读取一个字节(byte),但是返回值类型,为int类型,防止出现文件提前结束
               |--read(byte[] b)每次读取多个字节,将内容放入字节数组b中
           |--BufferedInputStream(字节输入缓冲流,其实就是一个包装类,创建对象时要接收一个InputStream,内部封装了一个1024*8的字节数组)
               |--使用BufferedInputStream就不用再定义数组了


       |--OutputStream(字节输出流,字节流的抽象父类)
           |--FileOutputStream(文件字节输出流,就是以字节的形式将内容写入到文件中)
               |--write(int b)一次写出一个字节
               |--write(byte[] b)将字节数组b里的内容写入到文件中
               |--write(byte[] b, int off, int len)将字节数组b里的内容,从索引为off的位置开始,总共写len个
           |--BufferedOutputStream(字节输出缓冲流,其实就是一个包装类,创建对象时要接收一个OutputStream,内部封装了一个1024*8的字节数组)

   3.字符流
       |--Reader(字符输入流,字符流的抽象父类,抽象类不能直接创建对象,必须使用子类)
           |--FileReader(文件字符输入流,就是以字符的形式读取文件中的内容)
               |--read()每次读取一个字符,即可以按照字符大小读取,返回值类型提升为int类型
               |--read(char[] b)每次读取多个字符,将内容放入字符数组b中
           |--BufferedReader(字符输入缓冲流,其实就是一个包装类,创建对象时要接收一个Reader,内部封装了一个1024*8的字符数组)
               |--使用BufferedReader和BufferedWriter就不用再定义数组了
               |--readLine()可以读取一行字符(不包含换行符号)
               |--LineNumberReader是BufferedReader的子类, 具有相同的功能, 并且可以统计行号
                   |--getLineNumber()方法可以获取当前行号
                   |--setLineNumber()方法可以设置当前行号

       |--Writer(字符输出流,字符流的抽象父类)
           |--FileWriter(文件字符输出流,就是以字符的形式将内容写入到文件中)
               |--write('a')/write("aaaa")可以写入单个字符或者写入字符串
               |--write(char[] b, int off, int len)将字符数组b里的内容,从所以为off的位置开始,总共写len个
           |--BufferedWriter(字符输出缓冲流,其实就是一个包装类,创建对象时要接收一个Writer,内部封装了一个1024*8的字符数组)
               |--newLine()可以输出一个跨平台的换行符号"\r\n"

   4.转换流(使用指定的码表读写字符)
       |--InputStreamReader字节输入流到字符输入流的桥梁
       |--OutputStreamWriter字符输出流到字节输出流的桥梁

   5.其它流
       |--SequenceInputStream序列流
           |--序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
           |--SequenceInputStream(InputStream in1,InputStream in2)
           |--SequenceInputStream(Enumeration en)
       |--ByteArrayOutputStream字节数组内存输出流
           |--是将文件或键盘录入的数据写入到内存中的字节数组
       |--ByteArrayInputStream字节数组内存输入流
           |--是以字节的方式读取内存中的字节数组数据

|--创建此对象要传递一个字节数组

使用方式

 * 创建对象: new ByteArrayOutputStream()
            * 写出数据: write(int), write(byte[])
            * 获取数据: toByteArray()
    
            FileInputStream fis = new FileInputStream("a.txt");
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b;
            while((b = fis.read()) != -1) {
                baos.write(b);
            }
            
            //byte[] newArr = baos.toByteArray();                //将内存缓冲区中所有的字节存储在newArr中
            //System.out.println(new String(newArr));
            System.out.println(baos);        //将a.txt文件中的内容打印出来
            fis.close();

       |--RandomAccessFile随机读写访问流
           |--该流同时具有读和写的功能
           |--seek(long pos)设置读取和写入的位置
       |--对象操作流
           |--ObjectOutputStream将对象写入到文件,要求对象所属的类实现Serializable接口,该接口里面没有内容,只是一个标记
               |--writeObject()将对象写入文件
           |--ObjectInputStream将上面存入到文件中的对象读取出来,因为存的时候所有对象是按照Object存入,所以取出来要进行强制类型转换
               |--readObject()从文件读取一个对象出来
       |--数据输入输出流
           |--DataInputStream数据输入流,就是从文件读取特定类型的数据
               |--readInt()从文件中读取一个int类型的数据
               |--readLong()从文件读取一个long类型的数据
           |--DataOutputStream数据输出流,向文件写出特定类型的数据
               |--writeInt()向文件写入一个int类型的数据
               |--writeLong()向文件写入一个long类型的数据
       |--打印流PrintStream
       |--标准输入输出流
           |--System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
               |--System.setIn(InputStream)修改输入流
           |--System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
               |--System.setOut(PrintStream)修改输出流
       |--键盘录入的两种方式
           |--Scanner sc = new Scanner(System.in);
           |--BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       |--Properties是Hashtable的子类,是一个Map,存放的是键值对,一般用于项目的配置文件,配置文件中键和值的类型都为String类型
           |--setProperty(String key,String value)向Properties中存入键值对
           |--getProperty(String key)根据键获取值
           |--public Enumeration<String> stringPropertyNames()以String的形式获取所有的键,并封装成Enumeration对象,之后进行遍历
           |--load(InputStream inStream) 将字节输入流inStream所关联的文件中的值加载到Properties对象中
           |--store(OutputStream out, String comments) 将Properties对象中的内容写入到out流所关联的文件中,comments为说明信息


   6. flush和close方法：
       flush用来刷新缓冲区的,刷新后可以再次写出,即flush后流仍然可以使用
       close用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出,即不能再使用该流

   7.IO流的标准异常处理

 //在外部建立对象引用
            FileWriter fw = null;
        
            try{
                //在try内进行初始化
                fw = new FileWriter("demo.txt");
                fw.write("abcdef");
            }
            catch(IOException e){
                System.out.println("Error:"+e.getMessage());
            }
            finally{
                try{
                    //如果流存在，始终关闭流资源，如果有多个流存在，需要单个去关半。
                    if(null != fw)
                        fw.close();
                }
                catch(IOException e){
                    System.out.println("Error:"+e.getMessage());
                }
            }

8.递归读取文件