Java 中文官方教程 2022 版（一）

原文：docs.oracle.com/javase/tutorial/reallybigindex.html

教程：入门指南

原文：docs.oracle.com/javase/tutorial/getStarted/index.html

这个教程提供了关于开始使用 Java 编程语言的所有必要信息。

提供了 Java 技术作为一个整体的概述。它讨论了 Java 编程语言和平台，广泛概述了这项技术可以做什么以及如何让您的生活更轻松。

这种实践方法描述了如何下载、安装以及输入什么内容，来创建一个简单的 “Hello World!” 应用程序。它为 NetBeans™ 集成开发环境（NetBeans IDE）、Microsoft Windows、Solaris™ 操作系统（Solaris OS）、Linux 和 Mac 用户提供了单独的说明。

讨论了 “Hello World!” 应用程序，详细描述了代码的每个部分。它涵盖了源代码注释、HelloWorldApp 类定义块以及 main 方法。

如果您在编译或运行本教程中的程序时遇到问题，这就是您应该去的地方。

课程：Java 技术现象

原文：docs.oracle.com/javase/tutorial/getStarted/intro/index.html

谈论 Java 技术似乎无处不在，但它究竟是什么？以下部分解释了 Java 技术既是一种编程语言又是一个平台，并概述了这项技术对您有何作用。

• 关于 Java 技术

• Java 技术能做什么？

• Java 技术将如何改变我的生活？

关于 Java 技术

原文：docs.oracle.com/javase/tutorial/getStarted/intro/definition.html

Java 技术既是一种编程语言，也是一个平台。

Java 编程语言

Java 编程语言是一种高级语言，可以用以下所有流行词来描述：

|

• 简单

• 面向对象

• 分布式

• 多线程

• 动态

|

• 架构中立

• 可移植

• 高性能

• 健壮

• 安全

|

前述流行词在《Java 语言环境》一书中有详细解释，该书是由詹姆斯·高斯林和亨利·麦吉尔顿撰写的白皮书。

在 Java 编程语言中，所有源代码首先以.java扩展名结尾的纯文本文件中编写。然后，这些源文件由javac编译器编译成.class文件。.class文件不包含本机于处理器的代码；它包含字节码 —— Java 虚拟机的机器语言^(1)（Java VM）。然后，java启动器工具使用 Java 虚拟机的实例运行你的应用程序。

软件开发过程概述。

由于 Java 虚拟机在许多不同操作系统上可用，同样的.class文件能够在 Microsoft Windows、Solaris™操作系统（Solaris OS）、Linux 或 Mac OS 上运行。一些虚拟机，如Java SE HotSpot 概览，在运行时执行额外步骤以提高应用程序性能。这包括诸如查找性能瓶颈和重新编译（为本机代码）频繁使用的代码段等任务。

通过 Java 虚拟机，同一个应用程序能够在多个平台上运行。

Java 平台

平台是程序运行的硬件或软件环境。我们已经提到了一些最流行的平台，如 Microsoft Windows、Linux、Solaris OS 和 Mac OS。大多数平台可以描述为操作系统和底层硬件的组合。Java 平台与大多数其他平台不同，它是一个仅软件的平台，运行在其他基于硬件的平台之上。

Java 平台有两个组成部分：

• Java 虚拟机

• Java 应用程序编程接口（API）

你已经了解了 Java 虚拟机；它是 Java 平台的基础，并被移植到各种基于硬件的平台上。

API 是一个庞大的现成软件组件集合，提供许多有用的功能。它被分组为相关类和接口的库；这些库被称为包。下一节，Java 技术能做什么？突出了 API 提供的一些功能。

API 和 Java 虚拟机使程序与底层硬件隔离。

作为一个独立于平台的环境，Java 平台可能比本机代码慢一些。然而，编译器和虚拟机技术的进步正在使性能接近本机代码，而不会威胁可移植性。

术语"Java 虚拟机"和"JVM"指的是 Java 平台的虚拟机。

Java 技术能做什么？

原文：docs.oracle.com/javase/tutorial/getStarted/intro/cando.html

通用高级 Java 编程语言是一个强大的软件平台。每个 Java 平台的完整实现都提供以下功能：

• 开发工具：开发工具提供了编译、运行、监控、调试和文档化应用程序所需的一切。作为新开发人员，您将主要使用javac编译器、java启动器和javadoc文档工具。

• 应用程序编程接口（API）：API 提供了 Java 编程语言的核心功能。它提供了一系列有用的类，可以直接在您自己的应用程序中使用。它涵盖了从基本对象到网络和安全性，再到 XML 生成和数据库访问等各种内容。核心 API 非常庞大；要了解其包含的内容，请参阅Java 平台标准版 8 文档。

• 部署技术：JDK 软件提供了标准机制，如 Java Web Start 软件和 Java 插件软件，用于将您的应用程序部署给最终用户。

• 用户界面工具包：JavaFX、Swing 和 Java 2D 工具包使得创建复杂的图形用户界面（GUIs）成为可能。

• 集成库：集成库如 Java IDL API、JDBC API、Java 命名和目录接口（JNDI）API、Java RMI 和基于 Internet 互 ORB 协议技术的 Java 远程方法调用（Java RMI-IIOP 技术）使数据库访问和远程对象操作成为可能。

Java 技术将如何改变我的生活？

原文：docs.oracle.com/javase/tutorial/getStarted/intro/changemylife.html

我们不能保证您学习 Java 编程语言后会获得名声、财富，甚至工作。但它很可能会使您的程序更好，并且比其他语言需要更少的努力。我们相信 Java 技术将帮助您实现以下目标：

• 快速入门：尽管 Java 编程语言是一种强大的面向对象语言，但对于已经熟悉 C 或 C++的程序员来说，学习起来很容易。

• 编写更少的代码：对程序指标（类计数、方法计数等）的比较表明，用 Java 编程语言编写的程序比用 C++编写的程序小四倍。

• 编写更好的代码：Java 编程语言鼓励良好的编码实践，自动垃圾回收帮助您避免内存泄漏。其面向对象性质、JavaBeans™组件架构以及广泛、易于扩展的 API 让您可以重用现有、经过测试的代码，并减少引入的错误。

• 更快地开发程序：Java 编程语言比 C++更简单，因此在使用它编写时，您的开发时间可能快两倍。您的程序也将需要更少的代码行。

• 避免平台依赖：通过避免使用其他语言编写的库，您可以使您的程序具有可移植性。

• 一次编写，到处运行：因为用 Java 编程语言编写的应用程序被编译成机器无关的字节码，它们可以在任何 Java 平台上一致运行。

• 更轻松地分发软件：使用 Java Web Start 软件，用户只需单击鼠标即可启动您的应用程序。启动时自动进行版本检查，确保用户始终使用您软件的最新版本。如果有更新可用，Java Web Start 软件将自动更新他们的安装。

课程： “Hello World!” 应用程序

原文：docs.oracle.com/javase/tutorial/getStarted/cupojava/index.html

下面列出的各节提供了编译和运行简单的 “Hello World!” 应用程序的详细说明。第一节提供了有关开始使用 NetBeans IDE 的信息，这是一个极大简化软件开发过程的集成开发环境。NetBeans IDE 可在下面列出的所有平台上运行。其余各节提供了针对不使用集成开发环境开始的特定平台的说明。如果遇到问题，请务必查阅常见问题部分；它提供了许多新用户遇到的问题的解决方案。

“Hello World!” for the NetBeans IDE 这些说明适用于 NetBeans IDE 的用户。NetBeans IDE 在 Java 平台上运行，这意味着您可以在任何有 JDK 7 可用的操作系统上使用它。这些操作系统包括 Microsoft Windows、Solaris OS、Linux 和 Mac OS X。我们建议尽可能使用 NetBeans IDE 而不是命令行。

“Hello World!” for Microsoft Windows 这些命令行指令适用于 Windows XP Professional、Windows XP Home、Windows Server 2003、Windows 2000 Professional 和 Windows Vista 的用户。

“Hello World!” for Solaris OS, Linux, and Mac OS X 这些命令行指令适用于 Solaris OS、Linux 和 Mac OS X 的用户。常见问题（及其解决方案）如果您在编译或运行应用程序时遇到问题，请参考此页面。

“Hello World!” 适用于 NetBeans IDE

原文：docs.oracle.com/javase/tutorial/getStarted/cupojava/netbeans.html

是时候编写您的第一个应用程序了！这些详细说明适用于 NetBeans IDE 的用户。NetBeans IDE 运行在 Java 平台上，这意味着您可以在任何有 JDK 可用的操作系统上使用它。这些操作系统包括 Microsoft Windows、Solaris OS、Linux 和 Mac OS X。

• 一个清单

• 创建您的第一个应用程序

  • 创建一个 IDE 项目

  • 将 JDK 8 添加到平台列表（如果需要）

  • 向生成的源文件添加代码

  • 编译源文件

  • 运行程序

• 使用 NetBeans IDE 继续教程

---

一个清单

要编写您的第一个程序，您需要：

1. Java SE 开发工具包（此示例中选择了 JDK 7）

   • 对于 Microsoft Windows、Solaris OS 和 Linux：Java SE 下载索引 页面

   • 对于 Mac OS X：developer.apple.com

2. NetBeans IDE

   • 对于所有平台：NetBeans IDE 下载索引 页面

---

创建您的第一个应用程序

您的第一个应用程序HelloWorldApp将简单地显示问候语“Hello World!” 要创建此程序，您将：

• 创建一个 IDE 项目

  创建 IDE 项目时，您创建了一个环境，用于构建和运行应用程序。使用 IDE 项目可以消除通常与在命令行上开发相关的配置问题。您可以通过在 IDE 中选择单个菜单项来构建或运行应用程序。

• 向生成的源文件添加代码

  源文件包含用 Java 编程语言编写的代码，您和其他程序员可以理解。作为创建 IDE 项目的一部分，将自动生成一个骨架源文件。然后，您将修改源文件以添加“Hello World!” 信息。

• 编译源文件为 .class 文件

  IDE 调用 Java 编程语言编译器（javac），它接受您的源文件并将其文本翻译为 Java 虚拟机可以理解的指令。该文件中包含的指令称为字节码。

• 运行程序

  IDE 调用 Java 应用程序启动器工具（java），该工具使用 Java 虚拟机来运行您的应用程序。

创建一个 IDE 项目

创建一个 IDE 项目：

1. 运行程序

   • 在 Microsoft Windows 系统上，您可以在“开始”菜单中使用 NetBeans IDE 项目。

   • 在 Solaris OS 和 Linux 系统上，您可以通过导航到 IDE 的 bin 目录并输入 ./netbeans 来执行 IDE 启动脚本。

   • 在 Mac OS X 系统上，单击 NetBeans IDE 应用程序图标。

2. 在 NetBeans IDE 中，选择文件 | 新建项目…。

   

   NetBeans IDE，文件 | 新建项目 菜单项已选择。

3. 在新建项目向导中，展开Java类别，并选择Java 应用程序，如下图所示：

   

   NetBeans IDE，新项目向导，选择项目页面。

4. 在向导的名称和位置页面中，执行以下操作（如下图所示）：

   • 在项目名称字段中，输入Hello World App。

   • 在创建主类字段中，输入helloworldapp.HelloWorldApp。

     

   NetBeans IDE，新项目向导，名称和位置页面。

5. 单击完成。

项目已创建并在 IDE 中打开。您应该看到以下组件：

• 项目窗口，其中包含项目组件的树视图，包括源文件、代码依赖的库等。

• 打开 NetBeans IDE。

• 导航器窗口，您可以使用它快速在所选类中的元素之间导航。

  

  打开的 NetBeans IDE 与 HelloWorldApp 项目。

---

将 JDK 8 添加到平台列表（如果需要）

可能需要将 JDK 8 添加到 IDE 的可用平台列表中。要执行此操作，请选择工具 | Java 平台，如下图所示：

从工具菜单中选择 Java 平台管理器

如果在已安装平台列表中看不到 JDK 8（可能显示为 1.8 或 1.8.0），请单击添加平台，导航到 JDK 8 安装目录，然后单击完成。现在您应该看到这个新添加的平台：

Java 平台管理器

要将此 JDK 设置为所有项目的默认 JDK，您可以在命令行上使用 --jdkhome 开关运行 IDE，或者在 INSTALLATION_DIRECTORY/etc/netbeans.conf 文件的 netbeans_j2sdkhome 属性中输入 JDK 的路径。

要为当前项目指定此 JDK，请在项目窗格中选择Hello World App，选择文件 | 项目属性（Hello World App），单击库，然后在Java 平台下拉菜单中选择JDK 1.8。您应该看到类似以下内容的屏幕：

IDE 现在已配置为 JDK 8。

---

向生成的源文件添加代码

在创建此项目时，在新建项目向导中保留了创建主类复选框。因此，IDE 已为您创建了一个骨架类。您可以通过替换以下行将“Hello World!” 信息添加到骨架代码中：

// TODO code application logic here

用以下行：

System.out.println("Hello World!"); // Display the string.

可选地，您可以替换这四行生成的代码：

/**
 *
 * @author
 */

用以下行：

/**
 * The HelloWorldApp class implements an application that
 * simply prints "Hello World!" to standard output.
 */

这四行是代码注释，不会影响程序的运行。本教程的后续部分将解释代码注释的用法和格式。

在输入时要小心

---

**注意：**确保按照所示输入所有代码、命令和文件名。编译器（javac）和启动器（java）都是区分大小写的，因此您必须保持一致。

HelloWorldApp与helloworldapp不同。

---

通过选择文件 | 保存来保存您的更改。

文件应该该看起来类似于以下内容：

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package helloworldapp;

/**
 * The HelloWorldApp class implements an application that
 * simply prints "Hello World!" to standard output.
 */
public class HelloWorldApp {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Display the string.
    }

}

编译源文件为 .class 文件

要编译您的源文件，请从 IDE 的主菜单中选择运行 | 构建项目（Hello World App）。

输出窗口将打开并显示类似于以下图示的输出：

输出窗口显示 HelloWorld 项目构建的结果。

如果构建输出以“构建成功”结束，则恭喜！您已成功编译了您的程序！

如果构建输出以“构建失败”结束，则您的代码中可能存在语法错误。错误将作为超链接文本显示在输出窗口中。双击此类超链接可导航到错误源。然后，您可以修复错误，再次选择运行 | 构建项目。

构建项目时，将生成字节码文件HelloWorldApp.class。您可以通过打开文件窗口并展开Hello World App/build/classes/helloworldapp节点来查看新文件生成的位置，如下图所示。

文件窗口，显示生成的.class文件。

现在您已经构建了项目，可以运行您的程序。

运行程序

从 IDE 的菜单栏中，选择运行 | 运行主项目。

下图显示了您现在应该看到的内容。

程序将“Hello World！”打印到输出窗口（以及构建脚本的其他输出）。

恭喜！您的程序正常运行！

使用 NetBeans IDE 继续教程

教程的接下来几页将解释这个简单应用程序中的代码。之后，课程将深入探讨核心语言特性，并提供更多示例。尽管教程的其余部分没有提供有关使用 NetBeans IDE 的具体说明，但您可以轻松使用 IDE 编写和运行示例代码。以下是一些关于使用 IDE 的提示以及您可能会看到的一些 IDE 行为的解释：

• 在 IDE 中创建项目后，您可以使用新建文件向导将文件添加到项目中。选择文件 | 新建文件，然后在向导中选择模板，例如空的 Java 文件模板。

• 您可以使用 IDE 的编译文件（F9）和运行文件（Shift-F6）命令编译和运行单个文件（而不是整个项目）。如果您使用运行主项目命令，IDE 将运行 IDE 关联为主项目的主类的文件。因此，如果您在 HelloWorldApp 项目中创建了一个额外的类，然后尝试使用运行主项目命令运行该文件，IDE 将运行HelloWorldApp文件。

• 您可能希望为包含多个源文件的示例应用程序创建单独的 IDE 项目。

• 在 IDE 中输入时，代码完成框可能会定期出现。您可以选择忽略代码完成框并继续输入，或者选择建议的表达式之一。如果您不希望代码完成框自动出现，可以关闭该功能。选择工具 | 选项 | 编辑器，单击代码完成选项卡并清除自动弹出完成窗口复选框。

• 如果您想要重命名项目窗口中源文件的节点，请从 IDE 的主菜单中选择重构。IDE 会提示您使用重命名对话框引导您完成重命名类和更新引用该类的代码的选项。进行更改并单击重构以应用更改。如果您的项目中只有一个类，这一系列点击可能看起来是多余的，但是在更大的项目中，当您的更改影响代码的其他部分时，这是非常有用的。

• 要了解 NetBeans IDE 功能的更详尽指南，请参阅NetBeans 文档页面。

“Hello World!” for Microsoft Windows

原文：docs.oracle.com/javase/tutorial/getStarted/cupojava/win32.html

是时候编写你的第一个应用程序了！以下说明适用于 Windows Vista、Windows 7 和 Windows 8 的用户。其他平台的说明在"Hello World!" for Solaris OS, Linux, and Mac OS X 和"Hello World!" for the NetBeans IDE 中。

如果在本页的说明中遇到问题，请参考常见问题（及其解决方案）。

• 一个清单

• 创建你的第一个应用程序

  • 创建一个源文件

  • 将源文件编译为.class文件

  • 运行程序

---

一个清单

要编写你的第一个程序，你需要：

1. Java SE 开发工具包 8（JDK 8）

   你可以立即下载 Windows 版本。（确保你下载的是JDK，而不是JRE。）请参考安装说明。

2. 一个文本编辑器

   在这个例子中，我们将使用 Notepad，它是 Windows 平台上包含的一个简单编辑器。如果你使用不同的文本编辑器，你可以轻松地调整这些说明。

这两个项目是你编写第一个应用程序所需的全部内容。

---

创建你的第一个应用程序

你的第一个应用程序HelloWorldApp将简单地显示问候语“Hello world!”。为了创建这个程序，你将：

• 创建一个源文件

  一个源文件包含用 Java 编程语言编写的代码，你和其他程序员都可以理解。你可以使用任何文本编辑器来创建和编辑源文件。

• 编译源文件为 .class 文件

  Java 编程语言编译器（javac）接受你的源文件并将其文本翻译为 Java 虚拟机可以理解的指令。该文件中包含的指令称为字节码。

• 运行程序

  Java 应用程序启动器工具（java）使用 Java 虚拟机来运行你的应用程序。

创建一个源文件

要创建一个源文件，你有两个选项：

• 你可以在计算机上保存文件HelloWorldApp.java，避免大量输入。然后，你可以直接转到将源文件编译为.class文件。

• 或者，你可以使用以下（更长的）说明。

首先，启动你的编辑器。你可以从开始菜单中选择程序 > 附件 > 记事本来启动记事本编辑器。在一个新文档中，输入以下代码：

/**
 * The HelloWorldApp class implements an application that
 * simply prints "Hello World!" to standard output.
 */
class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Display the string.
    }
}

输入时要小心

---

**注意：**请按照所示的方式输入所有代码、命令和文件名。编译器（javac）和启动器（java）都是区分大小写的，因此你必须保持一致。

HelloWorldApp与helloworldapp不相同。

---

将代码保存在名为HelloWorldApp.java的文件中。在 Notepad 中执行此操作，首先选择文件 > 另存为…菜单项。然后，在另存为对话框中：

1. 使用保存位置组合框，指定你将保存文件的文件夹（目录）。在这个例子中，目录是C驱动器上的myapplication。

2. 在文件名文本字段中，输入"HelloWorldApp.java"，不包括引号。

3. 从另存为类型组合框中选择文本文档（*.txt）。

4. 在编码组合框中，将编码保留为 ANSI。

当完成后，对话框应该看起来像这样。

在你点击保存之前的另存为对话框。

现在点击保存，然后退出 Notepad。

编译源文件为 .class 文件

打开一个 shell 或“命令”窗口。你可以从开始菜单中选择运行…，然后输入cmd来执行此操作。shell 窗口应该类似于以下图示。

一个 shell 窗口。

提示符显示你的当前目录。当你打开提示符时，你的当前目录通常是 Windows XP 的主目录（如前面的图所示）。

要编译你的源文件，请将当前目录更改为文件所在的目录。例如，如果你的源目录是C驱动器上的myapplication，请在提示符处输入以下命令并按Enter：

cd C:\myapplication

现在提示符应该变成C:\myapplication>。

---

注意：

要切换到另一个驱动器上的目录，你必须输入一个额外的命令：驱动器的名称。例如，要切换到D驱动器上的myapplication目录，你必须输入D:，如下所示：

C:\>D:

D:\>cd myapplication

D:\myapplication>

---

如果在提示符处输入dir，你应该看到你的源文件，如下所示：

C:\>cd myapplication

C:\myapplication>dir
 Volume in drive C is System
 Volume Serial Number is F2E8-C8CC

 Directory of C:\myapplication

2014-04-24  01:34 PM    <DIR>          .
2014-04-24  01:34 PM    <DIR>          ..
2014-04-24  01:34 PM               267 HelloWorldApp.java
               1 File(s)            267 bytes
               2 Dir(s)  93,297,991,680 bytes free

C:\myapplication>

现在你已经准备好编译了。在提示符处，输入以下命令并按Enter。

javac HelloWorldApp.java

编译器已生成一个字节码文件HelloWorldApp.class。在提示符处，输入dir以查看生成的新文件，如下所示：

C:\myapplication>javac HelloWorldApp.java

C:\myapplication>dir
 Volume in drive C is System
 Volume Serial Number is F2E8-C8CC

 Directory of C:\myapplication

2014-04-24  02:07 PM    <DIR>          .
2014-04-24  02:07 PM    <DIR>          ..
2014-04-24  02:07 PM               432 HelloWorldApp.class
2014-04-24  01:34 PM               267 HelloWorldApp.java
               2 File(s)            699 bytes
               2 Dir(s)  93,298,032,640 bytes free

C:\myapplication>

现在你有了一个.class文件，你可以运行你的程序。

如果在这一步的说明中遇到问题，请参考常见问题（及其解决方案）。

运行程序

在同一个目录中，在提示符处输入以下命令：

java -cp . HelloWorldApp

你应该在屏幕上看到以下内容：

C:\myapplication>java -cp . HelloWorldApp
Hello World!

C:\myapplication>

恭喜！你的程序运行成功！

如果在这一步的说明中遇到问题，请参考常见问题（及其解决方案）。

“Hello World!”适用于 Solaris OS、Linux 和 Mac OS X

原文：docs.oracle.com/javase/tutorial/getStarted/cupojava/unix.html

是时候写你的第一个应用程序了！这些详细说明适用于 Solaris OS、Linux 和 Mac OS X 的用户。其他平台的说明在"Hello World!" for Microsoft Windows 和"Hello World!" for the NetBeans IDE 中。

如果你在本页的说明中遇到问题，请查阅常见问题（及其解决方案）。

• 一个清单

• 创建你的第一个应用程序

  • 创建一个源文件

  • 将源文件编译为.class文件

  • 运行程序

---

一个清单

要编写你的第一个程序，你需要：

1. Java SE 开发工具包 8（JDK 8）

   你可以下载适用于 Solaris OS、Linux 或 Mac OS X 的版本。（确保你下载的是JDK，而不是JRE。）请查阅安装说明。

2. 一个文本编辑器

   在这个例子中，我们将使用 Pico，一个适用于许多基于 UNIX 的平台的编辑器。如果你使用不同的文本编辑器，如vi或emacs，你可以轻松地调整这些说明。

这两个项目是你写第一个应用程序所需的全部。

---

创建你的第一个应用程序

你的第一个应用程序，HelloWorldApp，将简单地显示问候语“Hello world!”。要创建这个程序，你需要：

• 创建一个源文件

  一个源文件包含用 Java 编程语言编写的代码，你和其他程序员都可以理解。你可以使用任何文本编辑器来创建和编辑源文件。

• 将源文件编译为.class 文件

  Java 编程语言的编译器(javac)会获取你的源文件并将其文本转换为 Java 虚拟机可以理解的指令。这个.class文件中包含的指令被称为字节码。

• 运行程序

  Java 应用程序启动器工具(java)使用 Java 虚拟机来运行你的应用程序。

创建一个源文件

要创建一个源文件，你有两个选项：

• 你可以将文件HelloWorldApp.java保存在你的计算机上，避免大量输入。然后，你可以直接转到编译源文件。

• 或者，你可以使用以下（更长的）说明。

首先，打开一个 shell 或“终端”窗口。

一个新的终端窗口。

当你首次打开提示符时，你的当前目录通常是你的主目录。你可以随时通过在提示符中输入cd然后按Return来将当前目录更改为主目录。

您创建的源文件应保存在单独的目录中。您可以使用命令mkdir创建目录。例如，要在/tmp目录中创建examples/java目录，请使用以下命令：

cd /tmp
mkdir examples
cd examples
mkdir java

要将当前目录更改为此新目录，请输入：

cd /tmp/examples/java

现在您可以开始创建源文件了。

输入pico并按Return键启动 Pico 编辑器。如果系统显示pico: command not found消息，则 Pico 很可能不可用。请咨询系统管理员获取更多信息，或使用其他编辑器。

启动 Pico 时，它将显示一个新的空缓冲区。这是您将输入代码的区域。

将以下代码输入到新缓冲区中：

/**
 * The HelloWorldApp class implements an application that
 * simply prints "Hello World!" to standard output.
 */
class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Display the string.
    }
}

输入时请小心

---

**注意：**请按照所示的方式输入所有代码、命令和文件名。编译器（javac）和启动器（java）都区分大小写，因此您必须保持一致。

HelloWorldApp与helloworldapp不相同。

---

将代码保存到名为HelloWorldApp.java的文件中。在 Pico 编辑器中，通过输入Ctrl-O，然后在底部看到提示File Name to write:处，输入您希望创建文件的目录，然后输入HelloWorldApp.java。例如，如果您希望在目录/tmp/examples/java中保存HelloWorldApp.java，则输入/tmp/examples/java/HelloWorldApp.java并按Return键。

您可以输入Ctrl-X退出 Pico。

编译源文件为.class文件

打开另一个 shell 窗口。要编译源文件，请将当前目录更改为文件所在的目录。例如，如果您的源目录是/tmp/examples/java，请在提示符处输入以下命令并按Return键：

cd /tmp/examples/java

如果在提示符处输入pwd，您应该看到当前目录，本示例中已更改为/tmp/examples/java。

如果在提示符处输入ls，您应该看到您的文件。

ls命令的结果，显示.java源文件。

现在可以编译源文件了。在提示符处，输入以下命令并按Return键。

javac HelloWorldApp.java

编译器已生成一个字节码文件HelloWorldApp.class。在提示符处，输入ls查看生成的新文件：如下图所示。

ls命令的结果，显示生成的.class文件。

现在您有了一个.class文件，可以运行您的程序了。

如果您在此步骤中遇到问题，请参考常见问题（及其解决方案）。

运行程序

在相同的目录中，在提示符下输入：

java HelloWorldApp

接下来的图示展示了你现在应该看到的内容。

输出将"Hello World!"打印到屏幕上。

恭喜！你的程序正常运行！

如果在这一步的说明中遇到问题，请参考常见问题（及其解决方案）。

教程：深入了解 “Hello World!” 应用程序

原文：docs.oracle.com/javase/tutorial/getStarted/application/index.html

现在你已经看到了 “Hello World!” 应用程序（甚至可能已经编译并运行了它），你可能想知道它是如何工作的。这里再次是它的代码：

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Display the string.
    }
}

“Hello World!” 应用程序由三个主要组件组成：源代码注释、HelloWorldApp 类定义 和 main 方法。以下解释将为您提供对代码的基本理解，但更深层次的含义只有在您完成阅读本教程的其余部分后才会显现。

源代码注释

下面的加粗文本定义了 “Hello World!” 应用程序的注释：

/**
 * The HelloWorldApp class implements an application that
 * simply prints "Hello World!" to standard output.
 */
class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Display the string.
    }
}

注释被编译器忽略，但对其他程序员有用。Java 编程语言支持三种类型的注释：

/* *文本* */

编译器忽略从 /* 到 */ 的所有内容。

/** *文档* */

这表示一个文档注释（doc comment）。编译器忽略这种类型的注释，就像它忽略使用 /* 和 */ 的注释一样。javadoc 工具在准备自动生成的文档时使用文档注释。有关 javadoc 的更多信息，请参阅Javadoc™ 工具文档。

// *文本*

编译器忽略从 // 到行尾的所有内容。

HelloWorldApp 类定义

下面的加粗文本开始了 “Hello World!” 应用程序的类定义块：

/**
 * The HelloWorldApp class implements an application that
 * simply displays "Hello World!" to the standard output.
 */
class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Display the string.
    }
}

如上所示，类定义的最基本形式是：

class *name* {
    . . .
}

关键字 class 开始了名为 name 的类的类定义，每个类的代码都出现在上面加粗的大括号之间。第二章概述了一般的类，第四章详细讨论了类。现在知道每个应用程序都以类定义开始就足够了。

main 方法

下面的加粗文本开始了 main 方法的定义：

/**
 * The HelloWorldApp class implements an application that
 * simply displays "Hello World!" to the standard output.
 */
class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); //Display the string.
    }
}

在 Java 编程语言中，每个应用程序必须包含一个签名为 main 的方法：

public static void main(String[] args)

修饰符 public 和 static 可以以任何顺序编写（public static 或 static public），但约定是使用如上所示的 public static。你可以将参数命名为任何你想要的东西，但大多数程序员选择 “args” 或 “argv”。

main 方法类似于 C 和 C++ 中的 main 函数；它是应用程序的入口点，并随后将调用程序所需的所有其他方法。

main 方法接受一个参数：类型为 String 的元素数组。

public static void main(String[] args)

这个数组是运行时系统向你的应用程序传递信息的机制。例如：

java *MyApp* *arg1* *arg2*

数组中的每个字符串被称为命令行参数。命令行参数让用户在不重新编译应用程序的情况下影响其操作。例如，一个排序程序可能允许用户通过以下命令行参数指定按降序排序数据：

-descending

“Hello World!” 应用程序忽略了它的命令行参数，但你应该意识到这些参数确实存在。

最后，这行代码：

System.out.println("Hello World!");

使用核心库中的System类将"Hello World!“消息打印到标准输出。本教程的其余部分将讨论该库的部分内容（也称为"应用程序编程接口"或"API”）。

问题和练习：入门指南

原文：docs.oracle.com/javase/tutorial/getStarted/QandE/questions.html

问题

问题 1：当编译用 Java 编写的程序时，编译器将人类可读的源文件转换为 Java 虚拟机可以理解的平台无关代码。这个平台无关代码叫什么？

问题 2：以下哪个不是有效的注释：

a. /** 注释 */

b. /* 注释 */

c. /* 注释

d. // 注释

问题 3：如果在运行时看到以下错误，你应该首先检查什么？

Exception in thread "main" java.lang.NoClassDefFoundError:
HelloWorldApp.java.

问题 4：main方法的正确签名是什么？

问题 5：在声明main方法时，public和static中哪个修饰符必须先出现？

问题 6：main方法定义了哪些参数？

练习

练习 1：修改HelloWorldApp.java程序，使其显示Hola Mundo!而不是Hello World!。

练习 2：你可以在这里找到一个稍作修改的HelloWorldApp版本：HelloWorldApp2.java

程序出现错误。修复错误以使程序成功编译和运行。错误是什么？

检查你的答案。

教训：常见问题（及其解决方法）

原文：docs.oracle.com/javase/tutorial/getStarted/problems/index.html

编译器问题

Microsoft Windows 系统上的常见错误消息

**'javac' is not recognized as an internal or external command, operable program or batch file**

如果你收到这个错误，Windows 找不到编译器(javac)。

下面是告诉 Windows 如何找到javac的一种方法。假设你将 JDK 安装在C:\jdk1.8.0中。在提示符下，你可以输入以下命令并按回车：

C:\jdk1.8.0\bin\javac HelloWorldApp.java

如果选择此选项，每次编译或运行程序时，都需要在C:\jdk1.8.0\bin\之前加上javac和java命令。为了避免这种额外的输入，可以参考 JDK 8 安装说明中的更新 PATH 变量部分。

**Class names, 'HelloWorldApp', are only accepted if annotation processing is explicitly requested**

如果你收到这个错误，那么在编译程序时忘记包含.java后缀。记住，命令是javac HelloWorldApp.java而不是javac HelloWorldApp。

UNIX 系统上的常见错误消息

javac: Command not found

如果你收到这个错误，UNIX 找不到编译器javac。

下面是告诉 UNIX 如何找到javac的一种方法。假设你将 JDK 安装在/usr/local/jdk1.8.0中。在提示符下，你可以输入以下命令并按回车：

/usr/local/jdk1.8.0/javac HelloWorldApp.java

注意： 如果选择此选项，每次编译或运行程序时，都需要在javac和java命令之前加上/usr/local/jdk1.8.0/。为了避免这种额外的输入，你可以将这些信息添加到你的 PATH 变量中。具体操作步骤将取决于你当前正在运行的 shell。

**Class names, 'HelloWorldApp', are only accepted if annotation processing is explicitly requested**

如果你收到这个错误，那么在编译程序时忘记包含.java后缀。记住，命令是javac HelloWorldApp.java而不是javac HelloWorldApp。

语法错误（所有平台）

如果你在程序的某个部分打错了字，编译器可能会发出语法错误。错误信息通常显示错误的类型、检测到错误的行号、该行的代码以及错误在代码中的位置。以下是由于在语句末尾省略分号(;)而引起的错误：

Testing.java:8: error: ';' expected
            count++
                   ^
1 error

如果你看到任何编译器错误，那么你的程序没有成功编译，编译器没有创建.class文件。仔细检查程序，修复你发现的任何错误，然后再试一次。

语义错误

除了验证你的程序在语法上是否正确之外，编译器还会检查其他基本的正确性。例如，每次使用未初始化的变量时，编译器都会警告你：

Testing.java:8: error: variable count might not have been initialized
            count++;
            ^
Testing.java:9: error: variable count might not have been initialized
        System.out.println("Input has " + count + " chars.");
                                          ^
2 errors

再次，你的程序没有成功编译，编译器没有创建.class文件。修复错误并重试。

运行时问题

Microsoft Windows 系统上的错误消息

主线程中的异常"main" java.lang.NoClassDefFoundError: HelloWorldApp

如果你收到这个错误，java找不到你的字节码文件HelloWorldApp.class。

java尝试查找你的.class文件的一个地方是你当前的目录。所以如果你的.class文件在C:\java中，你应该将当前目录更改为那个目录。要更改你的目录，请在提示符下输入以下命令并按回车键：

cd c:\java

提示符应该变成C:\java>。如果你在提示符下输入dir，你应该看到你的.java和.class文件。现在再次输入java HelloWorldApp。

如果你仍然遇到问题，你可能需要更改你的 CLASSPATH 变量。要查看是否需要这样做，请尝试使用以下命令清除类路径。

set CLASSPATH=

现在再次输入java HelloWorldApp。如果程序现在可以运行，那么你需要更改你的 CLASSPATH 变量。要设置这个变量，请参考 JDK 8 安装说明中的更新 PATH 变量部分。CLASSPATH 变量的设置方式相同。

**找不到或加载主类 HelloWorldApp.class**

初学者程序员常犯的一个常见错误是尝试在编译器创建的.class文件上运行java启动器。例如，如果你尝试用java HelloWorldApp.class而不是java HelloWorldApp来运行你的程序，你会得到这个错误。记住，参数是你想要使用的类名，不是文件名。

主线程中的异常"main" java.lang.NoSuchMethodError: main

Java 虚拟机要求你执行的类具有一个main方法，用于开始执行你的应用程序。深入了解"Hello World!"应用程序详细讨论了main方法。

UNIX 系统上的错误消息

主线程中的异常"main" java.lang.NoClassDefFoundError: HelloWorldApp

如果你收到这个错误，java找不到你的字节码文件HelloWorldApp.class。

java尝试查找你的字节码文件的一个地方是你当前的目录。所以，例如，如果你的字节码文件在/home/jdoe/java中，你应该将当前目录更改为那个目录。要更改你的目录，请在提示符下输入以下命令并按回车键：

cd /home/jdoe/java

如果你在提示符下输入pwd，你应该看到/home/jdoe/java。如果你在提示符下输入ls，你应该看到你的.java和.class文件。现在再次输入java HelloWorldApp。

如果你仍然遇到问题，你可能需要更改你的 CLASSPATH 环境变量。要查看是否需要这样做，请尝试使用以下命令清除类路径。

unset CLASSPATH

现在再次输入java HelloWorldApp。如果程序现在可以运行，你需要像上面的 PATH 变量一样更改你的 CLASSPATH 变量。

**主线程中的异常"main"java.lang.NoClassDefFoundError: HelloWorldApp/class**

初学者程序员常犯的一个错误是尝试在编译器创建的.class文件上运行java启动器。例如，如果你尝试用java HelloWorldApp.class而不是java HelloWorldApp来运行你的程序，你会得到这个错误。记住，参数是你想要使用的类名，而不是文件名。

主线程中的异常"main"java.lang.NoSuchMethodError: main

Java 虚拟机要求你执行的类具有一个main方法，用于开始执行你的应用程序。深入了解"Hello World!"应用程序详细讨论了main方法。

小程序或 Java Web Start 应用程序被阻止

如果你通过浏览器运行一个应用程序并收到安全警告说应用程序被阻止，请检查以下项目：

• 验证 JAR 文件清单中的属性是否针对应用程序运行的环境正确设置。权限属性是必需的。在 NetBeans 项目中，你可以通过在 NetBeans IDE 的文件选项卡中展开项目文件夹并双击manifest.mf来打开清单文件。

• 验证应用程序是否由有效证书签名，并且证书位于签名者 CA 密钥库中。

• 如果你正在运行一个本地小程序，建立一个用于测试的 Web 服务器。你也可以将你的应用程序添加到例外站点列表中，在 Java 控制面板的安全选项卡中管理。

教程：学习 Java 语言

原文：docs.oracle.com/javase/tutorial/java/index.html

本教程涵盖了使用 Java 编程语言的基础知识。

教授您面向对象编程背后的核心概念：对象、消息、类和继承。本课程最后展示了这些概念如何转化为代码。如果您已经熟悉面向对象编程，可以跳过本课程。

描述了语言的传统特性，包括变量、数组、数据类型、运算符和控制流。

描述了如何编写创建对象的类，以及如何创建和使用对象。

是一种元数据形式，为编译器提供信息。本课程描述了在程序中有效使用注解的位置和方式。

描述了接口——它们是什么，为什么要编写一个，以及如何编写一个。本节还描述了如何从一个类派生另一个类的方式。也就是说，子类如何从超类继承字段和方法。您将了解到所有类都是从Object类派生的，以及如何修改子类从超类继承的方法。

本课程描述了如何使用Number和String对象。本课程还向您展示如何为输出格式化数据。

是 Java 编程语言的一个强大特性。它们提高了代码的类型安全性，使得更多的错误在编译时可检测到。

是 Java 编程语言的一个特性，帮助您组织和结构化类及其彼此之间的关系。

课程：面向对象编程概念

原文：docs.oracle.com/javase/tutorial/java/concepts/index.html

如果您以前从未使用过面向对象的编程语言，您需要在开始编写任何代码之前学习一些基本概念。本课程将向您介绍对象、类、继承、接口和包。每个讨论重点介绍这些概念如何与现实世界相关联，同时向您介绍 Java 编程语言的语法。

什么是对象？

对象是相关状态和行为的软件包。软件对象通常用于模拟日常生活中找到的现实世界对象。本课程解释了如何在对象内表示状态和行为，介绍了数据封装的概念，并解释了以这种方式设计软件的好处。

什么是类？

类是创建对象的蓝图或原型。本节定义了一个模拟现实世界对象状态和行为的类。它有意专注于基础知识，展示了即使一个简单的类也可以清晰地模拟状态和行为。

什么是继承？

继承为组织和构建软件提供了一个强大而自然的机制。本节解释了类如何从它们的超类继承状态和行为，并解释了如何使用 Java 编程语言提供的简单语法从一个类派生另一个类。

什么是接口？

接口是类与外部世界之间的契约。当一个类实现一个接口时，它承诺提供该接口发布的行为。本节定义了一个简单的接口，并解释了任何实现它的类需要做出的必要更改。

什么是包？

包是一个用于以逻辑方式组织类和接口的命名空间。将代码放入包中使得大型软件项目更易于管理。本节解释了为什么这很有用，并向您介绍了 Java 平台提供的应用程序编程接口（API）。

问题和练习：面向对象编程概念

使用本节中提出的问题和练习来测试你对对象、类、继承、接口和包的理解。

什么是对象？

原文：docs.oracle.com/javase/tutorial/java/concepts/object.html

对象是理解面向对象技术的关键。现在看看周围，你会发现许多现实世界的对象：你的狗，你的桌子，你的电视机，你的自行车。

现实世界的对象共享两个特征：它们都有状态和行为。狗有状态（名字、颜色、品种、饥饿）和行为（叫、取东西、摇尾巴）。自行车也有状态（当前档位、当前踏板速度、当前速度）和行为（换档、改变踏板速度、刹车）。识别现实世界对象的状态和行为是开始以面向对象编程思考的好方法。

现在花一分钟观察你周围的现实世界对象。对于每个你看到的对象，问自己两个问题：“这个对象可能处于什么状态？”和“这个对象可能执行什么行为？”。确保写下你的观察。当你这样做时，你会注意到现实世界的对象在复杂性上有所不同；你的台灯可能只有两种可能的状态（开和关）和两种可能的行为（打开、关闭），但你的收音机可能有额外的状态（开、关、当前音量、当前频道）和行为（打开、关闭、增加音量、减小音量、搜索、扫描和调谐）。你还可能注意到一些对象反过来也会包含其他对象。这些现实世界的观察都可以转化为面向对象编程的世界。

一个软件对象。

软件对象在概念上类似于现实世界的对象：它们也由状态和相关行为组成。对象将其状态存储在字段（某些编程语言中的变量）中，并通过方法（某些编程语言中的函数）公开其行为。方法操作对象的内部状态，并作为对象间通信的主要机制。隐藏内部状态并要求所有交互通过对象的方法执行被称为数据封装——这是面向对象编程的基本原则。

以自行车为例：

以软件对象建模的自行车。

通过赋予状态（当前速度、当前踏板速度和当前档位）并提供改变该状态的方法，对象保持控制外部世界如何使用它。例如，如果自行车只有 6 个档位，一个改变档位的方法可以拒绝任何小于 1 或大于 6 的值。

将代码捆绑到单独的软件对象中提供了许多好处，包括：

1. 模块化：一个对象的源代码可以独立编写和维护，与其他对象的源代码无关。一旦创建，一个对象可以在系统内轻松传递。

2. 信息隐藏：通过仅与对象的方法交互，其内部实现的细节对外部世界保持隐藏。

3. 代码重用：如果一个对象已经存在（可能是由另一个软件开发人员编写），你可以在你的程序中使用该对象。这使得专家可以实现/测试/调试复杂的、任务特定的对象，然后你可以相信这些对象在你自己的代码中运行。

4. 可插拔性和调试便利性：如果一个特定对象出现问题，你可以简单地将其从应用程序中移除，并插入一个不同的对象作为替代。这类似于在现实世界中修复机械问题。如果一个螺栓断了，你只替换它，而不是整个机器。

什么是类？

原文：docs.oracle.com/javase/tutorial/java/concepts/class.html

在现实世界中，你经常会发现许多同类的个体对象。可能存在成千上万其他同款同型号的自行车。每辆自行车都是根据相同的蓝图构建的，因此包含相同的组件。在面向对象的术语中，我们说你的自行车是已知为自行车的对象类的实例。一个类是创建个体对象的蓝图。

以下的Bicycle类是自行车的一种可能实现：

class Bicycle {

    int cadence = 0;
    int speed = 0;
    int gear = 1;

    void changeCadence(int newValue) {
         cadence = newValue;
    }

    void changeGear(int newValue) {
         gear = newValue;
    }

    void speedUp(int increment) {
         speed = speed + increment;   
    }

    void applyBrakes(int decrement) {
         speed = speed - decrement;
    }

    void printStates() {
         System.out.println("cadence:" +
             cadence + " speed:" + 
             speed + " gear:" + gear);
    }
}

Java 编程语言的语法对你来说可能是新的，但这个类的设计是基于之前讨论的自行车对象的。字段cadence、speed和gear代表对象的状态，而方法（changeCadence、changeGear、speedUp等）定义了它与外部世界的交互。

你可能已经注意到Bicycle类中没有包含main方法。那是因为它不是一个完整的应用程序；它只是可能在应用程序中使用的自行车的蓝图。创建和使用新的Bicycle对象的责任属于你的应用程序中的某个其他类。

这里有一个BicycleDemo类，它创建了两个独立的Bicycle对象并调用它们的方法：

class BicycleDemo {
    public static void main(String[] args) {

        // Create two different 
        // Bicycle objects
        Bicycle bike1 = new Bicycle();
        Bicycle bike2 = new Bicycle();

        // Invoke methods on 
        // those objects
        bike1.changeCadence(50);
        bike1.speedUp(10);
        bike1.changeGear(2);
        bike1.printStates();

        bike2.changeCadence(50);
        bike2.speedUp(10);
        bike2.changeGear(2);
        bike2.changeCadence(40);
        bike2.speedUp(10);
        bike2.changeGear(3);
        bike2.printStates();
    }
}

这个测试的输出打印了两辆自行车的结束踏板节奏、速度和档位：

cadence:50 speed:10 gear:2
cadence:40 speed:20 gear:3

什么是继承？

原文：docs.oracle.com/javase/tutorial/java/concepts/inheritance.html

不同类型的对象通常彼此之间有一定的共同点。例如，山地自行车、公路自行车和双人自行车都共享自行车的特征（当前速度、当前踏板节奏、当前齿轮）。但每种自行车也定义了使它们不同的附加特征：双人自行车有两个座位和两套把手；公路自行车有下弯把手；一些山地自行车有额外的链环，使它们具有更低的齿轮比。

面向对象编程允许类从其他类中继承常用的状态和行为。在这个例子中，Bicycle现在成为MountainBike、RoadBike和TandemBike的超类。在 Java 编程语言中，每个类都允许有一个直接的超类，而每个超类都有无限数量的子类的潜力：

自行车类的层次结构。

创建子类的语法很简单。在类声明的开头，使用extends关键字，后面跟上要继承的类的名称：

class MountainBike extends Bicycle {

    // new fields and methods defining 
    // a mountain bike would go here

}

这使得MountainBike拥有与Bicycle相同的所有字段和方法，但允许其代码专注于使其独特的特征。这使得子类的代码易于阅读。然而，您必须小心地记录每个超类定义的状态和行为，因为该代码不会出现在每个子类的源文件中。

什么是接口？

原文：docs.oracle.com/javase/tutorial/java/concepts/interface.html

正如你已经学到的，对象通过暴露的方法定义它们与外部世界的交互。方法构成了对象与外部世界的接口；例如，电视机前面的按钮是你和塑料外壳另一侧的电线之间的接口。你按下“电源”按钮来打开和关闭电视。

在最常见的形式中，一个接口是一组相关方法，这些方法没有具体实现。如果将自行车的行为规定为一个接口，可能如下所示：

interface Bicycle {

    //  wheel revolutions per minute
    void changeCadence(int newValue);

    void changeGear(int newValue);

    void speedUp(int increment);

    void applyBrakes(int decrement);
}

要实现这个接口，你的类的名称会改变（例如，变成一个特定品牌的自行车，比如ACMEBicycle），并且在类声明中使用implements关键字：

class ACMEBicycle implements Bicycle {

    int cadence = 0;
    int speed = 0;
    int gear = 1;

   // The compiler will now require that methods
   // changeCadence, changeGear, speedUp, and applyBrakes
   // all be implemented. Compilation will fail if those
   // methods are missing from this class.

    void changeCadence(int newValue) {
         cadence = newValue;
    }

    void changeGear(int newValue) {
         gear = newValue;
    }

    void speedUp(int increment) {
         speed = speed + increment;   
    }

    void applyBrakes(int decrement) {
         speed = speed - decrement;
    }

    void printStates() {
         System.out.println("cadence:" +
             cadence + " speed:" + 
             speed + " gear:" + gear);
    }
}

实现一个接口允许一个类更加正式地承诺提供的行为。接口形成了类与外部世界之间的契约，这个契约在编译时由编译器强制执行。如果你的类声称实现了一个接口，那么该接口定义的所有方法必须在类的源代码中出现，类才能成功编译。

---

注意： 要实际编译ACMEBicycle类，你需要在实现的接口方法开头添加public关键字。你将在后面关于类和对象以及接口和继承的课程中了解这样做的原因。

---

什么是包？

原文：docs.oracle.com/javase/tutorial/java/concepts/package.html

包是一个命名空间，用于组织一组相关的类和接口。从概念上讲，你可以将包想象成计算机上的不同文件夹。你可以将 HTML 页面放在一个文件夹中，将图片放在另一个文件夹中，将脚本或应用程序放在另一个文件夹中。由于用 Java 编写的软件可能由数百甚至数千个单独的类组成，因此将相关的类和接口放入包中进行组织是有意义的。

Java 平台提供了一个庞大的类库（一组包），适用于在你自己的应用程序中使用。这个库被称为“应用程序编程接口”，简称为“API”。它的包代表了与通用编程最常相关的任务。例如，一个String对象包含了字符字符串的状态和行为；一个File对象允许程序员轻松地在文件系统上创建、删除、检查、比较或修改文件；一个Socket对象允许创建和使用网络套接字；各种 GUI 对象控制按钮、复选框以及与图形用户界面相关的任何其他内容。有成千上万的类可供选择。这使得你作为程序员可以专注于设计你特定应用程序的部分，而不是需要使其工作所需的基础设施。

Java 平台 API 规范包含了 Java SE 平台提供的所有包、接口、类、字段和方法的完整列表。在浏览器中加载该页面并将其加为书签。作为程序员，它将成为你最重要的参考文档。

问题和练习：面向对象编程概念

原文：docs.oracle.com/javase/tutorial/java/concepts/QandE/questions.html

问题

1. 现实世界的对象包含 ___ 和 ___。

2. 一个软件对象的状态存储在 ___ 中。

3. 一个软件对象的行为通过 ___ 暴露。

4. 将内部数据隐藏在外部世界之外，并仅通过公开的方法访问它被称为数据 ___。

5. 软件对象的蓝图被称为 ___。

6. 共同行为可以在 ___ 中定义，并通过 ___ 关键字继承到 ___ 中。

7. 一个没有实现的方法集合被称为 ___。

8. 通过功能组织类和接口的命名空间被称为 ___。

9. API 一词代表 ___？

练习

1. 为你在本教程开始时观察到的每个现实世界对象创建新的类。如果忘记所需的语法，请参考 Bicycle 类。

2. 对于你上面创建的每个新类，创建一个定义其行为的接口，然后要求你的类实现它。省略一两个方法并尝试编译。错误是什么样的？

检查你的答案。

课程：语言基础

原文：docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html

变量

对象将它们的状态存储在字段中，这一点你已经学过了。然而，Java 编程语言也使用术语“变量”。本节讨论了这种关系，以及变量命名规则和约定，基本数据类型（原始类型、字符串和数组），默认值和字面值。

运算符

本节描述了 Java 编程语言的运算符。它首先介绍了最常用的运算符，然后介绍了较少使用的运算符。每个讨论都包括您可以编译和运行的代码示例。

表达式、语句和块

运算符可用于构建计算值的表达式；表达式是语句的核心组件；语句可以分组成块。本节使用您已经看过的示例代码讨论了表达式、语句和块。

控制流语句

本节描述了 Java 编程语言支持的控制流语句。它涵盖了决策、循环和分支语句，使您的程序能够有条件地执行特定的代码块。

变量

译文：docs.oracle.com/javase/tutorial/java/nutsandbolts/variables.html

正如您在上一课中学到的，对象将其状态存储在 字段 中。

int cadence = 0;
int speed = 0;
int gear = 1;

什么是对象？ 讨论向您介绍了字段，但您可能仍有一些疑问，比如：字段的命名规则和约定是什么？除了 int，还有哪些其他数据类型？字段在声明时必须初始化吗？如果未明确初始化，字段是否被分配默认值？我们将在本课程中探讨这些问题的答案，但在此之前，您必须首先了解一些技术上的区别。在 Java 编程语言中，术语 “字段” 和 “变量” 都被使用；这是新开发人员常见的困惑源，因为两者似乎经常指的是同一件事情。

Java 编程语言定义了以下类型的变量：

• 实例变量（非静态字段） 从技术上讲，对象将其各自的状态存储在 “非静态字段” 中，即没有使用 static 关键字声明的字段。非静态字段也被称为 实例变量，因为它们的值对类的每个 实例（换句话说，对每个对象）都是唯一的；一个自行车的 currentSpeed 与另一个自行车的 currentSpeed 是独立的。

• 类变量（静态字段） 类变量 是使用 static 修饰符声明的任何字段；这告诉编译器，无论类被实例化多少次，该变量都只存在一份副本。为特定类型的自行车定义齿轮数量的字段可以标记为 static，因为概念上相同数量的齿轮将适用于所有实例。代码 static int numGears = 6; 将创建这样一个静态字段。此外，关键字 final 可以添加以指示齿轮数量永远不会改变。

• 局部变量 类似于对象将其状态存储在字段中，方法通常将其临时状态存储在 局部变量 中。声明局部变量的语法类似于声明字段（例如，int count = 0;）。没有特殊的关键字将变量标记为局部变量；这一决定完全取决于变量声明的位置——即在方法的大括号之间。因此，局部变量仅对声明它们的方法可见；它们无法从类的其他部分访问。

• 参数 你已经在Bicycle类和"Hello World!“应用程序的main方法中看到了参数的示例。回想一下，main方法的签名是public static void main(String[] args)。在这里，args变量是该方法的参数。重要的是要记住参数总是被分类为"变量"而不是"字段”。这也适用于其他接受参数的结构（如构造函数和异常处理程序），你将在本教程后面学习到。

说到这一点，本教程的其余部分在讨论字段和变量时使用以下一般准则。如果我们在谈论"一般字段"（不包括局部变量和参数），我们可能会简单地说"字段"。如果讨论适用于"以上所有内容"，我们可能会简单地说"变量"。如果上下文需要区分，我们将使用适当的具体术语（静态字段、局部变量等）。您还可能偶尔看到术语"成员"被使用。类型的字段、方法和嵌套类型统称为成员。

命名

每种编程语言都有其自己的规则和约定，用于允许使用的名称类型，而 Java 编程语言也不例外。关于为变量命名的规则和约定可以总结如下：

• 变量名区分大小写。变量的名称可以是任何合法标识符——以字母、美元符号"$“或下划线字符”_“开头的 Unicode 字母和数字的无限长度序列。然而，约定是始终以字母开头，而不是”$“或”_“。此外，按照约定，美元符号字符根本不使用。您可能会发现一些情况下自动生成的名称会包含美元符号，但您的变量名应始终避免使用它。下划线字符也存在类似的约定；虽然以”_"开头的变量名在技术上是合法的，但这种做法是不鼓励的。不允许使用空格。

• 后续字符可以是字母、数字、美元符号或下划线字符。这条规则也适用于约定（和常识）。在为变量选择名称时，使用完整的单词而不是神秘的缩写。这样做将使您的代码更易于阅读和理解。在许多情况下，这也将使您的代码自我记录；例如，命名为cadence、speed和gear的字段比缩写版本（如s、c和g）更直观。还要记住，您选择的名称不能是关键字或保留字。

• 如果您选择的名称只包含一个单词，请将该单词拼写为全部小写字母。如果名称由多个单词组成，请将每个后续单词的第一个字母大写。名称gearRatio和currentGear是这种约定的典型例子。如果您的变量存储一个常量值，比如static final int NUM_GEARS = 6，约定会略有变化，每个字母都大写，并用下划线字符分隔后续单词。按照约定，下划线字符在其他地方永远不会被使用。

原始数据类型

原文：docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Java 编程语言是静态类型的，这意味着所有变量在使用之前必须先声明。这涉及声明变量的类型和名称，就像你已经看到的那样：

int gear = 1;

这样做告诉您的程序，存在一个名为“gear”的字段，保存数值数据，并具有“1”的初始值。变量的数据类型确定它可能包含的值，以及可以对其执行的操作。除了int之外，Java 编程语言还支持其他七种原始数据类型。原始类型由语言预定义，并由保留关键字命名。原始值不与其他原始值共享状态。Java 编程语言支持的八种原始数据类型是：

• byte: byte 数据类型是一个 8 位有符号的二进制补码整数。它的最小值为-128，最大值为 127（包括边界值）。在需要实际节省内存的大数组中，byte数据类型可能很有用。它们也可以用于代替int，在这种情况下，它们的限制有助于澄清代码；变量的范围受限可以作为一种文档形式。

• short: short 数据类型是一个 16 位有符号的二进制补码整数。它的最小值为-32,768，最大值为 32,767（包括边界值）。与byte一样，相同的准则适用：在需要实际节省内存的大数组中，可以使用short来节省内存。

• int: 默认情况下，int数据类型是一个 32 位有符号的二进制补码整数，其最小值为-2³¹，最大值为 2³¹-1。在 Java SE 8 及更高版本中，可以使用int数据类型来表示无符号的 32 位整数，其最小值为 0，最大值为 2³²-1。使用 Integer 类将int数据类型用作无符号整数。有关更多信息，请参阅“数字类”部分。已向Integer类添加了compareUnsigned、divideUnsigned等静态方法，以支持无符号整数的算术运算。

• long: long 数据类型是一个 64 位的二进制补码整数。有符号的long的最小值为-2⁶³，最大值为 2⁶³-1。在 Java SE 8 及更高版本中，可以使用long数据类型来表示无符号的 64 位长整数，其最小值为 0，最大值为 2⁶⁴-1。当需要比int提供的值范围更广时，请使用此数据类型。Long类还包含诸如compareUnsigned、divideUnsigned等方法，以支持无符号长整数的算术运算。

• float：float数据类型是一个单精度 32 位 IEEE 754 浮点数。其值的范围超出了本讨论的范围，但在 Java 语言规范的浮点类型、格式和值部分中有规定。与对byte和short的建议一样，如果需要在大量浮点数数组中节省内存，则使用float（而不是double）。这种数据类型永远不应该用于精确值，比如货币。对于这种情况，你将需要使用java.math.BigDecimal类。数字和字符串介绍了BigDecimal和 Java 平台提供的其他有用类。

• double：double数据类型是一个双精度 64 位 IEEE 754 浮点数。其值的范围超出了本讨论的范围，但在 Java 语言规范的浮点类型、格式和值部分中有规定。对于十进制值，这种数据类型通常是默认选择。如上所述，这种数据类型永远不应该用于精确值，比如货币。

• boolean：boolean数据类型只有两个可能的值：true和false。使用这种数据类型来跟踪真/假条件的简单标志。这种数据类型表示一位信息，但其“大小”并没有明确定义。

• char：char数据类型是一个单个的 16 位 Unicode 字符。它的最小值为'\u0000'（或 0），最大值为'\uffff'（或 65,535，包括在内）。

除了上面列出的八种基本数据类型外，Java 编程语言还通过java.lang.String类提供了对字符字符串的特殊支持。将字符字符串放在双引号中将自动创建一个新的String对象；例如，String s = "this is a string";。String对象是不可变的，这意味着一旦创建，它们的值就不能被更改。String类在技术上不是一个基本数据类型，但考虑到语言对它的特殊支持，你可能会倾向于将其视为基本数据类型。你将在简单数据对象中了解更多关于String类的信息。

默认值

在声明字段时，不总是需要为其赋值。声明但未初始化的字段将由编译器设置为一个合理的默认值。一般来说，这个默认值将是零或null，取决于数据类型。然而，依赖这些默认值通常被认为是不良的编程风格。

以下图表总结了上述数据类型的默认值。

数据类型	默认值（对于字段）
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘\u0000’
String（或任何对象）	null
boolean	false

局部变量略有不同；编译器永远不会为未初始化的局部变量分配默认值。如果无法在声明变量的地方初始化局部变量，请确保在尝试使用之前为其赋值。访问未初始化的局部变量将导致编译时错误。

字面值

您可能已经注意到，在初始化原始类型变量时不使用 new 关键字。原始类型是内置到语言中的特殊数据类型；它们不是从类创建的对象。字面值 是固定值的源代码表示形式；字面值直接在您的代码中表示，无需计算。如下所示，可以将字面值分配给原始类型变量：

boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;

整数字面值

如果整数字面值以字母 L 或 l 结尾，则其类型为 long；否则为 int。建议使用大写字母 L，因为小写字母 l 很难与数字 1 区分。

整型 byte、short、int 和 long 的值可以从 int 字面值创建。超出 int 范围的 long 类型值可以从 long 字面值创建。整数字面值可以用以下数字系统表示：

• 十进制：基数为 10，其数字由数字 0 到 9 组成；这是您每天使用的数字系统

• 十六进制：基数为 16，其数字由数字 0 到 9 和字母 A 到 F 组成

• 二进制：基数为 2，其数字由数字 0 和 1 组成（您可以在 Java SE 7 及更高版本中创建二进制字面值）

对于通用编程，十进制系统可能是您唯一使用的数字系统。但是，如果需要使用其他数字系统，以下示例显示了正确的语法。前缀 0x 表示十六进制，0b 表示二进制：

// The number 26, in decimal
int decVal = 26;
//  The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;

浮点字面值

浮点字面值如果以字母 F 或 f 结尾，则其类型为 float；否则其类型为 double，并且可以选择以字母 D 或 d 结尾。

浮点类型（float 和 double）也可以使用 E 或 e（科学计数法）、F 或 f（32 位浮点字面值）和 D 或 d（64 位双精度字面值；这是默认值，按照惯例省略）来表示。

double d1 = 123.4;
// same value as d1, but in scientific notation
double d2 = 1.234e2;
float f1  = 123.4f;

字符和字符串字面值

char和String类型的字面量可以包含任何 Unicode（UTF-16）字符。如果您的编辑器和文件系统允许，您可以直接在代码中使用这些字符。如果不允许，您可以使用"Unicode 转义"，例如'\u0108'（带抑扬符的大写 C），或"S\u00ED Se\u00F1or"（西班牙语中的 Sí Señor）。始终使用’单引号’表示char字面量，使用"双引号"表示String字面量。Unicode 转义序列可以在程序的其他地方使用（例如，在字段名称中），不仅仅在char或String字面量中。

Java 编程语言还支持一些特殊的转义序列，用于char和String字面量：\b（退格）、\t（制表符）、\n（换行符）、\f（换页符）、\r（回车符）、\"（双引号）、\'（单引号）和\\（反斜杠）。

还有一个特殊的null字面量，可以用作任何引用类型的值。null可以赋给任何变量，除了原始类型的变量。对于null值，除了测试其是否存在外，几乎无法做任何操作。因此，在程序中，null通常用作指示某个对象不可用的标记。

最后，还有一种特殊的字面量称为类字面量，通过取类型名称并附加".class"形成；例如，String.class。这指的是代表类型本身的对象（类型为Class）。

在数字字面量中使用下划线字符

在 Java SE 7 及更高版本中，任何数量的下划线字符（_）可以出现在数字字面量中的任何位置。此功能使您能够，例如，将数字字面量中的数字分组，从而提高代码的可读性。

例如，如果您的代码包含许多位数的数字，您可以使用下划线字符将数字分组为三位一组，类似于您如何使用逗号或空格等标点符号作为分隔符。

以下示例展示了您可以在数字字面量中使用下划线的其他方式：

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi =  3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;

您只能在数字之间放置下划线；不能在以下位置放置下划线：

• 在数字的开头或结尾

• 邻近浮点字面量中的小数点

• 在F或L后缀之前

• 在期望出现一串数字的位置

以下示例演示了数字字面量中有效和无效的下划线放置方式（已突出显示）：

// Invalid: cannot put underscores
// adjacent to a decimal point
float pi1 = 3_.1415F;
// Invalid: cannot put underscores 
// adjacent to a decimal point
float pi2 = 3._1415F;
// Invalid: cannot put underscores 
// prior to an L suffix
long socialSecurityNumber1 = 999_99_9999_L;

// OK (decimal literal)
int x1 = 5_2;
// Invalid: cannot put underscores
// At the end of a literal
int x2 = 52_;
// OK (decimal literal)
int x3 = 5_______2;

// Invalid: cannot put underscores
// in the 0x radix prefix
int x4 = 0_x52;
// Invalid: cannot put underscores
// at the beginning of a number
int x5 = 0x_52;
// OK (hexadecimal literal)
int x6 = 0x5_2; 
// Invalid: cannot put underscores
// at the end of a number
int x7 = 0x52_;

数组

原文：docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

数组是一个容器对象，它保存单一类型的固定数量的值。数组的长度在创建数组时确定。创建后，其长度是固定的。你已经在"Hello World!"应用程序的main方法中看到了数组的一个示例。本节将更详细地讨论数组。

一个包含 10 个元素的数组。

数组中的每个项称为元素，每个元素通过其数字索引访问。如前面的插图所示，编号从 0 开始。例如，第 9 个元素将在索引 8 处访问。

下面的程序，ArrayDemo，创建了一个整数数组，向数组中放入一些值，并将每个值打印到标准输出。

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];

        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        System.out.println("Element at index 0: "
                           + anArray[0]);
        System.out.println("Element at index 1: "
                           + anArray[1]);
        System.out.println("Element at index 2: "
                           + anArray[2]);
        System.out.println("Element at index 3: "
                           + anArray[3]);
        System.out.println("Element at index 4: "
                           + anArray[4]);
        System.out.println("Element at index 5: "
                           + anArray[5]);
        System.out.println("Element at index 6: "
                           + anArray[6]);
        System.out.println("Element at index 7: "
                           + anArray[7]);
        System.out.println("Element at index 8: "
                           + anArray[8]);
        System.out.println("Element at index 9: "
                           + anArray[9]);
    }
} 

该程序的输出是：

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000

在实际的编程情况中，你可能会使用支持的循环结构之一来遍历数组的每个元素，而不是像前面的示例中那样逐行编写。然而，该示例清楚地说明了数组的语法。你将在 Control Flow 部分学习各种循环结构（for、while和`do-while）。

声明一个变量来引用一个数组

前面的程序用以下代码声明了一个数组（名为anArray）：

// declares an array of integers
int[] anArray;

与其他类型的变量声明类似，数组声明有两个组成部分：数组的类型和数组的名称。数组的类型写作*type*[]，其中*type*是包含元素的数据类型；方括号是特殊符号，表示该变量保存一个数组。数组的大小不是其类型的一部分（这就是为什么方括号是空的）。数组的名称可以是任何你想要的，只要遵循之前在 naming 部分讨论的规则和约定。与其他类型的变量一样，声明并不会实际创建一个数组；它只是告诉编译器这个变量将保存指定类型的数组。

同样，你也可以声明其他类型的数组：

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

你也可以将方括号放在数组名称后面：

// this form is discouraged
float anArrayOfFloats[];

然而，约定不鼓励这种形式；方括号标识数组类型，应该与类型标识一起出现。

创建、初始化和访问数组

用new运算符创建数组的一种方法。ArrayDemo程序中的下一条语句分配了足够内存以容纳 10 个整数元素的数组，并将该数组分配给anArray变量。

// create an array of integers
anArray = new int[10];

如果缺少这个语句，那么编译器会打印如下错误，并且编译失败：

ArrayDemo.java:4: Variable anArray may not have been initialized.

接下来的几行为数组的每个元素赋值：

anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // and so forth

每个数组元素都通过其数字索引访问：

System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);

或者，您可以使用快捷语法来创建和初始化一个数组：

int[] anArray = { 
    100, 200, 300,
    400, 500, 600, 
    700, 800, 900, 1000
};

这里数组的长度由大括号中提供的数值数量和逗号分隔确定。

您还可以通过使用两个或更多组括号（如String[][] names）声明一个数组的数组（也称为多维数组）。因此，必须通过相应数量的索引值访问每个元素。

在 Java 编程语言中，多维数组是其组件本身为数组的数组。这与 C 或 Fortran 中的数组不同。由此产生的一个结果是，行的长度允许变化，如下面的MultiDimArrayDemo程序所示：

class MultiDimArrayDemo {
    public static void main(String[] args) {
        String[][] names = {
            {"Mr. ", "Mrs. ", "Ms. "},
            {"Smith", "Jones"}
        };
        // Mr. Smith
        System.out.println(names[0][0] + names[1][0]);
        // Ms. Jones
        System.out.println(names[0][2] + names[1][1]);
    }
}

此程序的输出为：

Mr. Smith
Ms. Jones

最后，您可以使用内置的length属性来确定任何数组的大小。以下代码将数组的大小打印到标准输出：

 System.out.println(anArray.length);

复制数组

System类有一个arraycopy方法，您可以使用它来高效地将数据从一个数组复制到另一个数组中：

public static void arraycopy(Object src, int srcPos,
                             Object dest, int destPos, int length)

两个Object参数指定要从中复制的数组源和要复制到的数组目标。三个int参数指定源数组中的起始位置，目标数组中的起始位置，以及要复制的数组元素数量。

以下程序，ArrayCopyDemo，声明了一个String元素数组。它使用System.arraycopy方法将数组组件的子序列复制到第二个数组中：

class ArrayCopyDemo {
    public static void main(String[] args) {
        String[] copyFrom = {
            "Affogato", "Americano", "Cappuccino", "Corretto", "Cortado",   
            "Doppio", "Espresso", "Frappucino", "Freddo", "Lungo", "Macchiato",      
            "Marocchino", "Ristretto" };

        String[] copyTo = new String[7];
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        for (String coffee : copyTo) {
            System.out.print(coffee + " ");           
        }
    }
}

此程序的输出为：

Cappuccino Corretto Cortado Doppio Espresso Frappucino Freddo 

数组操作

数组是编程中使用的一个强大而有用的概念。Java SE 提供了一些用于执行与数组相关的最常见操作的方法。例如，ArrayCopyDemo示例使用System类的arraycopy方法，而不是手动迭代源数组的元素并将每个元素放入目标数组中。这是在后台执行的，使开发人员只需使用一行代码调用该方法。

为了方便起见，Java SE 在java.util.Arrays类中提供了几种执行数组操作（如复制、排序和搜索数组等常见任务）的方法。例如，前面的示例可以修改为使用java.util.Arrays类的copyOfRange方法，如您可以在ArrayCopyOfDemo示例中看到的那样。不同之处在于，使用copyOfRange方法不需要在调用方法之前创建目标数组，因为目标数组是由该方法返回的：

class ArrayCopyOfDemo {
    public static void main(String[] args) {
        String[] copyFrom = {
            "Affogato", "Americano", "Cappuccino", "Corretto", "Cortado",   
            "Doppio", "Espresso", "Frappucino", "Freddo", "Lungo", "Macchiato",      
            "Marocchino", "Ristretto" };

        String[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);        
        for (String coffee : copyTo) {
            System.out.print(coffee + " ");           
        }            
    }
}

如您所见，该程序的输出相同，尽管代码行数更少。请注意，copyOfRange 方法的第二个参数是要复制的范围的初始索引（包括），而第三个参数是要复制的范围的最终索引，不包括。在此示例中，要复制的范围不包括索引为 9 的数组元素（其中包含字符串Lungo）。

java.util.Arrays 类中的一些其他有用操作包括：

• 搜索数组以找到特定值的索引位置（binarySearch 方法）。

• 比较两个数组以确定它们是否相等（equals 方法）。

• 填充数组以在每个索引处放置特定值（fill 方法）。

• 将数组按升序排序。可以顺序执行，使用sort 方法，也可以并行执行，使用 Java SE 8 中引入的parallelSort 方法。在多处理器系统上，并行排序大型数组比顺序数组排序更快。

• 创建使用数组作为其源的流（stream 方法）。例如，以下语句以与前面示例相同的方式打印copyTo数组的内容：

  java.util.Arrays.stream(copyTo).map(coffee -> coffee + " ").forEach(System.out::print);  
  
  

  有关流的更多信息，请参见聚合操作。

• 将数组转换为字符串。toString 方法将数组的每个元素转换为字符串，用逗号分隔，然后用括号括起来。例如，以下语句将copyTo数组转换为字符串并打印出来：

  System.out.println(java.util.Arrays.toString(copyTo)); 
  
  

  此语句打印如下内容：

  [Cappuccino, Corretto, Cortado, Doppio, Espresso, Frappucino, Freddo] 
  
  

变量总结

原文：docs.oracle.com/javase/tutorial/java/nutsandbolts/variablesummary.html

Java 编程语言在其术语中同时使用“字段”和“变量”。实例变量（非静态字段）对于类的每个实例都是唯一的。类变量（静态字段）是用static修饰的字段；无论类被实例化多少次，类变量都只有一个副本。局部变量在方法内部存储临时状态。参数是向方法提供额外信息的变量；局部变量和参数始终被分类为“变量”（而不是“字段”）。在命名字段或变量时，有一些规则和约定您应该（或必须）遵循。

八种基本数据类型分别为：byte、short、int、long、float、double、boolean 和 char。java.lang.String 类表示字符串。编译器会为上述类型的字段分配一个合理的默认值；对于局部变量，永远不会分配默认值。字面值是固定值的源代码表示。数组是一个容器对象，它保存了单一类型的固定数量的值。数组的长度在创建数组时确定，创建后其长度是固定的。

问题和练习：变量

原文：docs.oracle.com/javase/tutorial/java/nutsandbolts/QandE/questions_variables.html

问题

1. "实例变量"是 ___ 的另一个名称。

2. "类变量"是 ___ 的另一个名称。

3. 本地变量存储临时状态；它声明在 ___ 内。

4. 在方法签名的括号内声明的变量称为 ____。

5. Java 编程语言支持的八种基本数据类型是什么？

6. 字符串由类 ___ 表示。

7. 一个 ___ 是一个容器对象，它保存单一类型的固定数量的值。

练习

1. 创建一个定义一些字段的小程序。尝试创建一些非法的字段名称，看看编译器会产生什么样的错误。使用命名规则和约定作为指南。

2. 在你在练习 1 中创建的程序中，尝试将字段保持未初始化并打印出它们的值。尝试对局部变量执行相同操作，看看你能产生什么样的编译器错误。熟悉常见的编译器错误将使您更容易识别代码中的错误。

检查你的答案