精华内容
下载资源
问答
  • Java核心技术2)

    2018-07-03 00:50:39
    Java核心技术2)是Java开发学习和工具查询的必备书籍之一
  • Java核心技术 1的源码,跟书本配套,完整的源码,可供学习使用
  • java学习三本神书:headfirst.pdf以故事性语言讲解java中的那些事儿,读起来不枯燥。java核心技术.pdf 知识讲解特别细致,java编程思想适合有基础的人,知识讲解更加深入。
  • 我们假定读者愿意(甚至渴望)学习Java提供的所有高级特性。本书将详细介绍下列内容: • 面向对象程序设计 • 异常处理 • 反射与代理 • 泛型程序设计 • 接口与内部类 • 集合框架 • 事件监听器模型 • 并行操作
  • java核心技术卷一+二 带目录!带目录!! 原书第九版 高清 百度网盘资源下载
  • Java核心技术卷】I/O详析

    千次阅读 多人点赞 2019-09-09 08:34:27
    文章目录概述Java io基本概念关于流流的分类Java io框架一、以字节为单位的输出流的框架图(1)框架图图示(2)OutputStream详解(3)OutputStream子类(4)引申:打印流二、以字节为单位的输入流的框架图(1)框架...

    概述

    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的一些高级技术的基石,而且也是一些大厂面试必不可少的东西,打得越牢固越好。下面要么再写一篇,要么在该篇继续补充,欢迎各位拍砖~

    展开全文
  • java核心技术 1 基础知识 带书签目录 java 学习的基础,基础是一切的开端
  • java核心技术卷1第九版高清中文版,含书签,适合初学者学习,参考。
  • java核心技术卷1,卷2

    2018-02-28 09:24:38
    java学习的得力教材,不论是新手还是有一定java基础的学者都很适合阅读学习.
  • Java 核心技术 卷一 中文版 第十版 带源码,仅供学习交流。如有侵权,请联系删除。
  • java核心技术卷Ⅰ (高清中文版)教材供参考学习!《Java核心技术·卷1:基础知识(原书第9版)》共14章。第1章概述了Java语言与其他程序设计语言不同的性能;第2章讲解了如何下载和安装JDK及本书的程序示例;第3章...
  • 本资源属于Java核心技术卷1基础知识原书第9版配套源代码,这对于学习Java知识的人员而言具有很好的参考价值。
  • Java核心技术卷1(原书第8版) 适合零基础菜鸟学习 通俗易懂(bu)
  • java核心技术卷1学习思维导图 java对象与类基础知识 面向对象java 继承 面向对象java 接口和内部类 异常、日志、断言和调试 泛型程序设计 集合
    展开全文
  • 第10,11,12,13章所讲Java图形界面相关,当今这方面几乎很少使用,选择忽略。 由于并不是Java新手,所以我将选择对我有益的知识点进行记录。 更详细的原文:https://segmentfault.com/a/1190000018462198 ...

    如何阅读本书

    拿到书的第一眼肯定去看目录,大概了解一下,各个章节所讲内容。为表对作者的尊重,快读扫读了,译者序、前言和致谢。
    通过目录了解到,第1,2章所讲概述和环境搭建,对于我来说没有价值,选择忽略。
    第10,11,12,13章所讲Java图形界面相关,当今这方面几乎很少使用,选择忽略。
    由于并不是Java新手,所以我将选择对我有益的知识点进行记录。

    更详细的原文:https://segmentfault.com/a/1190000018462198

    展开全文
  • corejava:java核心技术卷二原始学习
  • Java核心技术 1 基础知识

    万次阅读 2019-04-09 09:31:25
    网站 ...> CiCi岛 下载 电子版仅供预览及学习交流使用,下载后请24小时内删除,支持正版,喜欢的请购买正版书籍 ...购买正版 ... 根据Java SE 8全面更新,系统全面讲解Java语言的核心概念、语法...

    网站

    更多书籍点击进入>> CiCi岛

    下载

    电子版仅供预览及学习交流使用,下载后请24小时内删除,支持正版,喜欢的请购买正版书籍

    封页

    封页

    编辑推荐


    Java领域*有影响力和价值的著作之一,与《Java编程思想》齐名,10余年全球畅销不衰,广受好评
      根据Java SE 8全面更新,系统全面讲解Java语言的核心概念、语法、重要特性和开发方法,包含大量案例,实践性强 ??
      一直以来,《Java核心技术》都被认为是面向高级程序员的经典教程和参考书,它内容翔实、客观准确,不拖泥带水,是想为实际应用编写健壮 Java代码的程序员的*选。如今,本版进行了全面更新, 以反映近年来人们翘首以待、变革*大的Java版本(Java SE 8)的内容。这一版经过重写,并重新组织,全面阐释了新的Java SE 8特性、惯用法和*佳实践,其中包含数百个示例程序,所有这些代码都经过精心设计,不仅易于理解,也很容易实际应用。
      本书为专业程序员解决实际问题而写,可以帮助你深入了解Java语言和库。在卷I中,Horstmann主要强调基本语言概念和现代用户界面 编程基础,深入介绍了从Java面向对象编程到泛型、集合、lambda表达式、Swing UI设计以及并发和函数式编程的*新方法等内容。
      通过阅读本书,你将:
      充分利用你现有的编程知识快速掌握核心Java语法
      了解Java中封装、类和继承如何工作
      掌握利用接口、内部类和lambda表达式来实现函数式编程
      利用异常处理和有效调试提高程序健壮性
      利用泛型和强类型编写更安全、更可读的程序
      使用预建集合收集多个对象以便以后获取
      从头开始掌握并发编程技术
      利用标准Swing组件构建现代跨平台GUI
      部署可配置应用和applet,并通过互联网发布
      利用新的函数式技术简化并发性和提高性能
      如果你是一个资深程序员,刚刚转向Java SE 8,本书*是可靠、实用的“伙伴”,不仅现在能帮助你,在未来的很多年还会继续陪伴你前行。 

    内容简介

    Java领域有影响力和价值的著作之一,由拥有20多年教学与研究经验的资深Java技术专家撰写(获Jolt大奖),与《Java编程思想》齐 名,10余年全球畅销不衰,广受好评。第10版根据Java SE 8全面更新,同时修正了第9版中的不足,系统全面讲解了Java语言的核心概念、语法、重要特性和开发方法,包含大量案例,实践性强。   本书共14章。第1章概述Java语言与其他程序设计语言不同的性能;第2章讲解如何下载和安装JDK及本书的程序示例;第3章介绍变量、循 环和简单的函数;第4章讲解类和封装;第5章介绍继承;第6章解释接口和内部类;第7章讨论异常处理,并给出大量实用的调试技巧;第8章概要介绍泛型程序 设计;第9章讨论Java平台的集合框架;第10章介绍GUI程序设计,讨论如何建立窗口、如何在窗口中绘图、如何利用几何图形绘图、如何采用多种字体格 式化文本,以及如何显示图像;第11章详细讨论抽象窗口工具包的事件模型;第12章详细讨论Swing GUI工具包;第13章介绍如何将程序部署为应用或applet;第14章讨论并发。本书后还有一个附录,其中列出了Java语言的保留字。

    作者简介

    凯 S. 霍斯特曼(Cay S. Horstmann),圣何塞州立大学计算机科学系教授、Java的倡导者,经常在开发人员会议上发表演讲。他是《Core Java for the Impatient》(2015)《Java SE 8 for the Really Impatient》(2014)和《Scala for the lmpatient》(2012)的作者,这些书均由Addison-Wesley出版。他为专业程序员和计算机科学专业学生编写过数十本图书。

    目 录

    译者序

    前言

    致谢

    第1章 Java程序设计概述 1

    1.1 Java程序设计平台 1

    1.2 Java“白皮书”的关键术语 2

    1.2.1 简单性 2

    1.2.2 面向对象 2

    1.2.3 分布式 3

    1.2.4 健壮性 3

    1.2.5 安全性 3

    1.2.6 体系结构中立 4

    1.2.7 可移植性 4

    1.2.8 解释型 5

    1.2.9 高性能 5

    1.2.10 多线程 5

    1.2.11 动态性 5

    1.3 Java applet与Internet 6

    1.4 Java发展简史 7

    1.5 关于Java的常见误解 9

    第2章 Java程序设计环境 12

    2.1 安装Java开发工具包 12

    2.1.1 下载JDK 12

    2.1.2 设置JDK 13

    2.1.3 安装库源文件和文档 15

    2.2 使用命令行工具 16

    2.3 使用集成开发环境 18

    2.4 运行图形化应用程序 21

    2.5 构建并运行applet 23

    第3章 Java的基本程序设计结构 28

    3.1 一个简单的Java应用程序 28

    3.2 注释 31

    3.3 数据类型 32

    3.3.1 整型 32

    3.3.2 浮点类型 33

    3.3.3 char类型 34

    3.3.4 Unicode和char类型 35

    3.3.5 boolean类型 35

    3.4 变量 36

    3.4.1 变量初始化 37

    3.4.2 常量 37

    3.5 运算符 38

    3.5.1 数学函数与常量 39

    3.5.2 数值类型之间的转换 40

    3.5.3 强制类型转换 41

    3.5.4 结合赋值和运算符 42

    3.5.5 自增与自减运算符 42

    3.5.6 关系和boolean运算符 42

    3.5.7 位运算符 43

    3.5.8 括号与运算符级别 44

    3.5.9 枚举类型 45

    3.6 字符串 45

    3.6.1 子串 45

    3.6.2 拼接 46

    3.6.3 不可变字符串 46

    3.6.4 检测字符串是否相等 47

    3.6.5 空串与Null串 48

    3.6.6 码点与代码单元 49

    3.6.7 String API 50

    3.6.8 阅读联机API文档 52

    3.6.9 构建字符串 54

    3.7 输入输出 55

    3.7.1 读取输入 55

    3.7.2 格式化输出 58

    3.7.3 文件输入与输出 61

    3.8 控制流程 63

    3.8.1 块作用域 63

    3.8.2 条件语句 63

    3.8.3 循环 66

    3.8.4 确定循环 69

    3.8.5 多重选择:switch语句 72

    3.8.6 中断控制流程语句 74

    3.9 大数值 76

    3.10 数组 78

    3.10.1 for each循环 79

    3.10.2 数组初始化以及匿名数组 80

    3.10.3 数组拷贝 81

    3.10.4 命令行参数 81

    3.10.5 数组排序 82

    3.10.6 多维数组 85

    3.10.7 不规则数组 88

    第4章 对象与类 91

    4.1 面向对象程序设计概述 91

    4.1.1 类 92

    4.1.2 对象 93

    4.1.3 识别类 93

    4.1.4 类之间的关系 94

    4.2 使用预定义类 95

    4.2.1 对象与对象变量 95

    4.2.2 Java类库中的LocalDate类 98

    4.2.3 更改器方法与访问器方法 100

    4.3 用户自定义类 103

    4.3.1 Employee类 103

    4.3.2 多个源文件的使用 105

    4.3.3 剖析Employee类 106

    4.3.4 从构造器开始 106

    4.3.5 隐式参数与显式参数 108

    4.3.6 封装的优点 109

    4.3.7 基于类的访问权限 111

    4.3.8 私有方法 111

    4.3.9 f?inal实例域 112

    4.4 静态域与静态方法 112

    4.4.1 静态域 112

    4.4.2 静态常量 113

    4.4.3 静态方法 114

    4.4.4 工厂方法 115

    4.4.5 main方法 115

    4.5 方法参数 118

    4.6 对象构造 123

    4.6.1 重载 123

    4.6.2 默认域初始化 123

    4.6.3 无参数的构造器 124

    4.6.4 显式域初始化 125

    4.6.5 参数名 125

    4.6.6 调用另一个构造器 126

    4.6.7 初始化块 127

    4.6.8 对象析构与f?inalize方法 130

    4.7 包 131

    4.7.1 类的导入 131

    4.7.2 静态导入 133

    4.7.3 将类放入包中 133

    4.7.4 包作用域 136

    4.8 类路径 137

    4.8.1 设置类路径 139

    4.9 文档注释 140

    4.9.1 注释的插入 140

    4.9.2 类注释 140

    4.9.3 方法注释 141

    4.9.4 域注释 142

    4.9.5 通用注释 142

    4.9.6 包与概述注释 143

    4.9.7 注释的抽取 143

    4.10 类设计技巧 144

    第5章 继承 147

    5.1 类、超类和子类 147

    5.1.1 定义子类 147

    5.1.2 覆盖方法 149

    5.1.3 子类构造器 150

    5.1.4 继承层次 153

    5.1.5 多态 154

    5.1.6 理解方法调用 155

    5.1.7 阻止继承:f?inal类和方法 157

    5.1.8 强制类型转换 158

    5.1.9 抽象类 160

    5.1.10 受保护访问 165

    5.2 Object:所有类的超类 166

    5.2.1 equals方法 166

    5.2.2 相等测试与继承 167

    5.2.3 hashCode方法 170

    5.2.4 toString方法 172

    5.3 泛型数组列表 178

    5.3.1 访问数组列表元素 180

    5.3.2 类型化与原始数组列表的兼容性 183

    5.4 对象包装器与自动装箱 184

    5.5 参数数量可变的方法 187

    5.6 枚举类 188

    5.7 反射 190

    5.7.1 Class类 190

    5.7.2 捕获异常 192

    5.7.3 利用反射分析类的能力 194

    5.7.4 在运行时使用反射分析对象 198

    5.7.5 使用反射编写泛型数组代码 202

    5.7.6 调用任意方法 205

    5.8 继承的设计技巧 208

    第6章 接口、lambda表达式与内部类 211

    6.1 接口 211

    6.1.1 接口概念 211

    6.1.2 接口的特性 217

    6.1.3 接口与抽象类 218

    6.1.4 静态方法 218

    6.1.5 默认方法 219

    6.1.6 解决默认方法冲突 220

    6.2 接口示例 222

    6.2.1 接口与回调 222

    6.2.2 Comparator接口 224

    6.2.3 对象克隆 225

    6.3 lambda表达式 231

    6.3.1 为什么引入lambda表达式 231

    6.3.2 lambda表达式的语法 232

    6.3.3 函数式接口 234

    6.3.4 方法引用 235

    6.3.5 构造器引用 237

    6.3.6 变量作用域 237

    6.3.7 处理lambda表达式 239

    6.3.8 再谈Comparator 242

    6.4 内部类 242

    6.4.1 使用内部类访问对象状态 244

    6.4.2 内部类的特殊语法规则 247

    6.4.3 内部类是否有用、必要和安全 248

    6.4.4 局部内部类 250

    6.4.5 由外部方法访问变量 250

    6.4.6 匿名内部类 252

    6.4.7 静态内部类 255

    6.5 代理 258

    6.5.1 何时使用代理 259

    6.5.2 创建代理对象 259

    6.5.3 代理类的特性 262

    第7章 异常、断言和日志 264

    7.1 处理错误 264

    7.1.1 异常分类 265

    7.1.2 声明受查异常 267

    7.1.3 如何抛出异常 269

    7.1.4 创建异常类 270

    7.2 捕获异常 271

    7.2.1 捕获异常 271

    7.2.2 捕获多个异常 273

    7.2.3 再次抛出异常与异常链 274

    7.2.4 f?inally子句 275

    7.2.5 带资源的try语句 278

    7.2.6 分析堆栈轨迹元素 280

    7.3 使用异常机制的技巧 282

    7.4 使用断言 285

    7.4.1 断言的概念 285

    7.4.2 启用和禁用断言 286

    7.4.3 使用断言完成参数检查 287

    7.4.4 为文档假设使用断言 288

    7.5 记录日志 289

    7.5.1 基本日志 289

    7.5.2 高级日志 289

    7.5.3 修改日志管理器配置 291

    7.5.4 本地化 292

    7.5.5 处理器 293

    7.5.6 过滤器 296

    7.5.7 格式化器 296

    7.5.8 日志记录说明 296

    7.6 调试技巧 304

    第8章 泛型程序设计 309

    8.1 为什么要使用泛型程序设计 309

    8.1.1 类型参数的好处 309

    8.1.2 谁想成为泛型程序员 310

    8.2 定义简单泛型类 311

    8.3 泛型方法 313

    8.4 类型变量的限定 314

    8.5 泛型代码和虚拟机 316

    8.5.1 类型擦除 316

    8.5.2 翻译泛型表达式 317

    8.5.3 翻译泛型方法 318

    8.5.4 调用遗留代码 319

    8.6 约束与局限性 320

    8.6.1 不能用基本类型实例化类型参数 320

    8.6.2 运行时类型查询只适用于原始类型 321

    8.6.3 不能创建参数化类型的数组 321

    8.6.4 Varargs警告 322

    8.6.5 不能实例化类型变量 323

    8.6.6 不能构造泛型数组 323

    8.6.7 泛型类的静态上下文中类型变量无效 325

    8.6.8 不能抛出或捕获泛型类的实例 325

    8.6.9 可以消除对受查异常的检查 326

    8.6.10 注意擦除后的冲突 327

    8.7 泛型类型的继承规则 328

    8.8 通配符类型 330

    8.8.1 通配符概念 330

    8.8.2 通配符的超类型限定 331

    8.8.3 无限定通配符 334

    8.8.4 通配符捕获 334

    8.9 反射和泛型 337

    8.9.1 泛型Class类 337

    8.9.2 使用Class参数进行类型匹配 338

    8.9.3 虚拟机中的泛型类型信息 338

    第9章 集合 344

    9.1 Java集合框架 344

    9.1.1 将集合的接口与实现分离 344

    9.1.2 Collection接口 346

    9.1.3 迭代器 347

    9.1.4 泛型实用方法 349

    9.1.5 集合框架中的接口 352

    9.2 具体的集合 353

    9.2.1 链表 355

    9.2.2 数组列表 362

    9.2.3 散列集 363

    9.2.4 树集 366

    9.2.5 队列与双端队列 369

    9.2.6 优先级队列 371

    9.3 映射 372

    9.3.1 基本映射操作 372

    9.3.2 更新映射项 375

    9.3.3 映射视图 376

    9.3.4 弱散列映射 377

    9.3.5 链接散列集与映射 378

    9.3.6 枚举集与映射 379

    9.3.7 标识散列映射 380

    9.4 视图与包装器 381

    9.4.1 轻量级集合包装器 382

    9.4.2 子范围 382

    9.4.3 不可修改的视图 383

    9.4.4 同步视图 384

    9.4.5 受查视图 384

    9.4.6 关于可选操作的说明 385

    9.5 算法 388

    9.5.1 排序与混排 389

    9.5.2 二分查找 391

    9.5.3 简单算法 392

    9.5.4 批操作 394

    9.5.5 集合与数组的转换 394

    9.5.6 编写自己的算法 395

    9.6 遗留的集合 396

    9.6.1 Hashtable类 397

    9.6.2 枚举 397

    9.6.3 属性映射 398

    9.6.4 栈 399

    9.6.5 位集 399

    第10章 图形程序设计 403

    10.1 Swing概述 403

    10.2 创建框架 407

    10.3 框架定位 409

    10.3.1 框架属性 411

    10.3.2 确定合适的框架大小 411

    10.4 在组件中显示信息 415

    10.5 处理2D图形 419

    10.6 使用颜色 426

    10.7 文本使用特殊字体 429

    10.8 显示图像 435

    第11章 事件处理 439

    11.1 事件处理基础 439

    11.1.1 实例:处理按钮点击事件 441

    11.1.2 简洁地指定监听器 445

    11.1.3 实例:改变观感 447

    11.1.4 适配器类 450

    11.2 动作 453

    11.3 鼠标事件 459

    11.4 AWT事件继承层次 465

    11.4.1 语义事件和底层事件 466

    第12章 Swing用户界面组件 469

    12.1 Swing和模型–视图–控制器设计模式 469

    12.2 布局管理概述 474

    12.3 文本输入 481

    12.4 选择组件 488

    12.5 菜单 504

    12.6 复杂的布局管理 518

    12.7 对话框 541

    12.8 GUI程序排错 573

    第13章 部署Java应用程序 580

    13.1 JAR文件 580

    13.2 应用首选项的存储 586

    13.3 服务加载器 596

    13.4 applet 598

    13.5 Java Web Start 614

    第14章 并发 624

    14.1 什么是线程 624

    14.2 中断线程 632

    14.3 线程状态 635

    14.4 线程属性 638

    14.5 同步 640

    14.6 阻塞队列 668

    14.7 线程安全的集合 673

    14.8 Callable与Future 681

    14.9 执行器 685

    14.10 同步器 696

    14.11 线程与Swing 698

    附录A Java关键字 710

    前 言

    译 者 序

      书写Java传奇的Sun
    Microsystems曾经堪称“日不落”帝国,但服务器市场的萎缩却让这个声名赫赫的庞大帝国从蓬勃走向落寞。在2009年被Oracle公司收购之
    后,Sun公司逐渐淡出了人们的视线,而与此同时,我们也在很长一段时间内没能看到Java当初活跃的身影。

      Java就这样退出历史舞台了吗?当然不是!从Sun公司2006年12月发布Java
    6后,经过5年多的不懈努力,终于在2011年7月底发布了Java 7正式版。3年后,被冠名为“跳票王”的Oracle终于发布了Java
    8的正式版,但对于很多开发者来说,Java 8却比Java 7来得更漫长一些。主要是因为Oracle原本计划在2013年发布正式版Java
    8,却因受困于安全性的问题经过了两次“跳票”。无论如何,如今Java 8来了,全新“革命”而不只是“进化”的功能将会让无数开发者动容。

      值得一提的是,伴随着Java的成长,《Java核心技术》也从第1版到第9版一路走来,得到了广大Java程序设计人员的青睐,成为一本畅
    销不衰的Java经典图书。经过几年的蛰伏,针对Java 8打造的《Java核心技术》第10版终于问世,这一版有了大幅的修订和更新,以反映Java
    8增补、删改的内容。它将续写从前的辉煌,使人们能及时跟上Java前进的脚步。

      本书由周立新、陈波等主译,程芳、刘晓兵、张练达、陈峰、江健、谢连宝、张雷生、杨健康、张莹参与了全书的修改整理,并完善了关键部分的翻
    译。全体人员共同完成了本书的翻译工作。特别需要说明的是,按照出版社的要求,这一版的翻译在老版本基础上完成,因此尤其感谢之前版本的译者叶乃文、邝劲
    筠和杜永萍,他们的辛勤工作为新版本的翻译奠定了很好的基础。

      书中文字与内容力求忠实原著,不过由于译者水平有限,译文肯定有不当之处,敬请批评指正。

      译者

      2016年6月于北京

      前  言

      致读者

      1995年年底,Java语言在Internet舞台一亮相便名声大噪。其原因在于它将有望成为连接用户与信息的万能胶,而不论这些信息来自
    Web服务器、数据库、信息提供商,还是任何其他渠道。事实上,就发展前景而言,Java的地位是独一无二的。它是一种完全可信赖的程序设计语言,得到了
    除微软之外的所有厂家的认可。其固有的可靠性与安全性不仅令Java程序员放心,也令使用Java程序的用户放心。Java内建了对网络编程、数据库连
    接、多线程等高级程序设计任务的支持。

      1995年以来,已经发布了Java开发工具包(Java Development
    Kit)的9个主要版本。在过去的20年中,应用程序编程接口(API)已经从200个类扩展到超过4000个类。现在这些API覆盖了用户界面构建、数
    据库管理、国际化、安全性以及XML处理等各个不同的领域。

      本书是《Java核心技术》第10版的卷Ⅰ。自《Java核心技术》出版以来,每个新版本都尽可能快地跟上Java开发工具箱发展的步伐,而
    且每一版都重新改写了部分内容,以便适应Java的最新特性。在这一版中,已经反映了Java 标准版(Java SE 8)的特性。

      与前几版一样,本版仍然将读者群定位在那些打算将Java应用到实际工程项目中的程序设计人员。本书假设读者是一名具有程序设计语言(除
    Java之外)坚实背景知识的程序设计人员,并且不希望书中充斥着玩具式的示例(诸如,烤面包机、动物园的动物或神经质的跳动文本)。这些内容绝对不会在
    本书中出现。本书的目标是让读者充分理解书中介绍的Java语言及Java类库的相关特性,而不会产生任何误解。

      在本书中,我们选用大量的示例代码演示所讨论的每一个语言特性和类库特性。我们有意使用简单的示例程序以突出重点,然而,其中的大部分既不是赝品也没有偷工减料。它们将成为读者自己编写代码的良好开端。

      我们假定读者愿意(甚至渴望)学习Java提供的所有高级特性。例如,本书将详细介绍下列内容:

      面向对象程序设计

      反射与代理

      接口与内部类

      异常处理

      泛型程序设计

      集合框架

      事件监听器模型

      使用Swing UI工具箱进行图形用户界面设计

      并行操作

      随着Java类库的爆炸式增长,一本书无法涵盖程序员需要了解的所有Java特性。因此,我们决定将本书分为两卷。卷I(本书)集中介绍
    Java语言的基本概念以及图形用户界面程序设计的基础知识。卷Ⅱ(高级特性)涉及企业特性以及高级的用户界面程序设计,其中详细讨论下列内容:

      流API

      文件处理与正则表达式

      数据库

      XML处理

      注释

      国际化

      网络编程

      高级GUI组件

      高级图形

      原生方法

      本书中难免出现错误和不准确之处。我们很想知道这些错误,当然,也希望同一个问题只被告知一次。我们在网页
    http://horstmann.com/corejava中以列表的形式给出了常见的问题、bug修正和解决方法。在勘误页(建议先阅读一遍)最后附
    有用来报告bug并提出修改意见的表单。如果我们不能回答每一个问题或没有及时回复,请不要失望。我们会认真地阅读所有的来信,感谢您的建议使本书后续的
    版本更清晰、更有指导价值。

      关于本书

      第1章概述Java与其他程序设计语言不同的性能。解释这种语言的设计初衷,以及在哪些方面达到了预期的效果。然后,简要叙述Java诞生和发展的历史。

      第2章详细论述如何下载和安装JDK以及本书的程序示例。然后,通过编译和运行3个典型的Java程序(一个控制台应用、一个图形应用、一个applet),指导读者使用简易的JDK、可启用Java的文本编辑器以及一个Java IDE。

      第3章开始讨论Java
    语言。这一章涉及的基础知识有变量、循环以及简单的函数。对于C或C 程序员来说,学习这一章的内容将会感觉一帆风顺,因为这些语言特性的语法本质上与
    C语言相同。对于没有C语言程序设计背景,但使用过其他程序设计语言(如Visual Basic)的程序员来说,仔细地阅读这一章是非常必要的。

      面向对象程序设计(Object-Oriented Programming,
    OOP)是当今程序设计的主流,而Java是一种完全面向对象的语言。第4章将介绍面向对象两个基本成分中最重要的——封装,以及Java语言实现封装的
    机制,即类与方法。除了Java语言规则之外,还对如何完成合理的OOP设计给出了忠告。最后,介绍奇妙的javadoc工具,它将代码注释转换为一组包
    含超链接的网页。熟悉C 的程序员可以快速地浏览这一章,而没有面向对象程序设计背景的程序员应在进一步学习Java之前花一些时间了解OOP的有关概
    念。

      类与封装仅仅是OOP中的一部分,第5章将介绍另一部分——继承。继承使程序员可以使用现有的类,并根据需要进行修改。这是Java程序设计中的一个基础技术。Java中的继承机制与C 的继承机制十分相似。C 程序员只需关注两种语言的不同之处即可。

      第6章展示如何使用Java的接口。接口可以让你的理解超越第5章的简单继承模型。掌握接口可以充分获得Java的完全的面向对象程序设计能
    力。介绍接口之后,我们将转而介绍lambda表达式(lambda
    expression),这是一种简洁的方法,用来表述可以在以后某个时间点执行的代码块。本章还将介绍Java的一个有用的技术特性——内部类。

      第7章讨论异常处理(exception
    handling),即Java的一种健壮机制,用于处理可正常运行程序可能出现意外的情况。异常提供了一种将正常处理代码与错误处理代码分开的有效手
    段。当然,即使程序能够处理所有异常条件,仍然有可能无法按照预计的方式工作。这一章的后半部分将给出大量实用的调试技巧。

      第8章概要介绍泛型程序设计。泛型程序设计可以让程序更可读、更安全。我们会展示如何使用强类型机制,而舍弃不安全的强制类型转换,以及如何处理与旧版本Java兼容所带来的复杂问题。

      第9章讨论的是Java平台的集合框架。如果希望收集多个对象并在以后获取这些对象,就应当使用集合,而不要简单地把这些元素放在一个数组中,这是这种情况下最适用的做法。这一章会介绍如何充分利用内建的标准集合。

      第10章开始介绍GUI程序设计。我们会讨论如何建立窗口、如何在窗口中绘图、如何利用几何图形绘图、如何采用多种字体格式化文本,以及如何显示图像。

      第11章将详细讨论抽象窗口工具包(abstract window toolkit,AWT)的事件模型。你会看到如何编写代码来响应事件,如鼠标点击事件或按键事件。同时,你还会看到如何处理基本的GUI元素,如按钮和面板。

      第12章详细讨论Swing GUI工具包。Swing工具包允许建立跨平台的图像用户界面。在这里你会了解各种按钮、文本组件、边框、滑块、列表框、菜单以及对话框的有关内容。不过,一些更高级的组件会在卷II中讨论。

      第13章介绍如何将程序部署为应用或applet。在这里我们会描述如何将程序打包在JAR文件中,以及如何使用Java Web Start和applet机制在Internet上发布应用。另外还会解释Java程序部署之后如何存储和获取配置信息。

      第14章是本书的最后一章,这一章将讨论并发,并发能够让程序任务并行执行。在当今这个时代,大多数处理器都有多个内核,你往往希望这些内核都在工作,并发是Java技术的一个重要而且令人振奋的应用。

      附录列出了Java语言的保留字。

      约定

      本书使用以下图标表示特殊内容。

      注释:“注释”信息会用这样的“注释”图标标志。

      提示:“提示”信息会用这样的“提示”图标标志。

      警告:对于可能出现的危险,我们用一个“警告”图标做出警示。

      C 注释:在本书中有许多用来解释Java与C 之间差别的C 注释。对于没有C 程序设计背景,或者不擅长C 程序设计、把它当做一场噩梦不愿再想起的程序员来说,可以跳过这些注释。

      Java提供了一个很大的程序设计库,即应用程序编程接口。第一次使用API调用时,我们会在该节的结尾给出一个概要描述。这些描述十分通俗易懂,希望能够比联机API文档提供更多的信息。类、接口或方法名后面的编号是介绍该特性的JDK版本号,如下例所示:

      应用程序编程接口1.2

      程序(源代码见本书网站)以程序清单形式给出,例如:

      程序清单1-1 InputTest/InputTest.java

      示例代码

      本书网站http://horstmann.com/corejava以压缩的形式提供了书中的所有示例代码。可以用熟悉的解压缩程序或者用Java开发包中的jar实用程序解压这个文件。有关安装Java开发包和示例代码的详细信息请参看第2章。

      致  谢

      写一本书需要投入大量的精力,改写一本书也并不像想象的那样轻松,尤其是Java技术一直在持续不断地更新。编著一本书让很多人耗费了很多心血,在此衷心地感谢《Java核心技术》编写小组的每一位成员。

      Prentice
    Hall公司的许多人提供了非常有价值的帮助,却甘愿做幕后英雄。在此,我希望每一位都能够知道我对他们努力的感恩。与以往一样,我要真诚地感谢我的编
    辑,Prentice Hall公司的Greg
    Doench,从本书的写作到出版他一直在给予我们指导,同时感谢那些不知其姓名的为本书做出贡献的幕后人士。非常感谢Julie
    Nahil在图书制作方面给予的支持,还要感谢Dmitry Kirsanov和Alina
    Kirsanova完成手稿的编辑和排版工作。我还要感谢早期版本中我的合作者,Gary Cornell,他已经转向其他的事业。

      感谢早期版本的许多读者,他们指出了许多令人尴尬的错误并给出了许多具有建设性的修改意见。我还要特别感谢本书优秀的审阅小组,他们仔细地审阅我的手稿,使本书减少了许多错误。

      本书及早期版本的审阅专家包括:Chuck Allison (Utah Valley大学)、Lance Andersen
    (Oracle)、Paul Anderson (Anderson Software Group)、Alec Beaton (IBM)、Cliff
    Berg、Andrew Binstock (Oracle)、Joshua Bloch、David Brown、Corky
    Cartwright、Frank Cohen (PushToTest)、Chris Crane (devXsolution)、Dr.
    Nicholas J. De Lillo (Manhattan学院)、Rakesh Dhoopar (Oracle)、David Geary
    (Clarity Training)、Jim Gish (Oracle)、Brian Goetz (Oracle)、Angela
    Gordon、Dan Gordon (Electric Cloud)、Rob Gordon、John Gray
    (Hartford大学)、Cameron Gregory (olabs.com)、Marty Hall
    (coreservlets.com公司)、Vincent Hardy (Adobe Systems)、Dan Harkey (San
    Jose州立大学)、William Higgins (IBM)、Vladimir Ivanovic (PointBase)、Jerry
    Jackson (CA Technologies)、Tim Kimmet (Walmart)、Chris Laffra、Charlie Lai
    (Apple)、Angelika Langer、Doug Langston、Hang Lau (McGill大学)、Mark
    Lawrence、Doug Lea (SUNY Oswego)、Gregory Longshore、Bob Lynch (Lynch
    Associates)、Philip Milne (consultant)、Mark Morrissey (Oregon研究院)、Mahesh
    Neelakanta (Florida Atlantic大学)、Hao Pham、Paul Philion、Blake
    Ragsdell、Stuart Reges (Arizona大学)、Rich Rosen (Interactive Data
    Corporation)、Peter Sanders (法国尼斯ESSI大学)、Dr. Paul Sanghera (San
    Jose州立大学Brooks学院)、Paul Sevinc (Teamup AG)、Devang Shah (Sun
    Microsystems)、Yoshiki Shibata、Bradley A. Smith、Steven Stelting
    (Oracle)、Christopher Taylor、Luke Taylor (Valtech)、George
    Thiruvathukal、Kim Topley (StreamingEdge)、Janet Traub、Paul Tyma
    (consultant)、Peter van der Linden、Christian Ullenboom、Burt Walsh、Dan Xu
    (Oracle)和John Zavgren (Oracle)。

      Cay Horstmann

      2015年11月于瑞士比尔

    展开全文
  • 2.java变成思想和java核心技术整理 3.java8等java新特性学习整理 ###Java编程思想 第1章 对象导论 1.1 抽象过程 1.2 每个对象都有一个接口 1.3 每个对象都提供服务 1.4 被隐藏的具体实现 1.5 复用具体实现 1.6 继承 ...
  • Java核心技术卷代码

    2018-09-15 22:59:49
    这是Java核心技术卷第九版的源代码,可以供学习的时候更好的理解。
  • Java核心技术卷II:高级特性

    千次阅读 2019-04-08 20:18:31
    网站 ...> CiCi岛 ...本书是Java领域有影响力和价值的著作之一,由拥有20多年教学与研究经验的Java技术专家撰写(获Jolt大奖),与《Java编程思想》齐名,10余年全球畅销不衰,广受好评。第10版...
  • Java核心技术卷1基础知识原书第10版.pdf+代码.7z(带超详细书签目录) ——这是特别好的一个资源,强烈推荐!!! 本资源转载自网络,供学习研究之用,如用于商业用途,请购买正版,如有侵权,请联系我或CSDN删除。
  • java核心技术 1 基础知识 原书第8版.pdf 系统有深度,适合入门进阶学习!
  • Java核心技术2)第8版,仅用学习使用,不可用于商业用途,如有版权问题,请联系删除!
  • java核心技术卷1卷2第8版的源代码,各个例子都用,方便学习
  • Java核心技术卷 系列,本人认为是最权威的JAVA书籍了,结合java编程思想,java的基础就能的差不多了
  • 对《Java核心技术卷一》读者的一些建议

    千次阅读 多人点赞 2019-11-14 10:00:24
    而技术是要更新迭代的,所以《Java核心技术卷一》来到了第十版(2016 年)。 我们来看一下《Java核心技术卷一》第十版的大纲。 前九章:包括 “Java 程序设计概述”、“Java 程序设计环境”、“Java 的基本程序设计...
  • 本课程以领衔打造,以全、新、细为特点,让学员在... 完本期课程能初步掌握计算机基础知识,认识软件开发,了解到Java语言的特点。 能对基础语法有了初步的掌握,认识了基础逻辑运算,并开始培养面向对象的思维方式。
  • 核心Java源代码CoreJavaVolume和Java代码
  • Java核心技术 Ⅰ:基础知识 【中文】 第1章概述Java与其他程序设计语言不同的性能。解释这种语言的设计初衷,以及在哪些方 面达到了预期的效果。然后,简要叙述Java诞生和发展的历史。 第2章详细地论述如何下载和...
  • Java核心技术卷1基础知识课程—2人已学习 课程介绍   Java核心技术入门视频培训课程:该教程系统全面讲解Java语言的核心概念,语法,重要特性和开发方法,讲解Java开发工具跟编程思想、用Java开发具体的系统程序,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,888
精华内容 5,955
关键字:

java核心技术卷怎么学

java 订阅