【Java核心技术卷】I/O详析

最新推荐文章于 2024-08-11 04:03:03 发布
最新推荐文章于 2024-08-11 04:03:03 发布
阅读量5.1k 收藏 148
点赞数 34
文章标签： Java核心技术卷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42322103/article/details/100651049
版权

文章目录

概述

java的IO系统的设计是为了实现 “文件、控制台、网络设备” 这些IO设置的通信，它建立在流之上，输入流读取数据,输出流写出数据,不同的流类,会读/写某个特定的数据源。

数据源（Data Source）顾名思义，数据的来源

在展开整个面之前有必要弄清楚三个概念： 比特、字节和字符

  • Bit最小的二进制单位 ，是计算机的操作部分，取值0或者1，也是计算机网络的物理层最小的传输单位。
  • Byte是计算机操作数据的最小单位由8位bit组成 取值（-128-127）
  • Char是用户的可读写的最小单位，在Java里面由16位bit组成 取值（0-65535）

Java将IO进行了封装，所以我们看到的都是API，我们能做到的就是理解熟悉这些API，灵活运用即可。如果想要深入理解IO，建议从C语言入手，因为C语言是唯一一个能将IO讲明白的高级语言。

Java的IO系统是Java SE学习的重要一环，Java的文件操作 , Java网络编程基于此。它对你理解Tomcat的架构等也是必备的。


Java io基本概念

关于流

流是一串连续不断的数据的集合，你可以把它理解为水管里的水流，在水管的源头有水的供应，在另一端则是娟娟的水流，数据写入程序可以理解为供水，数据段会按先后顺序形成一个长的数据流。

对数据读取程序来说，不知道流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。

流的分类

Java IO中包含字节流、字符流。按照流向还分为输入流，输出流

  • 字节流：操作byte类型数据，主要操作类是OutputStream、InputStream的子类；不用缓冲区，直接对文件本身操作。
  • 字符流：操作字符类型数据，主要操作类是Reader、Writer的子类；使用缓冲区缓冲字符，不关闭流就不会输出任何内容。

输入流和输出流的区分很简单：输入流是把数据写入存储介质的。输出流是从存储介质中把数据读取出来

Java io框架

一、以字节为单位的输出流的框架图

（1）框架图图示

图示基于Jdk1.8
在这里插入图片描述

（2）OutputStream详解

OutputStream是抽象类，它是所有字节输出流的类的超类，它与InputStream构成了IO类层次结构的基础。

它展示了五种方法,子类针对这五个方法进行拓展, 不管是哪种介质，大都使用同样的这5种方法
在这里插入图片描述
?
值得注意的是 wirte(int b)
它虽然接收0~255的整数，但是实际上会写出一个无符号字节，因为Java是没有无符号字节整型数据的，所以这里用int来代替。


?
下面来看这两个方法，可用于多个字节的处理，相比上面一次处理一个字节效率要更高。

void wirte(byte[] b)
void write(byte[] b ,int off ,int len)

参数

  • b：数据读入的数组
  • off 第一个读入的字节 应该被放置的位置在b的偏移量
  • len 读入字节的最大数量

这个还是比较好理解的，就不多说了。


?
当结束一个流的操作的时候 会调用close方法将其关闭，释放与这个流相关的所有资源，如文件句柄或端口。

文件句柄
在文件I/O中，要从一个文件读取数据，应用程序首先要调用操作系统函数并传送文件名，并选一个到该文件的路径来打开文件。该函数取回一个顺序号，即文件句柄（file handle），该文件句柄对于打开的文件是唯一的识别依据。要从文件中读取一块数据，应用程序需要调用函数ReadFile，并将文件句柄在内存中的地址和要拷贝的字节数传送给操作系统。当完成任务后，再通过调用系统函数来关闭该文件。

其实关于结束一个流，在Java6及之前有一个很经典的 完成清理的释放模式

     OutputStream out = null;
        try {
            out = new FileOutputStream("/temp/data.txt");
        }catch (IOException ex){
            System.err.println(ex.getMessage());
        }finally {
            if(out != null){
                try {
                    out.close();
                }catch (IOException ex){
                    //忽略
                }
            }
        }

这个不仅可以用于流，还可以用于socket，通道，JDBC的连接

在Java7之后出现一个语法糖 — 带资源的 try构造。写法类似于这种：

 try(OutputStream out = new FileOutputStream("/temp/data.txt")){
            //处理输出流
        }catch (IOException ex){
            System.err.println(ex.getMessage());
        }

由于这个很重要，我们深究一下：

AutoCloseable接口对JDK7新添加的带资源的try语句提供了支持，这种try语句可以自动执行资源关闭过程。

只有实现了AutoCloseable接口的类的对象才可以由带资源的try语句进行管理。AutoCloseable接口只定义了close()方法：


Closeable接口也定义了close()方法。实现了Closeable接口的类的对象可以被关闭。

但是注意！！！ 从JDK7开始，Closeable扩展了AutoCloseable。因此，在JDK7中，所有实现了Closeable接口的类也都实现了AutoCloseable接口。

关于带资源的try语句的3个关键点：

  1. 由带资源的try语句管理的资源必须是实现了AutoCloseable接口的类的对象。
  2. 在try代码中声明的资源被隐式声明为final。
  3. 通过使用分号分隔每个声明可以管理多个资源。

此外请记住，所声明资源的作用域被限制在带资源的try语句中。


我们看一下Java编译器为我们解析语法糖tryWithResource 做了哪些事情：

原本的代码

public class TryWith {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("c:\\Test.jad"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

反编译之后

public class TryWith
{
    public TryWith()
    {
    }
    public static void main(String args[])
    {
        try
        {
            BufferedReader br = new BufferedReader(new FileReader("c:Test.jad"));
            String line;
            try
            {
                while((line = br.readLine()) != null) 
                    System.out.println(line);
            }
            catch(Throwable throwable)
            {
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
                throw throwable;
            }
            br.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

?
最后一个方法是flush()
意思是冲刷输出流，也就是将所有缓冲的数据发送到目的地。这个在 子类 缓冲流BufferedOutputStream 中体现最为明显


（3）OutputStream子类

关于子类的实现这里更多地知识点一下，如果一一详细介绍，这篇博文实在太长了。（所以把重要的放在下一篇写）

  • ByteArrayOutputStream 是字节数组输出流。写入ByteArrayOutputStream的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。
  • PipedOutputStream 是管道输出流，它和PipedInputStream一起使用，能实现多线程间的管道通信。
  • FilterOutputStream 是过滤输出流。它是DataOutputStream，BufferedOutputStream和PrintStream等的超类。
  • DataOutputStream 是数据输出流。它是用来装饰其它输出流，它“允许应用程序以与机器无关方式向底层写入基本 Java 数据类型”。（简单来说就是以二进制格式写出所有的基本Java类型）
  • BufferedOutputStream 是缓冲输出流。它的作用是为另一个输出流添加缓冲功能。
  • PrintStream 是打印输出流。它是用来装饰其它输出流，能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
  • FileOutputStream 是文件输出流。它通常用于向文件进行写入操作。
  • ObjectOutputStream 是对象输出流。它和ObjectInputStream一起，用来提供对“基本数据或对象”的持久存储。

（4）引申：打印流

平时我们在控制台打印输出，是调用 print 方法和 println 方法完成的，这两个方法都来自于java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

打印流PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

PrintStream特点：

  1. 只负责数据的输出，不负责数据的读取
  2. 与其他输出流不同，Printstream 永远不会抛出IOException
  3. 有特有的方法，print，println void print（任意类型的值）void printin（任意类型的值并换行）构造方法：

API信息

Print Stream（File file）：输出的目的地是一个文件PrintStream（Outputstream out）：输出的目的地是一个字节输出流PrintStream（string fileName）：输出的目的地是一个文件路径
PrintStream extends OutputStream继承自父类的成员方法：
public void close（）：关闭此输出流并释放与此流相关联的任何系统资源。
public void flush（）：刷新此输出流并强制任何缓冲的输出字节被写出。
public void write（byte[] b）：将b.length字节从指定的字节数组写入此输出流。
public void write（byte[]b，int off，int len）：从指定的字节数组写入len字节，从偏移量off开始输出到此输出流。
public abstract void write（int b）：将指定的字节输出流。

注意：
如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表97->a
如果使用自己特有的方法print/println方法写数据，写的数据原样输出97->97

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Main{
    public static void main(String[] args) throws FileNotFoundException {
        //创建打印流PrintStream对象，构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("C:\\Users\\JunQiao Lv\\Desktop\\文件\\b.txt");
        //如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表97->a
        ps.write(97);
        //如果使用自己的特有方法print/println方法写数据，写的数据原样输出97->97
        ps.println(97);
        ps.println(8.8);
        ps.println('a');
        ps.println("HelloZZU");
        ps.println(true);
        //释放资源
        ps.close();
    }
}

结果:
在这里插入图片描述
PrintStream可以改变输出语句的目的地（打印流的流向）输出语句，默认在控制台输出

使用System.setout方法改变输出语句的目的地改为参数中传递的打印流的目的地
static void setout（PrintStream out） 重新分配标准*输出流。

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Main{
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("我是在控制台输出的");
        PrintStream ps = new PrintStream("C:\\Users\\JunQiao Lv\\Desktop\\文件\\b.txt");
        System.setOut(ps); //把输出语句的自的地改变为打印流的目的地
        System.out.println("我在打印流的目的中输出");
        ps.close();
    }
}

结果:
在这里插入图片描述
在这里插入图片描述

PringtStream是存在一些问题的:

  1. 它的输出与平台有关, 对于编写必须遵循明确协议的网络客户端和服务器来说是个灾难
  2. 它假定所在平台的默认编码方式,这个可能不是服务器或客户端所期望的
  3. 它吞掉了所有的异常

二、以字节为单位的输入流的框架图

（1）框架图图示

图示版本Jdk1.8
在这里插入图片描述

（2）InputStream详解

它提供了写入数据的基本方法，圈起来的是需要重点关注的：
在这里插入图片描述

?
没有参数的read()方法: 从输入流的数据源中读入一个字节数据转为0~255的int返回, 流的结束通过返回-1来表示

这个应与OutputStream的write(int b）方法放在一起理解

.read()方法会等待并阻塞其后任何代码的执行,直到有1个字节可供读取.输入输出可能很慢,所以如果程序还要做其他事情,尽量把I/O放在单独的线程中.

read读取一个无符号字节,注意这里要求进行类型转换.可以通过下面的方法 将手里的有符号字节转换成无符号字节

int i = b>=0?b:256+b;

?
另外还有两个read() 返回-1的时候 都表示流的结束
不结束的时候 返回值为实际读取到的字节数

?
如果不想等待所需的全部字节都立即可用,可以使用available()方法来确定不阻塞的情况下有多少字节可以读取.它会返回可以读取的最少字节数(事实上还能够读取更多的字节),但至少读取available()建议的字节数

?
在少数的情况下,可能会希望跳过数据不进行读取.skip()方法会完成这项任务.
与读取文件相比,在网络连接中它的用处不大.网络连接是顺序的,一般会很慢.所以与跳过这些数据(不读取)相比,读取并不会耗费太长的时间.
文件是随机访问的,所以要跳过数据,可以简单地实现为重新指定文件指针的位置,而不需要处理要跳过的各字节.

?
InputStream类还有三个不太常用的方法，就是没圈起来的

mark()方法和reset()方法常被合起来称之为标记与重置

为了重新读取数据,需要用mark()方法标记流的当前位置.在以后的某个时刻,可以用reset()方法把流重置到之前标记的位置.
接下来的读取操作会烦会从标记位置开始的数据.

不过,不能随心所欲地向前重置任意远的位置.从标记处读取和重置的字节数由mark()的readAheadlimit参数确定.重置太远会有IO异常.

一个很重要的问题是,一个流在任何时刻都只能有一个标记.标记的第二个位置会清除第一个标记.

?
markSupported()方法是否返回true.如果返回true,这个流就支持标记和重置

Java.io仅有两个始终支持标记的输入流类是 BufferedInputStream和ByteArrayInputStream 而其他输入流(如TelnetInputStream)需要串联到缓冲的输入流才支持标记.

TelnetInputStream在文档中没有展示，被隐藏在了sun包下，这个类我们是直接接触不到的
关于串联其实是设计模式的思想，后面会单独详解

（3）InputStream子类

  • ByteArrayInputStream 是字节数组输入流。它包含一个内部缓冲区，该缓冲区包含从流中读取的字节；通俗点说，它的内部缓冲区就是一个字节数组，而ByteArrayInputStream本质就是通过字节数组来实现的。
  • PipedInputStream 是管道输入流，它和PipedOutputStream一起使用，能实现多线程间的管道通信。
  • FilterInputStream 是过滤输入流。它是DataInputStream和BufferedInputStream的超类。
  • DataInputStream 是数据输入流。它是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。
  • BufferedInputStream 是缓冲输入流。它的作用是为另一个输入流添加缓冲功能。
  • FileInputStream 是文件输入流。它通常用于对文件进行读取操作。
  • ObjectInputStream 是对象输入流。它和ObjectOutputStream一起，用来提供对“基本数据或对象”的持久存储。

（4）引申：缓冲流（含字节输出流的内容）

BufferedOutputStream

BufferedOutputStream类将写入的数据存储在缓冲区中（一个名字是buf的保护字节数组字段），直到缓冲区满或者刷新输出流。然后它将数据一次性写入底层输出流。
在这里插入图片描述

这里需要好好说一下flush方法了

关于缓冲流，如果输出流有一个1024字节的缓冲区，未满之前，它会一直等待数据的到达，如果是网络发送数据的话，因为缓冲区的等待，会产生死锁，flush（）方法可以强迫缓冲的流发送数据。

有一个细节就是当close缓冲流的时候会自动调用flush方法

具体方法如下:
在这里插入图片描述

BufferedInputStream
值得一提的是它的构造方法:
在这里插入图片描述
第一个参数是底层流，可以从中读取未缓冲的数据。或者向其写入数据。
如果给出第二个参数，它会指定缓冲区的字节数，否则输入流的缓冲区大小设置为2048字节.输出流的缓冲区大小设置为512字节.缓冲区的理想大小取决于所缓冲的流是何种类型.

其他方法与超类类似:
在这里插入图片描述

（5）引申：数据流（含字节输出流的内容）

DataInputSteam和DataOutputSteam类提供了一些方法,可以用二进制格式读/写Java的基本数据类型和字符串.

DataOutputSteam 写入的每一种数据 DatainputSteam都能够读取.

所有的数据都以big-endian格式写入.

小端格式和大端格式(Little-Endian&Big-Endian)属于计算机组成原理的内容
不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序。
最常见的有两种：
1． Little-endian：将低序字节存储在起始地址（低位编址）
2． Big-endian：将高序字节存储在起始地址（高位编址）

三、以字符为单位的输入流和输出流的框架图

（1）框架图图示

在这里插入图片描述

  • CharArrayReader 是字符数组输入流。它用于读取字符数组r。操作的数据是以字符为单位！

  • PipedReader 是字符类型的管道输入流。它和PipedWriter一起是可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedWriter和PipedReader配套使用。

  • FilterReader 是字符类型的过滤输入流。

  • BufferedReader 是字符缓冲输入流。它的作用是为另一个输入流添加缓冲功能。

  • InputStreamReader 是字节转字符的输入流。它是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。

  • FileReader 是字符类型的文件输入流。它通常用于对文件进行读取操作。
    在这里插入图片描述

  • CharArrayWriter 是字符数组输出流。它用于读取字符数组。操作的数据是以字符为单位！

  • PipedWriter 是字符类型的管道输出流。它和PipedReader一起是可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedWriter和PipedWriter配套使用。

  • FilterWriter 是字符类型的过滤输出流。

  • BufferedWriter 是字符缓冲输出流。它的作用是为另一个输出流添加缓冲功能。

  • OutputStreamWriter 是字节转字符的输出流。它是字节流通向字符流的桥梁：它使用指定的 charset 将字节转换为字符并写入。

  • FileWriter 是字符类型的文件输出流。它通常用于对文件进行读取操作。

  • PrintWriter 是字符类型的打印输出流。它是用来装饰其它输出流，能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

（2）框架详解

对于Unicode文本，可以使用抽象类Reader和Writer的子类。

小知识点： Java内置字符集是Unicode的UTF-16编码

很多人都将Reader及其子类称之为 阅读器, 将Writer及其子类称之为书写器，个人认为这是一个不错的做法, 后面会探讨Java io的设计模式，两个简称会用到。

Reader类的基本方法
在这里插入图片描述

read()方法将一个Unicode字符（实际上是UTF-16码点）作为一个 int返回，可以是0~65535之间的一个值，等遇到流结束的时候返回-1

read(char[] cbuf)
read(char[] cbuf,int off,int len)

第一个方法尝试使用字符填充数组cbuf，并返回实际读取到的字节数，等遇到流结束的时候返回-1
第二个方法尝试将len个字符读入cbuf的数组中（从off开始 长度为len）它会返回实际读取到的字节数，如果遇到流结束的时候返回-1

skip(Long n)等其他方法与InputStream基本上类似。

Writer类的基本方法
在这里插入图片描述
有了前面的基础，这些api也很好理解的，你会发现Writer中有一个append方法
它和writer方法最大区别是，append方法中的参数可以为null，而writer中的参数不能为null


Reader和Writer最重要的具体子类是InputStreamReader和OutputStreamWirter, 以这个为例我们看一下它的实现过程，其他类类似

关于InputStreamReader：
它包含一个底层输入流，可以从数据源中读取原始字节。它根据指定的编码方式，将这些字节转换成Unicode字符。

关于OutputStreamWriter
它从运行的程序中接收Unicode字符，然后使用指定的编码方式将这些字符转换成字节，然后字节写入底层输入流中。


有一道Java io的面试题是这样问的：字节流和字符流之间如何相互转换？
其实就是我们说的这两个具体子类，回答可以是下面的说法:
整个IO包实际上分为字节流和字符流，但是除了这两个流之外，还存在一组字节流-字符流的转换类。
OutputStreamWriter是Writer的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流输出对象。
InputStreamReader是Reader的子类，将输入的字节流变为字符流，即将一个字节流的输入对象变为字符流的输入对象。

（3）引申：过滤器流

这部分内容是我学习《Java网络编程》第四版摘录下来的

Java提供了很多的过滤器类,可以附加到原始流中,在原始字节和各种格式之间进行转换.。

过滤器有两种版本：过滤器流及阅读器和书写器。

过滤器流仍然主要将原始数据作为字节处理，通过压缩数据或解释为二进制数字。阅读器和书写器处理各种编码文本的特殊情况，如UTF-8和ISO 8859-1。它以链的形式进行组织。链中的每个环节都接收前一个过滤器或流的数据，并把数据传递给链中的下一个环节。在这个示例中，从本地网络接口接收到一个加密的文本文件，在这里本地代码将这个文件表示TelnetInputStream。通过一个BufferedInputtStream缓冲这个数据来加速整个过程。由一个CipherInputStream将数据解密。再由一GZIPInputStream解压解密后的数据。一个InputStream将解压后的数据转换为Unicode文本。最后，文本由应用程序进行处理。

在这里插入图片描述
这其中体现了一些设计模式

Java io中的设计模式

适配器模式

关于适配器模式，这里回顾一下：

定义： 将一个类的接口转换成客户期望的另一个接口

说的通俗点就是 笔记本电脑的电源就是个适配器吧，不管它外部电压是多少，只要经过了适配器就能转变成我电脑需要的伏数

作用： 使原本接口不兼容的类可以一起工作

类型： 结构型

演示：
（1）类适配器模式
定义一个目标接口

public interface Target {
    void request();
}

实现接口的类

public class ConcreteTarget implements Target{
    @Override
    public void request() {
        System.out.println("ConcreteTarget目标方法");
    }
}

被适配者

public class Adaptee {
    public void adapteeRequest(){
        System.out.println("被适配者的方法");
    }

}

关键 ： 继承被适配者且继承目标接口

//继承被适配者
public class Adapter extends Adaptee implements Target{
    @Override
    public void request() {
        super.adapteeRequest();
    }
}

类图：
在这里插入图片描述
测试：

public class Test {
    public static void main(String[] args) {
        Target target = new ConcreteTarget();
        target.request();

        Target adapterTarget = new Adapter();
        adapterTarget.request();
    }
}

结果：
在这里插入图片描述

（2）下面来看一下对象适配器模式
和类适配器模式相比 只有一处发生了变化

Adapter 类 之前还继承了Adaptee，现在没有继承

//继承被适配者
public class Adapter implements Target{
    private Adaptee adaptee = new Adaptee();
    @Override
    public void request() {
        adaptee.adapteeRequest();
    }
}

类图：
在这里插入图片描述
前面已经说了字节流和字符流之间的相互转换靠的是OutputStreamWriter和InputStreamReader，其实它们充当了适配器，如果不相信可以翻源码。
在这里插入图片描述
这里举个转换的例子：

BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("test.txt"))));

装饰者模式

同样回顾一下：

定义：在不改变原有对象的基础之上，将功能附加到对象上

作用： 提供了比继承更有弹性的替代方案（扩展原有对象功能）

类型： 结构型

使用场景：

  1. 扩展一个类的功能或给一个类添加附加职责
  2. 动态的给一个对象添加功能，这些功能可以再动态的撤销

演示

不满足装饰者模式的情况
以买煎饼为例

public class Battercake {
    protected String getDesc(){
        return "煎饼";
    }
    protected int cost(){
        return 5;
    }
}

煎饼 加一个鸡蛋

public class BattercakeWithEgg extends Battercake{
    @Override
    protected String getDesc() {
        return super.getDesc()+"加一个鸡蛋";
    }

    @Override
    protected int cost() {
        return super.cost()+ 1;
    }
}

煎饼加一个鸡蛋 加一个烤肠

public class BattercakeWithEggSausage extends BattercakeWithEgg{
    @Override
    protected String getDesc() {
        return super.getDesc()+"加一根香肠";
    }

    @Override
    public int cost() {
        return super.cost()+2;
    }
}

测试:

public class Test {
    public static void main(String[] args) {
        Battercake battercake = new Battercake();
        System.out.println(battercake.getDesc()+ " 销售价格为："+battercake.cost());

        BattercakeWithEgg battercakeWithEgg = new BattercakeWithEgg();
        System.out.println(battercakeWithEgg.getDesc()+ " 销售价格为："+battercakeWithEgg.cost());

        BattercakeWithEggSausage battercakeWithEggSausage = new BattercakeWithEggSausage();
        System.out.println(battercakeWithEgg.getDesc()+ " 销售价格为："+battercakeWithEgg.cost());
    }
}

我们看一下它的UML类图 很容易发现 单纯的继承关系
在这里插入图片描述
如果一个煎饼加两个鸡蛋 或者别的其他的呢 容易引起"类爆炸"

所以为了解决这个问题 引入装饰着模式,下面让我们看一下满足装饰者模式的写法

这里被装饰的是煎饼 装饰者是鸡蛋和香肠

创建煎饼的抽象类

public abstract class ABattercake {
    protected abstract String getDesc();
    protected abstract int cost();
}

创建煎饼

public class Battercake extends ABattercake{
    protected String getDesc(){
        return "煎饼";
    }
    protected int cost(){
        return 5;
    }
}

创建装饰着的抽象类

public class AbstractDecorator extends ABattercake{
    private ABattercake aBattercake;

    public AbstractDecorator(ABattercake aBattercake) {  //注入煎饼
        this.aBattercake = aBattercake;
    }

    @Override
    protected String getDesc() {
        return this.getDesc();
    }

    @Override
    protected int cost() {
        return this.cost();
    }
}

鸡蛋的装饰者

public class EggDecorator extends AbstractDecorator {
    public EggDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc()+"加一个鸡蛋";
    }

    @Override
    protected int cost() {
        return super.cost()+1;
    }
}

香肠的装饰者

public class SausageDecorator extends AbstractDecorator{
    public SausageDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc()+"加一根香肠";
    }

    @Override
    protected int cost() {
        return super.cost()+1;
    }
}

类图:
在这里插入图片描述
测试:

public class Test {
    public static void main(String[] args) {
       ABattercake  aBattercake;
       aBattercake = new Battercake();
       aBattercake = new EggDecorator(aBattercake);
       aBattercake = new EggDecorator(aBattercake);
       aBattercake = new SausageDecorator(aBattercake);
       System.out.println(aBattercake.getDesc() + " 销售价格为:" +aBattercake.cost());
    }
}

结果:
在这里插入图片描述
类图:
在这里插入图片描述
嵌套的风格有没有让你回忆出点什么？

这个时候我们就需要关注过滤器流了 FilterInputStream和 FilterOutputStream，这里以FilterInputStream为例：
在这里插入图片描述
举个例子

DataInputStream  dataInputStream = new DataInputStream(new FileInputStream(new File("text.txt")));

其中DataInputStream给FileInputStream起到包装作用。

Java的IO流装饰模式很明显体现在这两点：
1、有原数据、可以被包装的。
2、包装类，能包装其他事物的，就是在原事物上添加点东西。

复盘

文章内容是有点多的，其实重要的是一定要理解这几个概念：

  1. Java的IO建立在流之上，它的体系建立在InputStream和OutputStream抽象类的基础上，这两个抽象类的基本方法被子类拓展实现了针对某一数据源的处理，因此一定要对它们的基本方法有着清晰的认识。尤其注意它们用于处理字节。
  2. 在InputStream和OutputStream基础上，又根据实现的具体子类的功能划分出了缓冲流、数据流等。
  3. 在它们的子类中还有过滤器流FilterInputStream和 FilterOutputStream，它们属于装饰者模式中的装饰者，拓展了被装饰者的功能。
  4. Writer和Reader被称为书写器和阅读器，它的具体子类InputStreamReader和OutputStreamWriter实现了字节到字符的过渡，运用了适配器模式的设计模式。

Java IO涉及的东西还并未结束，毕竟它是Java的一些高级技术的基石，而且也是一些大厂面试必不可少的东西，打得越牢固越好。下面要么再写一篇，要么在该篇继续补充，欢迎各位拍砖~

沉晓
关注
近5年133个Java面试问题列表
02-14
Java NIO (New I/O) - **NIO**：Java NIO 是 Java 新一代输入/输出处理方式，提供了比传统 IO 更高效的数据处理能力。NIO 包括 Channel（通道）、Buffer（缓冲区）和 Selector（选择器）等核心组件。 - **Channel**...
Java核心技术 卷1-总结-11
weixin_42583701的博客
04-21 859
例如，如果试图向集中添加一个对象，而这个对象在集中已经存在，这个添加请求就没有生效，因为集合中不允许有重复的对象。例如队列（queue）：队列接口指出可以在队列的尾部添加元素，在队列的头部删除元素，并且可以查找队列中元素的个数。这些实用方法中的某些方法非常有用，这样，类库的使用者就不必自己重新构建这些方法了。要适当地定义集的 equals 方法：只要两个集包含同样的元素就认为是相等的，而不要求这些元素有同样的顺序。虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元素被访问的次序。
java核心技术卷I
buxiangmafan的博客
11-25 2246
java核心技术卷I
Java 核心技术卷 1PDF版
最新发布
weixin_35814757的博客
08-11 66
Java 核心技术解析：面向对象编程与设计模式 Java 是一种广泛使用的编程语言，其核心技术的掌握对于软件开发尤为重要。《Java 核心技术卷 1》深入探讨了 Java 的基础知识，包括面向对象编程、异常处理、泛型等。本篇文章将围绕这些概念，结合代码示例进行科普，旨在帮助读者更好地理解 Java 的核心技术。 一、面向对...
Java 核心技术卷一 随笔
Jett_Leo的博客
08-05 676
java 核心技术卷一
【Java 核心技术卷 I】，Java高级工程师进阶学习—Java热修复原理
2401_83621384的博客
03-30 784
1.1 块作用域不能在嵌套的两个块中声明同名变量，如int n;int n;该代码由于在嵌套的两个块中出现了同名变量，无法通过编译在 C++ 中，可以在嵌套的块中重定义一个变量。在内层定义的变量会覆盖在外层定义的变量。1.2 条件语句在循环中，检测两个浮点数是否相等需要格外注意，如x!=10;x+=0.1);上述循环不会结束，因为 0.1 无法精确的用二进制表示，所以 x 将从 9.99999999999998 跳到 10.09999999999998。
Java核心技术 卷（一） 学习记录
nnh235991942的博客
03-28 1360
对于Java核心技术这本书的阅读体会摘要
SCJP---试题详析
01-16
7. **输入/输出流**：掌握I/O流的基本概念，包括文件流、字符流、字节流，以及缓冲区的使用。 8. **反射**：理解反射机制，能够动态地获取类的信息并操作类的对象。 9. **泛型**：了解泛型的基本用法，如泛型类、...
SCJP试题详析（中文版）
12-27
6. **输入/输出流(I/O)**：掌握Java I/O流的基本概念，包括文件操作、缓冲流、序列化等。 7. **网络编程**：了解Java网络编程的基础，如Socket编程、URL和URLConnection类的使用。 8. **数据库连接(JDBC)**：掌握...
SCJP试题详析(中文)
09-03
SCJP（Sun Certified Programmer for the Java 2 Platform, Standard Edition）是Java编程领域的一个认证考试，旨在验证候选者对...对于初学者来说，这是一个很好的自我提升工具，能够系统性地学习Java编程的核心概念。
Java专业人士必备的书籍和网站列表：
06-27
3. **《Java核心技术卷I & II》** - Cay S. Horstmann等著。这套书覆盖了Java语言的基础到高级特性，适合所有层次的学习者，从基础语法到高级框架都有涉及。 4. **《Java虚拟机规范》** - Tim Lindholm等著。了解JVM...
java核心技术卷1基础知识整理
qq_39748316的博客
02-23 4492
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
java开发转游戏开发，一文说清！
程序员环西
07-12 1494
基础 JAVA基础 JAVA集合 JAVA多线程并发 网络 数据结构与算法 框架 Spring SpringMVC MyBatis 设计模式 分布式 负载均衡 Zookeeper Redis MQ/kafka 微服务 Netty与RPC Spring Boot Spring Cloud Dubbo 调优 MySQL JVM Tomcat 最后 小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来
Java核心技术卷一、二读书笔记（PDF）分享
ProuHan的博客
08-13 1702
Java核心技术卷一基础知识第10版 Java核心技术卷二高级特性第10版 链接：https://pan.baidu.com/s/1EcA8MmZ5Fh7zPyoAeSw_sQ 提取码：ao14 找半天，终于把2本技术卷找全了。 有需要的兄弟自取
Java核心技术· 卷一（11版）笔记（第1-3章）
weixin_43647460的博客
10-22 629
Java是一种跨平台的编程语言，广泛应用于企业级应用、嵌入式系统、移动应用等领域。Java程序可以在不同的操作系统和硬件平台上运行，具有高效性、安全性、稳定性等特点。Java程序的编写需要使用Java开发工具，如Eclipse、NetBeans、IntelliJ IDEA等。编写完成后，Java程序需要通过编译器将其转换为字节码，然后再通过Java虚拟机（JVM）解释执行。Java程序的基本组成部分包括类、对象、方法、变量、运算符等，Java程序也支持面向对象编程的特性，如封装、继承和多态。
java核心卷一笔记(持续更新)
yu001207的博客
03-30 178
java是将.java文件编译成字节码文件然后由虚拟机执行,这样速度就会比运行机器码慢很多,不过虚拟机有一个选项(即时编译),可以将执行最频繁的字节码序列转换文机器码。对象的状态可能会随着时间而发生改变，但这种改变不会是自发的。如果要遍历一个字符串，可以使用codePoints方法，它会生成int值的流，然后可以将流转化为数组再遍历。一个类的方法使用或操纵另一个类的对象，我们就说一个类依赖于另一个类,我们应尽可能减少类之间的耦合。在Java中，任何对象变量的值都是对存储在另外一个地方的某个对象的引用。
《Java核心技术 卷1 基础知识 原书第10版》
热门推荐
Angus
04-28 2万+
/*免责声明：全部内容都属于是段友分享，我只是属于整理。**/ /*写在前边，个人觉得****弄一个积分下载，就是在自掘坟墓。表面上看起来是可以为个人赚积分，实际砍掉分享交流的一个途径。对我就是没有积分，我就是这么理直气壮。所以每次需要东西的时候，网上一艘，全都是积分下载，虽然有的只是1分，但是不好意思我真的没有，我觉得不想分享别分享啊。到了这里，我把我有的就分享出来，我在博客上专门...
Java核心技术卷1：基础知识（原书第10版）
持 开源思想，撰 必胜所学，望 勤学者，无难处
02-28 3908
本书为专业程序员解决实际问题而写，Java基础知识面覆盖很完整，可以帮助你深入了解Java语言和库。在卷I中，Horstmann主要强调基本语言概念和现代用户界面编程基础，深入介绍了从Java面向对象编程到泛型、集合、lambda表达式、Swing UI设计以及并发和函数式编程的新方法等内容。 目录 译者序 前言 致谢 第1章　Java程序设计概述 1 第2章　Java程序设计环境 12 第3章　Java的基本程序设计结构 28 第4章　对象与类 91 第5章　继承 147 第6章　接口、lambd
《JAVA核心技术卷·I》——第一章——JAVA程序设计概述
做一个善良的人，做好自己的事，如果愿意，再发一份光。
06-11 833
🔥本篇概览：本章是《JAVA核心技术卷·I》——第一章——JAVA程序设计概述的详细总结，详细讲解了JAVA语言的各种优点。尤其重点讨论JAVA中的OOP、JIT。🌈⭕🔥
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值