Java 白皮书 —— A White Paper

参考资源

tips：建议用谷歌浏览器打开，用 Microsoft Edge 浏览器会导致有些格式混乱。

1、Oracle 官网 Java 白皮书参考链接：https://www.oracle.com/java/technologies/language-environment.html
2、《Java 核心技术 卷一》第 12 版中关于 Java 白皮书摘要解释：https://horstmann.com/corejava/java-an-overview/
3、《Java 核心技术 卷一》第 12 版中关于 Java 白皮书摘要解释 PDF 格式：https://horstmann.com/corejava/java-an-overview/7Gosling.pdf
4、Oracle 官网关于 JavaSE 相关的一些白皮书参考链接：https://www.oracle.com/java/technologies/javase/javase-whitepapers.html
5、早期 Sun 公司（没被 Oracle 收购前）1996 年发布的 Java 白皮书 PDF 版资源：
微信公众号：洛槟的学习笔记
回复：Java白皮书
即可自动获取

Java 白皮书目录

从上图可以看出白皮书是在 1996 年 5 月发表的，作者是 James Gosling （Java 之父）和 Henry McGilton。

Java 设计者编写了一个颇有影响力的白皮书，来解释设计初衷以及完成的情况，他们还发布了一个简短的摘要。这个摘要按以下关键术语进行组织。——来自《Java 核心技术 卷I》第 12 版

目录有以下九个部分（在这里先了解，后续回过头来深入研究）：

• Java 介绍
• 简单性和熟悉的
• 面向对象
• 体系结构中立、可移植性和健壮性
• 解释性和动态性
• 安全性
• 多线程
• 高性能
• Java 基础系统和类库

1、Java 介绍

这章主要介绍了设计 Java 语言的起源以及初衷，最后提到了 Java 平台是分布式计算的新方法。

1.1 设计初衷

其中一段说明了 Java 语言的起源和设计初衷

The Java programming language originated as part of a research project to develop advanced software for a wide variety of network devices and embedded systems. The goal was to develop a small, reliable, portable, distributed, real-time operating platform. When the project started, C++ was the language of choice. But over time the difficulties encountered with C++ grew to the point where the problems could best be addressed by creating an entirely new language platform. Design and architecture decisions drew from a variety of languages such as Eiffel, SmallTalk, Objective C, and Cedar/Mesa. The result is a language platform that has proven ideal for developing secure, distributed, network-based end-user applications in environments ranging from network-embedded devices to the World-Wide Web and the desktop.
 
Java 编程语言起源于为各种网络设备和嵌入式系统开发高级软件的研究项目的一部分。目标是开发一个小型、可靠、便携、分布式、实时的操作平台。当项目开始时，C++ 是首选语言。但随着时间的推移，C++ 遇到的困难发展到可以通过创建一个全新的语言平台来最好地解决问题的地步。设计和架构决策借鉴了多种语言，如 Eiffel，SmallTalk，Objective C 和 Cedar/Mesa。其结果是一个语言平台，已被证明非常适合在从网络嵌入式设备到万维网和桌面的环境中开发安全、分布式、基于网络的最终用户应用程序。

1.2 设计目标

Java 最初设计目标 可以概括以下几点：

• 简单、面向对象和熟悉
• 健壮和安全
• 体系结构中立和可移植
• 高性能
• 解释性、多线程和动态性

1.3 Java平台——分布式计算的新方法

Taken individually, the characteristics discussed above can be found in a variety of software development platforms. What’s completely new is the manner in which Java technology and its runtime environment have combined them to produce a flexible and powerful programming system.

Developing your applications using the Java programming language results in software that is portable across multiple machine architectures, operating systems, and graphical user interfaces, secure, and high performance.

单独来看，上面讨论的特征可以在各种软件开发平台中找到。全新的是 Java 技术及其运行时环境将它们结合起来以产生灵活而强大的编程系统的方式。

使用 Java 编程语言开发应用程序可生成可跨多个机器体系结构、操作系统和图形用户界面移植的软件，安全且高性能。

这里正好说到了 Java 的分布式特点。

Java 有一个丰富的类库，用于处理 HTTP 和 FTP 之类的 TCP/IP 协议。Java 应用程序能够通过 URL打开和访问网上的对象，其便携程度就好像访问本地文件一样。

如今这一点被认为是理所当然的，不过在 1995 年主要还是从 C++ 或 Visual Basic 程序连接 Web 服务器。

2、简单性和熟悉的

总结本章，Java 是：

Simplicity is one of Java’s overriding design goals. Simplicity and removal of many “features” of dubious worth from its C and C++ ancestors keep Java relatively small and reduce the programmer’s burden in producing reliable applications. To this end, Java design team examined many aspects of the “modern” C and C++ languages 1 to determine features that could be eliminated in the context of modern object-oriented programming.
 
Another major design goal is that Java look familiar to a majority of programmers in the personal computer and workstation arenas, where a large fraction of system programmers and application programmers are familiar with C and C++. Thus, Java “looks like” C++. Programmers familiar with C, Objective C, C++, Eiffel, Ada, and related languages should find their Java language learning curve quite short–on the order of a couple of weeks.

• 简单 - 从 C 和 C++ 中剔除了一些不太需要的功能，使Java保持相对较小的规模，并减轻了程序员在生成可靠应用程序方面的负担。
• 熟悉 - Java 看起来像 C 和 C++，同时抛弃了这些语言的压倒性复杂性。大多数程序员和应用程序程序员都熟悉Java，其中很大一部分系统程序员和应用程序程序员都熟悉 C 和 C++。因此，Java “看起来像” C++。熟悉 C，Objective C，C++，Eiffel，Ada 和相关语言的程序员应该会发现他们的 Java 语言学习曲线很短 - 大约几周。

我们希望构建一个无须深奥的专业训练就可以进行编程的系统，并且要符合当今的标准惯例。因此，尽管我们发现 C++ 不太适用，但在设计 Java 的时候还是尽可能地接近 C++，以使系统更易于理解。Java 剔除了 C 和 C++ 中许多很少使用、难以理解、容易混淆的特性。——来自《Java 核心技术 卷I》第 12 版

“简单”的另一方面是“小”。Java 的目标之一是支持开发能够在小型机器上独立运行的软件。基本的解释器和类支持大约仅为 40KB，再加上基础的标准类库和线程支持（基本上是一个自包含的微内核），大约需要增加 175KB。这在当时，是一个了不起的成就。
当然，由于不断扩展，类库已经相当庞大了。不过现在还有一些带有较小类库的独立版本，这些版本适用于嵌入式设备和智能卡。 ——来自《Java 核心技术 卷I》第 12 版

3、面向对象

参见：https://www.oracle.com/java/technologies/object-oriented.html#343

为了跟上现代软件开发实践的步伐，Java 从一开始就是面向对象的。设计面向对象语言的意义不仅仅是跳上最新的编程时尚。面向对象的范式很好地满足了客户端-服务器和分布式软件的需求。随着越来越多的组织将其应用程序迁移到分布式客户端-服务器模型，对象技术的好处正在迅速实现。

将对象与普通过程或函数区分开来的一个重要特征是，对象的生存期可以大于创建它的对象的生存期。物体的这一方面是微妙的，大多被忽视。在分布式客户端-服务器世界中，您现在可以在一个地方创建对象，在网络中传递，并存储在其他地方（可能在数据库中），以便检索以备将来工作。

作为一种面向对象的语言，Java 借鉴了以前面向对象语言的最佳概念和功能，主要是 Eiffel，SmallTalk，Objective C 和 C++。Java 在扩展对象模型和消除 C++ 的主要复杂性方面超越了 C++。除了其原始数据类型外，Java 中的所有内容都是对象，如果需要，甚至可以将原始类型封装在对象中。

3.1 Java 中的对象技术

要真正被认为是“面向对象”的，编程语言至少应该支持四个特征：

• 封装 —— 实现信息隐藏和模块化（抽象）
• 多态性 —— 发送到不同对象的相同消息会导致行为取决于接收消息的对象的性质
• 继承 —— 基于现有类定义新的类和行为，以获得代码重用和代码组织
• 动态绑定 —— 对象可能来自任何地方，可能来自网络。您需要能够在编写代码时向对象发送消息，而不必知道其特定类型。动态绑定在程序执行时提供最大的灵活性。

Java 很好地满足了这些要求，并增加了相当多的运行时支持，使您的软件开发工作更轻松。

3.2 什么是对象？

简单来说，对象技术是分析、设计和编程方法的集合，其设计侧重于对现实世界中对象的特征和行为进行建模。诚然，这个定义似乎有点循环，所以让我们试着打破清澈的空气。

什么是对象？它们是软件编程模型。在你的日常生活中，你被物体包围着：汽车、咖啡机、鸭子、树木等等。软件应用程序包含对象：用户界面上的按钮、电子表格和电子表格单元格、属性列表、菜单等。这些对象具有状态和行为。您可以使用称为对象的软件构造来表示所有这些内容，这些构造也可以由其状态和行为来定义。

在您的日常运输需求中，汽车可以通过物体建模。汽车具有状态（行驶速度、方向、油耗等）和行为（启动、停止、转弯、滑动和撞树）。

你把车开到办公室，在那里你跟踪你的股票投资组合。在与股票市场的日常互动中，股票可以通过对象建模。股票有状态（每日高点、日低、开盘价、收盘价、每股收益、相对强弱）和行为（改变价值、执行拆分、有股息）。

看到你的股票价格下跌后，你去咖啡馆用一杯热咖啡来安慰自己。浓缩咖啡机可以建模为一个对象。它有状态（水温，料斗中的咖啡量）和行为（发出蒸汽，发出噪音，并酿造一杯完美的咖啡）。

3.3 对象基础

对象的行为由其方法定义。方法操作实例变量以创建新状态;对象的方法还可以创建新对象。

左边的小图片是对象的常用图形表示形式。该图说明了软件对象的概念结构 - 它有点像一个细胞，外膜是它与世界的接口，内核受外膜保护。

对象的实例变量（数据）被打包或封装在对象中。实例变量由对象的方法包围。除了某些明确定义的异常之外，对象的方法就是其他对象可以访问或更改其实例变量的唯一方法。在 Java 中，类可以将其实例变量声明为 public，在这种情况下，实例变量可供其他对象全局访问。

3.3.1 类

类是一种软件构造，用于定义随后从该类构造的特定具体对象的数据（状态）和方法（行为）。在 Java 术语中，类是由成员构建的，这些成员可以是字段也可以是方法。字段是类的数据。方法是对数据进行操作的语句序列。字段通常特定于对象，也就是说，从类定义构造的每个对象都有自己的字段副本。此类字段称为实例变量。类似地，方法通常也被声明为对类的实例变量进行操作，因此被称为实例方法。

类本身不是对象。类类似于蓝图，它定义从类声明的规范创建或实例化对象时对象的外观和行为。通过实例化先前定义的类来获取具体对象。您可以从一个类定义实例化多个对象，就像您可以从单个建筑师的图纸中构建许多相同的房屋一样。下面是一个名为 Point 的非常简单的类的基本声明。

class Point extends Object {
      public double  x;    /*   instance variable 实例变量  */
      public double  y;    /*   instance variable 实例变量 */
}

如前所述，此声明仅定义一个模板，从中可以实例化真实对象，如下所述。

3.3.2 从类实例化对象

在上面声明了 Point 类之后，可以使用如下代码片段创建一个 Point 对象（Point 类的实例）：

Point  myPoint;           // declares a variable to refer to a Point object
             
myPoint = new Point();   // allocates an instance of  a Point object

现在，您可以通过引用变量的名称来访问此 Point 对象的变量，这些变量使用对象的名称进行限定：

myPoint.x = 10.0;
             
myPoint.y = 25.7;

此引用方案类似于 C 结构引用，之所以有效，是因为 Point 的实例变量是在类声明中声明的 public。如果没有声明实例变量 public，则声明包之外 Point 的对象不能以这种直接方式访问其实例变量。然后，Point 类声明需要提供访问器方法来设置和获取其变量（set 和 get 方法）。

3.3.3 构造函数

在 Java 中声明类时，可以声明在实例化该类中的对象时执行初始化的可选构造函数（constructors）。您还可以声明一个可选的 finalizer（终结器），稍后将讨论。让我们回到之前的类 Point：

class Point extends Object {
      public double  x;    /* instance variable  */
      public double  y;   /* instance variable  */
      Point() {        /* constructor to initialize to default zero value  */
       x = 0.0;
        y = 0.0;
      }                  
      /* constructor to initialize to specific value  */
      Point(double x, double y) {
          this.x = x;    /* 给实例变量传递参数值  */
          this.y = y;
      }
      
 }

与代码片段中的类同名的方法称为构造函数。创建（实例化）Point 类的对象时，将调用构造函数方法来执行所需的任何初始化 - 在本例中，将实例变量设置为初始状态。

此示例是以前 Point 类的变体。现在，当您希望创建和初始化 Point 对象时，您可以将它们初始化为默认值，也可以将它们初始化为特定值：

Point  lowerLeft;
Point  upperRight;

lowerLeft = new Point();        /* initialize to default zero value  */
upperRight = new Point(100.0, 200.0);  /* initialize to non- zero   */

3.3.4 this 变量

上面例子中的 this 变量是什么呢？this 指的是当前 “里面” 的对象。换句话说，this 指向接收对象。

创建新 Point 对象时使用的特定构造函数，是由其中的参数类型和数量确定。用 this 来明确你所指的变量。
在 Point(double x, double y) 方法中， this.x 表示这个对象的 x 实例变量，而不是 Point(double x, double y) 方法中的 x 参数。

后续相关白皮书原文，有时间再研究，在此标记一下，做个书上总结摘抄。

4、体系结构中立、可移植性和健壮性

4.1 体系结构中立

编译器生成一个体系结构中立的目标文件格式，这是一种编译型代码，这些编译型代码可以在很多处理器上运行（只要它们有 Java 运行时系统）。Java 编译器通过生成与特定计算机体系结构无关的字节码指令来实现这一特性。精心设计的字节码不仅可以很容易地在任何机器上解释执行，而且可以很容易地动态转换为原生机器代码。

当时，为“虚拟机”生成代码并不是一个新思路，诸如 Lisp、Smalltalk 和 Pascal 等编程语言多年前就已经采用了这种技术。

当然，解释虚拟机指令肯定比全速运行机器指令慢很多。不过，虚拟机有一个选项，可以将执行最频繁的字节码序列转换成机器码，这一过程称为即时编译（just-in-time compilation）。

Java 虚拟机还有其它一些优点。它可以检查指令序列的行为，从而增强安全性。

4.2 可移植性

与 C 和 C++ 不同，Java 规范中没有“依赖具体实现”的地方。基本数据类型的大小以及有关运算的行为都是明确的。例如，Java 中的 int 总是 32 位整数，而在 C/C++ 中，int 可能是 16 位整数、32 位整数，也可能是编辑器开发商指定的任何其它大小。唯一的限制就是，int 类型的字节数，不能低于 short int，并且不能高于 long int。

• 在 Java 中，数值类型有固定的字节数，这消除了代码移植时一个令人头痛的主要问题。

• 二进制数据以固定格式进行存储和传输，消除了有关字节顺序的困扰。

• 字符串则采用标准的 Unicode 格式存储。

• 作为系统组成部分的类库定义了可移植的接口，除了与用户界面有关的部分外，所有其他 Java 库确实能很好地支持平台独立性。你可以处理文件、正则表达式、XML、日期和时间、数据库、网络连接、线程等，而不用操心底层操作系统。不仅程序是可移植的，Java API 往往也比原生 API 质量更高。

要编写一个在 Windows、Macintosh 和 10 种不同风格的 UNIX 上看起来都不错的程序是多么困难。Java 1.0 就尝试着做了一个壮举，发布了一个简单的工具包，为多个不同平台提供了常用的用户界面元素。遗憾的是，尽管花费了大量的心血，结果却不尽如人意，这个库并不能在不同系统上都提供让人接受的结果。原先的用户界面工具包已经重写，而且后来又再次重写，跨平台的可移植性任然是个问题。

4.3 健壮性

Java 的设计目标之一是要让用 Java 编写的程序具有多方面的可靠性。Java 非常强调进行早期的问题检测、后期动态（运行时）检测，以及消除容易出错的情况。

• Java 与 C、C++ 最大的不同在于 Java 采用的指针模型可以消除重写内存和损坏数据的可能性。对于曾经花费几个小时来检查由于指针 bug 而引起内存冲突的人来说，一定很喜欢 Java 的这一特性。
• Java 编译器能够检测许多其它语言中仅在运行时才能够检测出来的问题。

5、解释性和动态性

5.1 解释性

Java 解释器可以在任何移植了解释器的机器上直接执行 Java 字节码。由于链接（linking）是一个增量式的轻量级过程，所以，开发过程也会更加快捷，更具有探索性。

这看上去很不错。用过 Lisp、Smalltalk、Visual Basic、Python、R 或 Scala 的人都知道“快捷而且具有探索性”的开发过程是怎样的。你可以做些尝试，然后立即就能看到结果。

在 Java 发展的前 20 年里，开发环境并没有把重点放在这种体验上。直到 Java 9 才提供了 jshell 工具来支持快捷而且具有探索性的编程。

5.2 动态性

从很多方面来看，Java 与 C 或 C++ 相比更具有动态性。Java 设计为能够适应不断演进的环境。库可以自由地添加新方法和实例变量，而对客户端没有任何影响。在 Java 中找出运行时类型信息十分简单。

需要为正在运行的程序增加代码时，动态性将是一个非常重要的特性。

6、安全性

Java 要适用于网络/分布式环境。为了实现这个目标，安全性颇受重视。

从一开始，Java 就设计成能够防范各种攻击，其中包括：

• 运行时堆栈溢出，这是蠕虫和病毒常用的攻击手段
• 破坏自己的进程空间之外的内存
• 未经授权读写文件

不过 Java 安全模型很复杂。Java 开发包（JDK）的第一版本发布之后不久，普林斯顿大学的一些安全专家就发现一些小 bug 会允许不可信的代码攻击主系统。

可以说没有绝对安全的系统和软件，就像人的免疫系统一样，时刻不断与病毒、细菌做抗争。更多的是相对安全的，因为技术也是在不断的进步。

最初安全 bug 可以快速修复。遗憾的是，经过一段时间之后，黑客已经很擅长找出安全体系结构实现中的小漏洞。Sun 公司以及之后的 Oracle 公司为不断修复 bug 经历了一段很是艰难的日子。

遭遇多次高调攻击之后，浏览器开发商和 Oracle 公司变得越来越谨慎。有一段时间，远程代码必须有数字签名。如今，通过浏览器交付 Java 应用（applet）已经是很遥远的记忆。

现在看来，尽管 Java 安全模型没有原先预想的那么成功，但 Java 在那个时代确实相当超前。微软公司提出了一种与之竞争的代码交付机制，称为 ActiveX，其安全性完全依赖于数字签名。显然这是不够的，因为微软公司的产品的任何用户都可以证实，一些知名开发商的程序确实会崩溃并对系统产生危害。

7、多线程

多线程可以带来更好的交互响应和实时行为。

如今，我们非常关注并发性，因为摩尔定律即将走到尽头。我们不再追求更快的处理器，而是更多的处理器，而且要让它们保持繁忙。不过，可以看到，大多数编程语言对于这个问题并没有显示出足够的重视。

Java 在当时很超前，它是第一个支持并发程序设计的主流语言。从白皮书中可以看到，它的出发点稍有些不同。当时，多核处理器还很神秘，而 Web 编程才刚刚起步，处理器要花很长时间等待服务器的响应，需要并发程序设计来确保用户界面没有“冻住”。

并发程序设计绝非易事，不过 Java 在这方面表现很出色，可以很好地管理这个工作。

8、高性能

尽管解释型字节码的性能通常已经足够让人满意，但在有些场合下还需要更高的性能。字节码可以（在运行时）动态转换为面向运行这个应用的特定 CPU 的机器码。

现在的即时编译器非常出色，可以与传统的编译器相媲美，而且在某些情况下甚至超过了传统编译器，原因是它们有更多可用的信息。例如，即时编译器可以监控哪些代码频繁执行，并优化这些代码以提高速度。更为复杂的优化是消除函数调用（即“内联”）。即时编译器知道已经加载了哪些类。基于当前加载的类集合，如果一个特定的函数不会被覆盖，就可以使用内联。必要时，以后还可以撤销这种优化。

9、Java 基础系统和类库

完整的 Java 系统包括几个实用程序类库和供开发人员在创建多平台应用程序时使用的方法。简而言之，这些类库是：

• 基础的 Java 语言类–java.lang
• 输入输出包–java.io
• Java 工具包–java.util
• 抽象窗口工具包–java.awt

9.1 Java Language Classes

这个 java.lang 包里的类包含基本类型的集合，这些类总是被导入到任何给定的编译单元中。在这里可以找到 Object (类层次结构的根) 类和 Class 类的声明。还有线程、异常、基本数据类型的包装器和各种其他基本类。

上面这张图说明了 java.lang 中的类，这里排除了所有异常和错误类。

注意Boolean类、Character类和Number类——这些类是基本类型的“包装器”类。在原始类型必须存储为对象的应用程序中使用这些类。还要注意 Throwable 类——这是所有异常和错误的根类。

9.2 Input Output Package

java.io 包 包含用于处理流和随机访问文件的类的声明。在这里，您可以找到大多数 UNIX 系统上熟悉的标准 I/O 库的大致等效项。另一个库称为 java.net，它提供对套接字、telnet 接口和 URL 的支持。

此图显示了 I/O 包的类层次结构。

请注意，灰显的 DataInput 和 DataOutput 框表示接口，而不是类。任何派生出其他类的新 I/O 类都可以在需要时实现适当的接口。

9.3 Utility Package

java.util 包包含各种工具类，包括集合类，如 Dictionary 和 Vector。在这里，您将找到常见的存储类(如 HashTable 和 Stack )，以及特殊使用类(如 Date 和 Time)以及处理编码器和解码器技术的类。这张图说明了 java.util 包中包含的有用的类。

9.4 Abstract Window Toolkit

java.awt 包是一个抽象窗口工具包，它提供了一个层，使您能够轻松地将 Java 应用程序从一个窗口系统移植到另一个窗口系统。这个库包含基本接口组件的类，如事件、颜色、字体以及按钮和滚动条等控件。

下面的图片是抽象窗口工具包中类层次结构的图形化描述。

熟悉的界面元素，如窗口和面板，都是 Component 的子类。布局类对界面元素的布局提供了不同程度的控制。