Java阶段一Day19

已于 2023-04-24 19:31:00 修改
阅读量902 收藏 1
点赞数 2
分类专栏： # 开发篇 文章标签： java jvm 开发语言
于 2023-04-10 18:44:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65777087/article/details/130066834
版权

Java阶段一Day19

文章目录

对象流

java.io.ObjectlnputStream和ObjectOutputStream

作用：

  • 对象输出流：将我们的java对象进行序列化
  • 对象输入流：将java对象进行反序列化

序列化
将一个对象转换为一组可被传输或保存的字节。这组字节中除了包含对象本身的数据外，还会包含结构信息。

反序列化

将字符序列还原回一个对象的过程
在这里插入图片描述

transient：短暂的

有时候，一些对象的状态没必要写入和读取，使用transient，被transient关键字修饰后，该对象在进行序列化时，转换出来的字节中不包含该属性，忽略不必要属性达到对象“瘦身”操作

对象瘦身可以在对象持久化时减少磁盘开销。在进行传输时可以缩短传输速度。

如果该对象，不需要序列化，那么该关键字不发挥任何效果

读写数据的单位分为 字符流和字节流

字符流

  • 都是高级流，Reader和Writer
  • java.io. Reader是字符输入流的父类
  • java.io. Writer是字符输出流的父类。
  • 字符流是以字符(char)为单位读写数据的。一次处理一个unicode。
  • 字符流的底层仍然是基本的字节流。

Writer

常用方法：

方法介绍
void write(int c)写出一个字符,写出给定int值"低16”的字符
void write(char[] chs)将给定字符数组中所有字符写出
void write(String str):将给定的字符串写出
void write(chang] chs,int offsetint len)给定的字符数组中从offset处开始连续的len个字符写出

Reader

常用方法：

方法介绍
int read()读取一个字符，返回的int值“低16”位有效
int read(char[] chs)从该流中读取一个字符数组的length个字符并存入该数组，返回值为实际读取到的字符量

转换流

字符流和字节流不能直接连接，需要转换流

在这里插入图片描述

  • InputStreamReader：字符输入流。

    • 使用该流可以设置字符集，并按照指定的字符集从流中按照该编码将字节数据转换为字符并读取。

    • lnputStreamReader的构造方法：

      方法介绍
      lnputStreamReader(InputStream in,Charset cs)基于给定的字节输入流以及字符编码创建ISR
      InputStreamReader(InputStream in)该构造方法会根据系统默认字符集创建ISR

  • OutputStreamWriter：字符输出流

    • 使用该流可以设置字符集，并按照指定的字符集将字符转换为对应字节后通过该流写出。

    • OutputStreamWriter的构造方法：

      方法介绍
      OutputStreamWriter(OutputStream out,Charsetcs)基于给定的字节输出流以及字符编码创建OSW
      OutputStreamWriter(OutputStream out)该构造方法会根据系统默认字符集创建OSW

  • 意义：

    • 转换流是唯一可以连接在字节流上的字符流。而其他字符流都只能连接在字符流上。

    • 因此在流连接中我们使用的字符流只有先连接在转换流上才能再连接到字节流上进行工作。所以转换流起到了转换器的作用。

缓冲字符流

  • java.io.BufferedWriter 和 BufferedReader
    • 缓冲字符流内部有一个默认为8192长度的char数组，总是以块读写形式来保证读写效率。
  • java.io.PrintWriter
    • 具有自动行刷新功能的缓冲字符输出流，内部总是连接BufferedWriter作为缓冲使用。

特点：

  • 可以按行写出字符串
  • 可选的自动行刷新功能

BufferedWriter与PrintWriter

  • PrintWriter是具有自动行刷新的缓冲字符输出流。其提供了比较丰富的构造方法。

    • PrintWriter(File file)
    • PrintWriter(String fileName)
    • PrintWriter(OutputStream out)
    • PrintWriter(OutputStream out,boolean autoFlush)
    • PrintWriter(Writer writer)
    • PrintWriter(Writer writer,boolean autoFlush)
    • 传入boolean值参数，用于表示PrintWriter是否具有自动行刷新

  • PrintWriter提供了丰富的重载print与println方法。其中println方法在于输出目标数据后自动输出一个系统支持的换行符。

  • 若该流是具有自动行刷新的，那么每当通过println方法写出的内容都会被实际写出，而不是进行缓存。

  • 常用方法：

    方法介绍
    void printIn(int i)打印整数
    void printIn(char c)打印字符
    void printIn(boolean b)打印boolean值
    void printIn(char[] c)打印字符数组
    void printIn(double d)打印double值
    void printIn(float f)打印float值
    void println(long l)打印long值
    void println(String str)打印字符串

在文件输出流上最终链接到PrintWriter上

在这里插入图片描述

public static void main(String[] args) throws IOException {

    //四层流连接
    //fos -> osw -> bw -> pw
    //负责:将写出的字节写入文件中
    FileOutputStream fos = new FileOutputStream("text2.txt",true);
    //负责:将写出的字符全部转换成字节(可指定字符集转换)
    OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
    //负责:块写入数据(攒够8192个字符一次性写出)
    BufferedWriter bw = new BufferedWriter(osw);
    //负责:按行输出字符串
    PrintWriter pw = new PrintWriter(bw,true);
    
    pw.println("这是一个测试语句");
    pw.println("这是另一个测试语句");

    System.out.println("写出完毕");

    pw.close();

}

BufferedReader

  • 缓冲字符输入流:java.io. BufferedReader
  • 缓冲字符输入流内部默认有一个长度为8192的char数组，块读文本数据加速。
  • 并且其还具备按行读取字符串的能力
    • String readLine()
    • 该方法连续读取一行字符串，直到读取到换行符为止，返回的字符串中不包含该换行符。
  • BufferedReader的常用构造方法：
    • BufferedReader(Reader reader)
public static void main(String[] args) throws IOException {

    /*
         * 一口气读8192个字符
         *  readLine(new String)
         * 在其内部扫描，遇到换行就输出换行符前的内容
         * 下次从换行符之后出发直到下一个换行符
         * 该行没内容就返回 " " 表示空行 
         * 文件判断结束末尾是null
         */

    // 三次链接  fis -> isr -> br
     //负责:读取文件中的字节
    FileInputStream fis = new FileInputStream("./src/main/java/com/liner/io/BRDemo.java");
     //负责:将读取的字符全部转换成字节
    InputStreamReader isr = new InputStreamReader(fis);
     //负责:块读取数据(攒够8192个字符一次性读取)
    BufferedReader br = new BufferedReader(isr);

    String line;
    //readLine检测到/n自动换行 
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    br.close();

}

异常

Throwable、Error、Exception

  • Java异常结构中定义有Throwable类，Exception和Error是其派生的两个子类。
    • Exception表示由于网络故障、文件损坏、设备错误、用户输入非法等情况导致的异常，可恢复
    • Error表示Java运行时环境出现的错误，例如:JVM内存资源耗尽等。不可恢复

异常处理机制

程序抛出异常，程序从导致异常的代码处跳出，jjava虚拟机检测寻找和try关键字匹配的处理该异常的catch块，

如果找到,将控制权交到catch块中的代码,然后继续往下执行程序，try块中发生异常的代码不会被重新执行。

如果没有找到处理该异常的catch块，在所有的finally块代码被执行和当前线程的所属的ThreadGroup的uncaughtException方法被调用后，遇到异常的当前线程被中止。

throw

  • 当程序发生错误而无法处理的时候，会抛出对应的异常对象
  • 在某些时刻，可能会想要自行抛出异常,并生成指定的异常对象后抛出

throws

  • 程序中会声明许多方法（Method)，可能会因某些错误而引发异常
  • 不希望直接在这个方法中处理这些异常，而希望调用这个它的方法来统一处理
  • 重写方法时的throws
    • 使用继承时，在父类别的某个方法上宣告了throws某些异常，而在子类别中重新定义该方法时，可以：
      • 不处理异常（重新定义时不设定throws)
      • 可仅throws父类别中声明的部分异常。
      • 可throws父类方法中抛出异常的子类异常
    • 但是不可以：
      • throws出额外的异常
      • throws父类方法中抛出异常的父类异常

try-catch

  • 就是一次捕获并处理例外的范围
  • 在执行过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句分别对这些异常做相应的处理
  • 如果没有异常产生，所有的catch代码段都被略过不执行
  • 当多个异常可使用同一种方法解决时，可以合并到一个catch中处理
  • 在catch语句块中是对异常进行处理的代码
  • 在catch中声明的异常对象(catch(SomeExceptione))封装了异常事件发生的信息,
  • 在catch语句块中可以使用这个对象的一些方法获取这些信息

finally

  • finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序其它部分以前，能够对程序的状态作统一管理

  • 无论try所指定的程序块中是否抛出异常，finally所指定的代码都要被执行

  • 通常在finally语句中可以进行资源的释放工作，如关闭打开的文件、删除临时文件等。

  • JDK7之后，java推出了自动关闭特性，旨在更优雅的在异常处理机制中关闭如流这样的操作

    //只有实现了java.io.AutoCloseable接口的类才可以在这里定义
//在try的()中定义并初始化需要在finally中调用close方法的对象
//自动关闭特性是编译器认可的
public static void main(String[] args) {
        try (
                FileOutputStream fos = new FileOutputStream("fos.dat");
        ) {
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

面试题

请分别描述final,finally ,finalize?

  • final：最终的，最后的，被final修饰的类不可被继承，被修饰的变量是不可变量，被修饰的方法不可被重写
  • finally：在try-catch代码块的最后加上finally，为异常处理提供一个统一的出口
  • finalize是Object定义的一个方法，java中所有的类都有这个方法。
    • 特点：该方法是一个对象声明周期的最后一个方法。当GC发现一个对象没有引用时就会释放该对象，释放前会调用该对象的finalize方法，该方法调用后，对象被销毁

教师总结

新单词

  • transient-稍纵即逝的

  • unsupported-不支持的

  • encoding-编码

  • try-试试

  • catch- 抓住，捕获

  • throw-抛出，扔出

  • error-错误

  • AutoClose-自动关闭

JAVA IO

对象流

对象输入流

java.io.ObjectInputStream使用对象流可以进行对象反序列化

构造器
ObjectInputStream(InputStream in)
将当前创建的对象输入流链接在指定的输入流上
方法
Object readObject()
进行对象反序列化并返回。该方法会从当前对象输入流链接的流中读取若干字节并将其还原为对象。这里要注意读取的字节必须是由ObjectOutputStream序列化一个对象所得到的字节。
例
package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * 对象输入流，用来进行对象反序列化
 */
public class OISDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //读取person.obj文件并将其中保存的数据进行反序列化
        FileInputStream fis = new FileInputStream("person.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);

        Person person = (Person)ois.readObject();
        System.out.println(person);

        ois.close();
    }
}
transient关键字

当一个属性被transient关键字修饰后，该对象在进行序列化时，转换出来的字节中是不包含该属性的。忽略不必要的属性可以达到对象"瘦身"的操作。

对象瘦身可以在对象持久化时减少磁盘开销。在进行传输时可以缩短传输速度。

如果该对象不需要序列化，那么该关键字不发挥其他任何效果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Av9gHF24-1681122832913)(C:\Users\TEACHER\IdeaProjects\JSD2303_SE\笔记\image-20230410093231602.png)]

序列化时不包含otherInfo属性，并且反序列化时该属性值为null
在这里插入图片描述

字符流

  • java将流按照读写单位划分为字节流与字符流.
  • java.io.InputStream和OutputStream是所有字节流的超类
  • 而java.io.Reader和Writer则是所有字符流的超类,它们和字节流的超类是平级关系.
  • Reader和Writer是两个抽象类,里面规定了所有字符流都必须具备的读写字符的相关方法.
  • 字符流最小读写单位为字符(char),但是底层实际还是读写字节,只是字符与字节的转换工作由字符流完成.
  • 字符流都是高级流
超类

  • java.io.Writer 所有字符输入流的超类

    常用方法

    void write(int c):写出一个字符,写出给定int值”低16”位表示的字符。
void write(char[] chs):将给定字符数组中所有字符写出。
void write(String str):将给定的字符串写出
void write(char[] chs,int offset,int len):将给定的字符数组中从offset处开始连续的len个字符写出

  • java.io.Reader 所有字符输出流的超类

    常用方法

    int read():读取一个字符，返回的int值“低16”位有效。当返回值为-1时表达流读取到了末尾。
int read(char[] chs):从该流中读取一个字符数组的length个字符并存入该数组，返回值为实际读取到的字符量。当返回值为-1时表达流读取到了末尾。
转换流

java.io.InputStreamReader和OutputStreamWriter是常用的字符流的实现类。

实际开发中我们不会直接操作他们，但是他们在流连接中是必不可少的一环。

流连接中的作用
  • 衔接字节流与其他字符流
  • 将字符与字节相互转换
意义

实际开发中我们还有功能更好用的字符高级流.但是其他的字符高级流都有一个共通点:不能直接连接在字节流上.而实际操作设备的流都是低级流同时也都是字节流.因此不能直接在流连接中串联起来.转换流是一对可以连接在字节流上的字符流,其他的高级字符流可以连接在转换流上.在流连接中起到"转换器"的作用(负责字符与字节的实际转换)

输出流
构造器
OutputStreamWriter(OutputStream out,Charset cs)
基于给定的字节输出流以及字符编码创建OSW
    
OutputStreamWriter(OutputStream out)
该构造方法会根据系统默认字符集创建OSW

示意

在这里插入图片描述

例

package io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;

/**
 * 转换流写出文本数据
 */
public class OSWDemo {
    public static void main(String[] args) throws IOException {
        //向文件osw.txt中写出文本数据
        FileOutputStream fos = new FileOutputStream("osw.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);

        osw.write("夜空中最亮的星，能否听清，");
        osw.write("那仰望的人心底的孤独和叹息。");
        System.out.println("写出完毕");
        osw.close();

    }
}
输入流
构造器
InputStreamWriter(InputStream in,Charset cs)
基于给定的字节输入流以及字符编码创建当前转换流
    
InputStreamWriter(InputStream in)
该构造方法会根据系统默认字符集创建当前转换流

例

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * 使用转换流读取文本数据
 */
public class ISRDemo {
    public static void main(String[] args) throws IOException {
        //将osw.txt文件中的文本信息读取回来
        FileInputStream fis = new FileInputStream("osw.txt");
        InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
        //00000000 00000000 10011101 01110010
        int d;
        while(( d = isr.read()) != -1) {
            System.out.print((char) d);
        }
        isr.close();
    }
}

缓冲字符流

缓冲字符输出流-java.io.PrintWriter

  • java.io.BufferedWriter和BufferedReader

  • 缓冲字符流内部也有一个缓冲区,读写文本数据以块读写形式加快效率.并且缓冲流有一个特别的功能:可以按行读写文本数据.缓冲流内部维护一个char数组，默认长度8192.以块读写方式读写字符数据保证效率

  • java.io.PrintWriter具有自动行刷新的缓冲字符输出流,实际开发中更常用.它内部总是会自动连BufferedWriter作为块写加速使用.

工作原理

在这里插入图片描述

特点

  • 可以按行写出字符串

  • 具有自动行刷新功能

对文件写操作的构造器
PrintWriter(File file)
PrintWriter(String path)
    
还支持指定字符集
PrintWriter(File file,String csn)
PrintWriter(String path,String csn)  
    
上述构造器看似PW可以直接对文件进行操作，但是它是一个高级流，实际内部会进行流连接:
this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),false);
如上面工作原理图
例
package io;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;

/**
 * 缓冲字符输出流:java.io.PrintWriter
 * 特点:
 * 1:按行写出字符串
 * 2:具有自动的行刷新功能
 *
 */
public class PWDemo {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        //向文件中写入文本数据
        /*
            PrintWriter(File file)
            PrintWriter(String path)
         */
        PrintWriter pw = new PrintWriter("pw.txt");
//        PrintWriter pw = new PrintWriter("pw.txt", "UTF-8");
        pw.println("我祈祷拥有一颗透明的心灵，和会流泪的眼睛。");
        pw.println("给我再去相信的勇气，oh越过黄昏去拥抱你。");
        System.out.println("写出完毕");
        pw.close();
    }
}
其他构造器
PritWriter(Writer writer)
将当前实例化的PrintWriter链接在指定的字符输出流上    
    
PrintWriter(OutputStream out)    
将当前实例化的PrintWriter链接在指定的字节输出流上
由于除了转换流外的其他字符流都不能直接连在字节流上，因此这个构造器内部会自动链接在BufferedWriter上
并且让BufferedWriter链接在转换流OutputStream上，最后再让转换流链接再指定的字节输出流上
例
package io;

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 *  自行完成流连接向文件写出字符串
 */
public class PWDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        //负责:将写出的字节写入到文件中
        FileOutputStream fos = new FileOutputStream("pw2.txt");
        //负责:将写出的字符全部转换为字节(可以按照指定的字符集转换)
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
        //负责:块写文本数据(攒够8192个字符一次性写出)
        BufferedWriter bw = new BufferedWriter(osw);
        //负责:按行写出字符串
        PrintWriter pw = new PrintWriter(bw);

        pw.println("你停在了这条我们熟悉的街,");
        pw.println("把你准备好的台词全念一遍。");

        System.out.println("写出完毕");
        pw.close();
    }
}
自动行刷新

PrintWriter支持自动行刷新，每当我们调用println方法写出一行内容后自动flush一次。

对应的构造器
PritWriter(Writer writer,boolean autoflush)
如果第二个参数为true则开启自动行刷新

例

package io;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

/**
 * 实现一个简易的记事本工具
 * 利用流连接
 * 在文件输出流上最终链接到PrintWriter上。
 * 然后将用户在控制台上输入的每一行字符串都可以按行写入到对应的文件中。
 * 当用户在控制台上单独输入"exit"时程序退出。
 */
public class AutoFlushDemo {
    public static void main(String[] args) throws FileNotFoundException {
        //负责:将写出的字节写入到文件中
        FileOutputStream fos = new FileOutputStream("note.txt");
        //负责:将写出的字符全部转换为字节(可以按照指定的字符集转换)
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
        //负责:块写文本数据(攒够8192个字符一次性写出)
        BufferedWriter bw = new BufferedWriter(osw);
        //负责:按行写出字符串
        PrintWriter pw = new PrintWriter(bw,true);//开启自动行刷新

        Scanner scanner = new Scanner(System.in);
        System.out.println("请开始输入内容，单独输入exit退出");
        while(true){
            String line = scanner.nextLine();
            //String可以忽略大小写比较字符串内容:equalsIgnoreCase
            if("exit".equalsIgnoreCase(line)){
                break;
            }
            pw.println(line);//每当println后自动flush。注意:print方法并不会自动flush
        }
        System.out.println("再见!");
        pw.close();
    }
}
缓冲字符输入流-java.io.BufferedReader

缓冲字符输入流内部维护一个默认8192长度的char数组，总是以块读取文本数据保证读取效率。

缓冲输入流提供了一个按行读取文本数据的方法

String readLine()
返回一行字符串。方法内部会连续扫描若干个字符，直到遇到换行符为止，将换行符之前的内容以一个字符串形式返回。
返回的字符串中不含有最后的换行符。
返回值有三种情况:
1:正常一行内容
2:空字符串。当读取了一个空行时(这一行只有一个换行符)。
3:null。当流读取到了末尾时。  
    
当我们第一次调用readLine()时，流并不是只读取了一行字符串，而是先进行块读操作(一次性读取8192个字符并转入到内部的char数组中)，然后扫描内部的char数组，然后将第一行字符串返回。第二次调用后再继续扫描后去的内容以此类推。
例
package io;

import java.io.*;

/**
 * 使用缓冲字符输入流读取文本数据
 */
public class BRDemo {
    public static void main(String[] args) throws IOException {
        //将当前源代码输出到控制台上
        /*
            1:创建文件输入流读取当前源代码文件
            2:进行流连接最终链接到BufferedReader上
            3:读取每一行字符串并输出到控制台上
         */
        FileInputStream fis = new FileInputStream(
                "./src/main/java/io/BRDemo.java"
        );
        InputStreamReader isr = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(isr);

        String line;
        while((line = br.readLine())!=null) {
            System.out.println(line);
        }
        br.close();
    }
}

IO总结

在这里插入图片描述

JAVA 异常处理

java异常处理机制

  • java中所有错误的超类为:Throwable。其下有两个子类:Error和Exception
  • Error的子类描述的都是系统错误，比如虚拟机内存溢出等。
  • Exception的子类描述的都是程序错误，比如空指针，下表越界等。
  • 通常我们程序中处理的异常都是Exception。

在这里插入图片描述

try-catch

package exception;

/**
 * 异常处理机制中的try-catch
 * 语法:
 * try{
 *     代码片段...
 * }catch(XXXException e){
 *     出现错误后的补救措施(B计划)
 * }
 */
public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        /*
            try{}语句块不能单独写，后面要么跟catch语句块要么跟finally语句块

            异常处理机制关注的是:明知道程序可能出现某种错误，但是该错误无法通过修改逻辑
            完全规避掉时，我们会使用异常处理机制，在出现该错误是提供一种补救办法。
            凡是能通过逻辑避免的错误都属于bug！就应当通过逻辑去避免!
         */
        try {
//            String str = null;
//            String str = "";
            String str = "a";
        /*
            若str=null的情况
            当JVM执行到下面代码时:str.length()会出现空指针，此时虚拟机就会根据该情况
            实例化一个对应的异常实例出来，即:空指针异常实例 NullPointerException实例
            然后将程序从一开始执行到报错这句话的过程设置到该异常实例中，此时该异常通过
            类型名字可以表达出现了什么错误，并将来可以通过输出错误信息来得知错误出现在那里
            虚拟机会将该异常抛出
            当某句代码抛出了一个异常时，JVM会做如下操作:
            1:检查报错这句话是否有被异常处理机制控制(有没有try-catch)
              如果有，则执行对应的catch操作，如果没有catch可以捕获该异常则视为没有
              异常处理动作
            2:如果没有异常处理，则异常会被抛出当当前代码所在的方法之外由调用当前方法的
              代码片段处理该异常
         */
            System.out.println(str.length());//抛出空指针异常
            System.out.println(str.charAt(0));
            System.out.println(Integer.parseInt(str));
            /*
                当try中某句代码报错后，就会跳出try执行下面对应的catch块，执行后就会
                退出catch继续向后执行。因此try语句块中报错代码以下的内容都不会被执行
             */
            System.out.println("!!!!!!!!!!!!!!");
//        }catch(NullPointerException e){
//            //这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug
//            System.out.println("出现了空指针，并解决了!");
//        }catch(StringIndexOutOfBoundsException e){
//            System.out.println("处理字符串下标越界问题!");
//        }
        /*
            当try语句块中可能出现的几种不同异常对应的处理办法相同时，可以采取合并
            catch的做法，用同一个catch来捕获这几种可能出现的异常，而执行措施使用
            同一个。
         */
        }catch(NullPointerException|StringIndexOutOfBoundsException e){
            System.out.println("处理空指针或下标越界!");
        /*
            当catch捕获某个超类型异常时，那么try语句块中出现它类型异常时都可以被这个
            catch块捕获并处理。

            如果多个catch捕获的异常之间存在继承关系时，一定是子类异常在上超类异常在下
         */
        }catch(Exception e){
            System.out.println("反正就是出了个错!");
        }
        System.out.println("程序结束了...");
    }
}

finally块

finally块是异常处理机制中的最后一块

  • finally可以直接跟在try语句块之后
  • finally可以跟在最后一个catch块之后
  • fianlly下面不能再定义catch块
特点:

只要程序执行到异常处理机制中(执行到try语句块中)，无论try中的代码是否出现异常，finally最终都必定执行

作用:

通常用来执行释放资源这一类操作。例如IO操作完毕后的流关闭。

例
package exception;

/**
 * finally块
 */
public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        try {
            String str = "null";
            System.out.println(str.length());
            return;//结束方法，结束前finally还是要执行的
        } catch (Exception e) {
            System.out.println("出错了");
        }finally {
            System.out.println("finally中的代码执行了");
        }
        System.out.println("程序结束了");
    }
}
在IO中的应用
package exception;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 异常处理机制在IO中的应用
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("./fos.dat");
            fos.write(1);
        } catch (IOException e) {
            System.out.println("出错了");
        } finally {
            try {
                if(fos!=null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

自动关闭特性

JDK7之后java推出了一个新特性:自动关闭特性可以更优雅的在异常处理机制中关闭IO

语法
try(
   声明并初始化IO对象
){
   IO操作
}catch(IOException e){//catch各种IO异常
   ...
}
例
package exception;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * JDK7之后java推出了一个新特性:自动关闭特性
 * 可以更优雅的在异常处理机制中关闭IO
 */
public class AutoCloseableDemo {
    public static void main(String[] args) {
        //自动关闭特性是编译器认可的，编译后就变成FinallyDemo2的样子
        try(
                FileOutputStream fos = new FileOutputStream("fos.dat");
        ){
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

总结

java将流分为两类:节点流与处理流:

  • 节点流:也称为低级流.

    节点流的另一端是明确的,是实际读写数据的流,读写一定是建立在节点流基础上进行的.

  • 处理流:也称为高级流.

    处理流不能独立存在,必须连接在其他流上,目的是当数据流经当前流时对数据进行加工处理来简化我们对数据的该操作.

实际应用中,我们可以通过串联一组高级流到某个低级流上以流水线式的加工处理对某设备的数据进行读写,这个过程也成为流的连接,这也是IO的精髓所在.

缓冲流

缓冲流是一对高级流，在流链接中链接它的目的是加快读写效率。缓冲流内部默认缓冲区为8kb，缓冲流总是块读写数据来提高读写效率。

java.io.BufferedOutputStream缓冲字节输出流，继承自java.io.OutputStream
常用构造器
  • BufferedOutputStream(OutputStream out)：创建一个默认8kb大小缓冲区的缓冲字节输出流，并连接到参数指定的字节输出流上。
  • BufferedOutputStream(OutputStream out,int size)：创建一个size指定大小(单位是字节)缓冲区的缓冲字节输出流，并连接到参数指定的字节输出流上。
常用方法
flush()：强制将缓冲区中已经缓存的数据一次性写出

缓冲流的写出方法功能与OutputStream上一致，需要知道的时write方法调用后并非实际写出，而是先将数据存入缓冲区(内部的字节数组中)，当缓冲区满了时会自动写出一次。
java.io.BufferedInputStream缓冲字节输出流，继承自java.io.InputStream
常用构造器
  • BufferedInputStream(InputStream in)：创建一个默认8kb大小缓冲区的缓冲字节输入流，并连接到参数指定的字节输入流上。
  • BufferedInputStream(InputStream in,int size)：创建一个size指定大小(单位是字节)缓冲区的缓冲字节输入流，并连接到参数指定的字节输入流上。
常用方法
缓冲流的读取方法功能与InputStream上一致，需要知道的时read方法调用后缓冲流会一次性读取缓冲区大小的字节数据并存入缓冲区，然后再根据我们调用read方法读取的字节数进行返回，直到缓冲区所有数据都已经通过read方法返回后会再次读取一组数据进缓冲区。即:块读取操作

对象流

对象流是一对高级流，在流链接中的作用是完成对象的序列化与反序列化

序列化：是对象输出流的工作，将一个对象按照其结构转换为一组字节的过程。

反序列化：是对象输入流的工作，将一组字节还原为对象的过程。

java.io.ObjectInputStream对象输入流，继承自java.io.InputStream
常用构造器

ObjectInputStream(InputStream in)：创建一个对象输入流并连接到参数in这个输入流上。

常用方法

Object readObject()：进行对象反序列化，将读取的字节转换为一个对象并以Object形式返回(多态)。

如果读取的字节表示的不是一个java对象会抛出异常:java.io.ClassNotFoundException

java.io.ObjectOutputStream对象输出流，继承自java.io.OutputStream
常用构造器

ObjectOutputStream(OutputStream out)：创建一个对象输出流并连接到参数out这个输出流上

常用方法

void writeObject(Object obj)：进行对象的序列化，将一个java对象序列化成一组字节后再通过连接的输出流将这组字节写出。

如果序列化的对象没有实现可序列化接口:java.io.Serializable就会抛出异常:java.io.NotSerializableException

序列化接口java.io.Serrializable

该接口没有任何抽象方法，但是只有实现了该接口的类的实例才能进行序列化与反序列化。

实现了序列化接口的类建议显示的定义常量:static final long serialVersionUID = 1L;

可以为属性添加关键字transient，被该关键字修饰的属性在序列化是会被忽略，达到对象序列化瘦身的目的。

字符流

java将流按照读写单位划分为字节与字符流。字节流以字节为单位读写，字符流以字符为单位读写。

转换流java.io.InputStreamReader和OutputStreamWriter

功能无需掌握，了解其核心意义:

1:衔接其它字节与字符流

2:将字符与字节进行转换

相当于是现实中的"转换器"

缓冲字符输出流

缓冲字符输出流需要记住的是PrintWriter和BufferedReader

作用:

1:块写或块读文本数据加速

2:可以按行写或读字符串

java.io.PrintWriter 具有自动行刷新的缓冲字符输出流
常用构造器

PrintWriter(String filename) :可以直接对给定路径的文件进行写操作

PrintWriter(File file):可以直接对File表示的文件进行写操作

上述两种构造器内部会自动完成流连接操作。

PrintWriter(OutputStream out):将PW链接在给定的字节流上(构造方法内部会自行完成转换流等流连接)

PrintWriter(Writer writer):将PW链接在其它字符流上

PrintWriter(OutputStream out,boolean autoflush)

PrintWriter(Writer writer,boolean autoflush)

上述两个构造器可以在链接到流上的同时传入第二个参数，如果该值为true则开启了自动行刷新功能。

常用方法

void println(String line)：按行写出一行字符串

特点

自动行刷新，当打开了该功能后，每当使用println方法写出一行字符串后就会自动flush一次

java异常处理机制:
  • 异常处理机制是用来处理那些可能存在的异常，但是无法通过修改逻辑完全规避的场景。
  • 而如果通过修改逻辑可以规避的异常是bug，不应当用异常处理机制在运行期间解决！应当在编码时及时修正

try语句块用来包含可能出错的代码片段

catch用来捕获并处理对应的异常，可以定义多个，也可以合并多个异常在一个catch中。

今天你学Java了吗
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java阶段三Day03
今天你学Java了吗
05-24 777
今天是学习Java阶段三的第三天，学习JS的一些知识，回顾了基础的如关系符、循环语句、条件语句等知识，了解了BOM和DOM，学习了前端设计模式
Java阶段四Day06
今天你学Java了吗
06-16 746
今天是学习Java阶段四的第六天，讲解了关于配置响应中消除Null的属性、配置跨域、和学习运用formData可以不用在请求中添加@ResquestBody注解
Java阶段一Day20
今天你学Java了吗
04-11 1267
今天是学习Java阶段一的第二十天，今天主要讲了异常的剩余要点，如自定义异常、常见的catch的方法，重头戏就是关于网络的讲解，三次握手、四次挥手，如何设计Client、Server来实现网络间通讯
java第一阶段（day17）终篇
sunshine195的博客
03-20 735
...
Java第一阶段（day07）迷你共享单车
sunshine195的博客
02-23 1661
...
Java_day19上课资料.zip
04-01
"Java_day19上课资料.zip"这个压缩包文件很可能是某个教学课程的第19天的学习资源，包含了深入学习Java的关键知识点。配合提供的视频链接（），我们可以期待获得更丰富的视听学习体验。 在Java的学习过程中，第19天...
Java基础_第二阶段-day18每日作业卷答案1
08-08
在Java开发中，BeanUtils工具类是Apache Commons库中的一个组件，它提供了一种方便的方式来操作JavaBean的属性，简化了对象属性的设置和获取。本篇将深入讲解BeanUtils工具类的使用及其在实际编程中的应用。 1. **...
Java学习day01-day15学习资料
04-05
3. **day04**: 没有具体的主题，但通常在学习Java的早期阶段，这部分可能讲解了异常处理（Exception Handling），以及如何使用try-catch块来捕获和处理程序运行时可能出现的问题。 4. **day05**: 重点可能是循环...
04-就业阶段_框架一课件 JAVA
03-19
【标题】"04-就业阶段_框架一课件 JAVA" 涵盖了Java开发者在就业阶段所需掌握的关键技术领域，特别是针对各种框架的学习和应用。这是一系列深入探讨Java开发中重要框架的课程内容，旨在提升学员的技能水平，使其能够...
week1day4.java
03-26
在Java编程语言的学习过程中，"week1day4.java"很可能是一个初学者在第一周第四天接触到的练习或示例代码。这个文件名暗示了这是一个按照时间进度编排的学习资源，可能涵盖了一些基础概念或者特定主题的实践应用。...
配置Java开发环境
Broken_x的博客
07-10 1557
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 526
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
【Go系列】 Sync并发控制
u013379032的博客
07-14 640
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
elk部署springboot
Chihirozy的博客
07-11 383
elk部署springboot。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 281
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
从零手写实现 nginx-27-return 指令
最新发布
07-14 473
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 788
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
uboot的功能
weixin_43732386的博客
07-13 34
uboot=裸机程序，uboot的核心功能是启动内核。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 507
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今天你学Java了吗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值