Intellij IDEA 入门手册（一）

原文：Beginning IntelliJ IDEA

协议：CC BY-NC-SA 4.0

一、入门指南

在本章中，我们将介绍以下内容:

• 要使用哪个版本

• [计] 下载

• 安装和配置

要使用哪个版本

IDEA 有两种版本，终极版和社区版。

社区版(以下简称 CE)是 IntelliJ IDEA 的免费开源版本。如果你是一个初学编程的人或者是一个周末战士，这个版本可能最适合你。您可以免费使用 IntelliJ。IDEA CE 支持一些编程语言，比如 Java、Groovy、Kotlin、Scala、Python、Dart、HTML 等。

CE 不是一个残缺的版本，绝对不是；这是一个称职的编辑；也没有角度和附加条件。没有截止日期。你可以免费使用它。永远。

终极版是 IDEA 的付费选项。它做了 CE 所做的一切(当然)，还做了更多。它支持更多的语言、更多的框架、更多的工具等等。在一个表格上比较这两个版本要容易得多，所以我们现在就来比较一下。表 1-1 比较了社区版和旗舰版的特性和支持。

表 1-1

IDEA 社区与终极版

|   |   |

终极版

|

社区版

|
| — | — | — | — |
| 语言支持 | 爪哇 | -好的 | -好的 |
| 绝妙的 | -好的 | -好的 |
| 我的锅 | -好的 | -好的 |
| 缩放(通过插件) | -好的 | -好的 |
| Python 和 Jython(通过插件) | -好的 | -好的 |
| Dart(通过插件) | -好的 | -好的 |
| Rust(通过插件) | -好的 | -好的 |
| HTML、XML、JSON、YAML | -好的 | -好的 |
| XSL，XPath | -好的 | -好的 |
| 降价 | -好的 | -好的 |
| JavaScript，TypeScript | -好的 |   |
| 咖啡脚本，动作脚本 | -好的 |   |
| 结构化查询语言 | -好的 |   |
| CSS，Saas，SCSS，Less，手写笔 | -好的 |   |
| Ruby 和 JRuby | -好的 |   |
| 服务器端编程语言（Professional Hypertext Preprocessor 的缩写） | -好的 |   |
| 去 | -好的 |   |
| 框架支持 | 机器人 | -好的 | -好的 |
| 摇摆 | -好的 | -好的 |
| 应用 | -好的 | -好的 |
| Spring (Spring MVC，Spring Boot，Spring Integration，Spring Security 等。) | -好的 |   |
| 春云 | -好的 |   |
| 爪哇 EE/雅加达 EE (JSF、JAX-RS、CDI、JPA 等。) | -好的 |   |
| 冬眠 | -好的 |   |
| Micronaut | -好的 |   |
| 圣杯 | -好的 |   |
| 总重量 | -好的 |   |
| 播放(通过插件) | -好的 |   |
| 百里香叶，自由标记，速度 | -好的 |   |
| AspectJ | -好的 |   |
| 阿卡，SSP，Play2 | -好的 |   |
| 硒 | -好的 |   |
| 反应，原生反应 | -好的 |   |
| 角度，角度 JS | -好的 |   |
| view . js-检视. js | -好的 |   |
| 铁轨上的红宝石 | -好的 |   |
| 姜戈，烧瓶，金字塔 | -好的 |   |
| Drupal，WordPress，Laravel，Symfony | -好的 |   |
| 构建工具 | 专家 | -好的 | -好的 |
| 格拉德尔 | -好的 | -好的 |
| 蚂蚁 | -好的 | -好的 |
| SBT bllop fury | -好的 | -好的 |
| 新公共管理 | -好的 |   |
| 网页包 | -好的 |   |
| 大口，咕噜 | -好的 |   |
| 集成开发工具 | 调试器 | -好的 | -好的 |
| 反编译程序 | -好的 | -好的 |
| 字节码查看器 | -好的 | -好的 |
| 测试覆盖率 | -好的 | -好的 |
| 测试跑步者(JUnit、TestNG、Spock、Cucumber、ScalaTest、spec2 等。) | -好的 | -好的 |
| 嵌入式终端 | -好的 | -好的 |
| 数据库工具/SQL | -好的 |   |
| http client(http 客户端) | -好的 |   |
| 分析工具 | -好的 |   |
| 版本控制 | 吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人吉卜赛人 | -好的 | -好的 |
| 破坏 | -好的 | -好的 |
| 水银的 | -好的 | -好的 |
| Team Foundation Server(通过插件) | -好的 | -好的 |
| 不得已 | -好的 |   |
| 部署 | 坞站，坞站复合 | -好的 | -好的 |
| 雄猫 | -好的 |   |
| 汤米，汤米 | -好的 |   |
| GlassFish | -好的 |   |
| 树脂 | -好的 |   |
| 码头 | -好的 |   |
| 室女宫 | -好的 |   |
| JBoss，野猫队 | -好的 |   |
| 中间件 | -好的 |   |
| WebSphere，自由 | -好的 |   |
| 忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈 | -好的 |   |
| 其他人 | 自定义主题(通过插件) | -好的 | -好的 |
| 问题跟踪集成(YouTrack、JIRA、GitHub、TFS、灯塔、Pivotal Tracker、Redmine、Trac 等。) | -好的 | -好的 |
| 图表(UML，依赖关系) | -好的 |   |
| 依存结构矩阵 | -好的 |   |
| 检测重复项 | -好的 |   |
| 通过 JetBrains 帐户同步设置 | -好的 |   |
| 客户支持 | 资源 | 问题跟踪和社区论坛 | 问题跟踪和社区论坛 |
| 支持 | 担保 | 可能的 |
| 许可证 |   | 商业 | Opensource，Apache 2.0 |

IDEA 终极版的定价信息位于 www.jetbrains.com/store 。

获取 Java 开发工具包

最好在安装 IDEA 之前安装 Java 开发工具包(JDK)标准版。当您这样做时，IDEA 会自动检测 JDK 安装，这将为您节省一些配置时间。

您有几个选择来使用 JDK，但是两个更受欢迎的选择是

• 甲骨文 JDK——你可以从这里下载安装程序: www.oracle.com/java/technologies/javase-downloads.html 。

• open JDK——你可以在这里找到下载链接和安装说明: https://openjdk.java.net/install/ 。

对于这本书，我用了甲骨文 JDK。你不必做同样的事情。如果您喜欢的话，可以使用 OpenJDK。

从我提供的前面的链接中获取适合您的操作系统的安装程序。图 1-1 显示了 JDK 下载的 Oracle 页面——在撰写本文时，JDK 是第 15 版。

图 1-1

Java SE 下载页面

你应该点击“JDK 下载”链接。最好也下载文档。那以后会派上用场的。

Oracle 将要求您同意许可协议，然后才能继续。

在 macOS 上安装

在 macOS 上安装 JDK 非常简单:只需双击下载的 DMG 文件，然后按照提示操作，直到完成。安装程序负责更新系统路径，因此安装后您不需要执行任何进一步的操作。

在 Windows 上安装

在 Windows 上，双击下载的安装程序文件，然后按照提示操作直到完成，就像在 macOS 中一样；但是与 macOS 不同，你需要在系统路径中包含 JDK 工具和二进制文件。您需要知道如何在 Windows 上执行以下操作:

1. 在您的 OS 系统路径中包含 Java/bin

2. 在系统路径中添加一个类路径定义

请注意，如果您想从 Windows 命令行使用 JDK 工具，只需执行上述步骤。如果你想从一个 like IDEA 中单独使用 JDK，你不需要这么做。

在 Linux 上安装

在 Linux 上安装 Java 有一个 tarball 选项。如果你用的是 RHEL、Fedora 或 CentOS，还有一个 RPM 选项。这些都可以从我前面提到的 Oracle 链接中获得。

或者，您可以使用 PPA 安装 JDK。本指令适用于 Debian 及其衍生产品，例如 Ubuntu、Mint 等。

在终端窗口中，键入以下命令:

sudo add-apt-repository ppa:linuxuprising/java

像往常一样输入您的用户密码。然后，检查更新并安装脚本

sudo apt update
sudo apt install oracle-java15-installer oracle-java15-set-default

当脚本完成时，您的系统上将会安装 JDK 15。

获取和安装 IntelliJ IDEA

在安装 IDEA 之前，请确保您的机器满足推荐的要求——让我们跳过最低硬件要求，因为，我们在骗谁呢，在一台勉强满足最低要求的机器上工作几乎是不可能的。安装 IDEA 的推荐硬件规格如下:

• RAM–8GB RAM(越多越好)。

• 磁盘–有大量备用空间的固态硬盘。

• 显示器分辨率–全高清(1920 x 1080)；尽可能去 4K。你能负担得起的屏幕空间越大越好。

• OS–最新 64 位版本的 Windows、macOS 或 Linux(例如 Debian、Ubuntu 或 RHEL)。

JetBrains 建议您使用工具箱应用程序来安装 IntelliJ IDEA，但这不是我们在这里将使用的。出于我们的目的，我们将使用独立的安装方法。

让我们从 www.jetbrains.com/idea/download/ 得到 CE 安装程序的想法。下载适合您平台的安装程序。您可以在 Windows、macOS 和 Linux 上安装 IDEA。

安装 IntelliJ IDEA

在窗口上

下载安装程序。双击安装程序运行它，然后按照向导完成。在安装过程中，您可以配置以下内容:

• 创建桌面快捷方式。

• 将 IDEA 命令行启动器添加到系统路径中。这很方便，我建议你勾选这个框。

• 将项目 Open Folder 作为项目添加到系统上下文菜单中(当你右击一个文件夹时)。

• 将特定的文件扩展名与 IntelliJ IDEA 相关联，以便双击打开它们。

图 1-2 显示了设置选项。

图 1-2

IntelliJ 安装选项

安装完成后，启动 IntelliJ。

在苹果电脑上

对于 macOS，请遵循以下步骤:

1. 下载 DMG 安装程序。

2. 双击安装程序来安装它。

3. 将 IntelliJ IDEA 应用程序拖放到**/应用程序**文件夹中。

4. 在 Finder 中，进入 /Applications 文件夹，右键点击 IntelliJ IDEA，然后选择“打开”；macOS 可能会询问您是否要打开该应用程序。第一次在 macOS 中启动 IntelliJ 时，可能会出现这种情况。

在 Linux 上

在 Linux 上，二进制安装程序是 tarball 格式的(ideaC-2020.3 . tar . gz)；下载吧。然后，将它解压缩到您拥有“执行”权限的文件夹中，如下所示

sudo tar -xzf ideaIU.tar.gz -C /opt

Note

不要在现有 IntelliJ 安装的目录下解压缩 tarball，以免您想要覆盖当前的应用程序——这可能会导致冲突。

接下来，转到解压缩 IntelliJ 的目录，然后运行 idea.sh 文件。

配置 IntelliJ

当您第一次运行 IntelliJ 时，它需要您的一些输入。首先，它会询问你是否想要导入一些你以前对 IntelliJ 的设置——也就是说，如果你以前已经安装了它。图 1-3 显示此提示。

图 1-3

导入 IntelliJ 意见设置

您可以在随后的窗口中选择深色或浅色主题，如图 1-4 所示。

图 1-4

自定义 IntelliJ

您可以继续探索首次启动配置选项，也可以跳过这一步——我就是这么做的。

之后，您将看到 IntelliJ 的欢迎屏幕，如下所示:

关键要点

这里没有太多要注意的，因为我们所做的只是设置；但是如果有什么可以带走的话，我想应该是下面这些:

• 确保在安装 IntelliJ 之前已经安装了 JDK。

• 在安装之前，请确保您的机器符合 IntelliJ 的要求。它不是一个非常重的 IDE(相对于它的同类产品，如 Eclipse 或 NetBeans)，但它也不像程序编辑器那样轻(想想 Sublime)。

• 在 Linux 中，确保将 IntelliJ 安装在您拥有“执行”权限的文件夹中。JetBrains 建议将其安装在/opt 文件夹中，但您可以将其安装在任何您喜欢的位置。

二、创建和运行项目

我们将在本章中介绍如下:

• 创建项目

• 建造它

• 运行它

您需要知道的基本任务是在 IntelliJ 中创建、构建和运行项目。这就是我们在本章要做的。

使用 IntelliJ 时，您需要习惯项目的概念，因为如果没有项目结构，您在 IntelliJ 中无法做很多事情。如果您想要构建一个应用程序，您需要创建一个项目并将源代码(和其他资产)添加到该项目中。

构建基本的 Java 项目

如果你还没有启动 IntelliJ，现在是时候了；打开后，您会看到欢迎窗口(如图 2-1 所示)。

图 2-1

欢迎来到 IntelliJ IDEA

突出显示的四个选项允许我们处理一个项目:

• 新项目——这个选项相当简单明了。它将让您从头开始创建一个项目。

• 打开或导入——这将让我们指向一个现有的项目，并让 IntelliJ 从该文件夹中引入所有工件。在此过程中，IntelliJ 将在加载项目时创建一个新的项目配置文件。

• 从 VCS 获得–如果你已经设置了版本控制(我们还没有)，你可以使用这个选项从像 GitHub、Bitbucket 或本地回购协议这样的回购协议中加载项目。

• 搜索项目–当你已经创建了几个项目时，在这个打开的屏幕上会有一个很长的列表。您可以使用“搜索项目”功能快速启动项目。

让我们创建一个新项目。选择新建项目。

你会看到新建项目对话框(如图 2-2 )。

图 2-2

新项目

如您所见，IntelliJ 让我们可以使用 Kotlin、Groovy 和 Java 等编程语言来处理各种项目。我们将使用 Java。

如图 2-2 所示，IntelliJ 已经检测到我安装的 JDK；对我来说，是 JDK 15 号。如果您的机器中有多个 JDK 版本，您可以单击 Project SDK 下拉按钮(如图 2-3 所示)来选择您想要使用的 JDK。

图 2-3

新项目，项目 SDK

我将跳过“附加库和框架”部分，因为我现在不需要任何东西，然后单击下一步**。**

在接下来的窗口中，IntelliJ 允许您从模板创建一个项目(如图 2-4 所示)。

图 2-4

新项目，模板

我会选择一个命令行 App ，然后点击下一个。

在下一个窗口中，我们将输入项目的名称、包和位置，如图 2-5 所示。

图 2-5

项目名称、位置和包

这是一个“Hello World”项目，所以我将使用“Hello”作为项目名称。

项目位置显示 IntelliJ 将存储项目文件的位置。IntelliJ 显示项目文件的默认位置，但是如果您希望将其存储在不同的位置，您可以更改它—如果您希望这样做，请单击省略号(带有三个点的按钮)。

基础包将指定您将在项目中创建的类的名称空间。

对名称、位置和包满意后，单击下一步继续。

IntelliJ 开始创建你的闪亮的新项目，在随后的窗口中，它显示了Main.java文件(如图 2-6 )。

图 2-6

Main.java，与“日积月累”

第一次在 IntelliJ 中创建项目时，会弹出 TOD(每日提示)对话框，并且它会在每次启动 IDE 时一直显示，除非您勾选了不显示提示复选框。我只是把托德留在那里——因为小费给得太多了。您可以点击关闭按钮退出对话框。

现在可以看到我们的主程序了(图 2-7 )。

图 2-7

Main.java

编辑Main.java以匹配清单 2-1 中显示的代码。

package com.workingdev.net;

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Listing 2-1Main.java

完成后，您可以通过进入主菜单栏，然后进入文件 ➤ 全部保存来保存更改，如图 2-8 所示。或者，您可以使用键盘快捷键来保存文件:

图 2-8

全部保存

• cmd + S (macOS)

• CTRL + S (Linux 和 Windows)

IntelliJ 中一个很好的省时工具 Eclipse 中没有——是打开“自动保存”的选项。你可以在首选项(macOS)或者设置(Linux/Windows)中打开这个功能，然后进入外观和行为 ➤ 系统设置 ➤ 自动保存(如图 2-9 )。

图 2-9

首选项|自动保存

下一步是构建项目。你可以从主菜单栏中选择构建 ➤ 构建项目，如图 2-10 所示。

图 2-10

构建项目

当构建完成时，你会注意到在项目工具窗口中会出现一个名为 out 的新橙色文件夹(如图 2-11 )。

图 2-11

项目工具窗口中的 out 文件夹

out 文件夹包含生成的类文件。 out 文件夹被标记为橙色，因为它被排除在项目之外——它毕竟是生成的代码，所以它是有意义的。

您可以用不同的方式标记文件夹。如果你想更深入地探索它，尝试使用 out 文件夹上的上下文菜单，然后选择标记目录(如图 2-12 )。

图 2-12

将目录标记为

你现在不需要做任何改变。我只是想指出 IntelliJ 在标记文件夹方面能做些什么。如果您向项目中添加一些临时资源，但这些资源不一定是项目的一部分(如输出目录)，或者当您创建测试根文件夹时(单元测试时)，这可能会很方便。

下一步是运行程序。进入主菜单栏，然后进入运行 ➤ 运行主，如图 2-13 所示。

图 2-13

奔跑

IDE 底部弹出输出窗口(如图 2-14 所示)并打印我们程序的结果。

图 2-14

Hello World 输出

给你。这就是如何在 IntelliJ 中创建和运行 Java 项目。

建设大型项目

在这一节中，我将向您展示 IntelliJ 如何处理大型项目。你不必跟着来。事实上，我建议您不要这样做，因为我们还没有能力解决导入重要项目所带来的问题。

我要做的是从 GitHub home repo 下载 IntelliJ IDEA CE 的源代码(如图 2-15 ) https://github.com/JetBrains/intellij-community 。这个项目是巨大的。已经分叉了三千八百次；它有 320 个分支机构和 614 个贡献者。这不是一个微不足道的项目。

图 2-15

IntelliJ 在 GitHub 上休息

我将通过点击“代码”按钮下载项目(如图 2-16 )。我去拿压缩文件。

图 2-16

下载 ZIP

我将解压压缩文件，然后在 IntelliJ 中打开它。“Hello World”项目仍然在我的机器中打开，所以我将进入主菜单栏，然后进入文件 ➤ 打开，然后指向我解压缩压缩文件的目录。

IntelliJ 将加载项目的所有工件并创建新的配置。在这个过程中，我需要解决一些冲突，如版本，SDK 设置等。；但是一旦完成，来自 GitHub 的 IntelliJ 项目将被加载。

我将构建项目，就像我们如何构建“Hello World”项目一样。IntelliJ 忙于构建项目(如图 2-17 所示)。

图 2-17

IntelliJ 项目加载到 IntelliJ 中

这不会是一个短暂的过程。这要花一点时间，足够我喝点咖啡，吃点快餐了。

当它最终完成时，我将运行这个项目， et voila ，我将再次看到 IntelliJ 的欢迎窗口——我不会再向您展示它了，因为您已经看过了。

关键要点

• 从头开始创建项目非常简单。您可以从“欢迎”窗口执行此操作。

• 您可以将现有项目加载到 IntelliJ 中；只需使用欢迎窗口中的打开选项，并指向现有项目的文件夹。

• IntelliJ 是一个非常有能力的 IDE 它可以处理大型项目——这就是我向您展示如何从 IntelliJ 内部构建 IntelliJ IDE 本身的原因。如果 IntelliJ 能处理这么大的项目，我打赌它也能处理你的项目。

三、项目文件

我们将在本章中介绍如下:

• IntelliJ 模块

• 那个。创意文件夹

• out 文件夹

• 外部库

在前一章中，我们创建了一个小项目。内容不多，但它让我们体验了 IntelliJ 中的项目创建、编译和执行。在这一章中，我们将更仔细地看看组成 IntelliJ 项目的文件。

大多数足够先进的 ide，除了简单编辑源文件之外，还会生成包含配置、状态、首选项等的专有文件。IntelliJ 也不例外。

本章将着眼于 IntelliJ 作为项目的一部分生成的一些文件。

iml 文件

这包含基本的模块信息。IntelliJ 中的模块不同于 Java 模块(在 Java 9 中引入)。IntelliJ 模块是一个独立的功能块，可以在 IDE 中独立运行、测试和调试。一个项目可能包含不止一个模块，它可能包含诸如源代码、构建脚本、单元测试、部署描述符等内容。iml 文件描述了一个模块。

图 3-1 显示了示例 iml 文件的内容。

图 3-1

显示 iml 文件的小项目

如您所见，这个项目中只有一个模块。它是随着项目自动创建的。您可以根据需要向项目中添加模块。

项目中的每个模块可以使用特定的 SDK，甚至可以根据项目设置继承一个 SDK。清单 3-1 显示了我们的(默认)iml 文件的内容。

<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
    </content>
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
</module>

Listing 3-1test.iml

那个。创意文件夹

。idea 文件夹是应用于整个项目的配置文件的集合，不管它包含多少模块。这是每个项目的根本。图 3-2 显示了一个带有的项目。项目工具窗口中展开的 idea 文件夹。

图 3-2

的内容。创意文件夹

当您更改项目设置或 IDE 设置时，这些更改将反映在中的一个文件中。创意文件夹。如果您更改了 JDK 设置、将模块添加到项目、更改了编码等。这些改变会使它成为这些文件中的一个。最好不要手动编辑这些文件。

如果这是您第一次使用 IntelliJ，您可能想知道是否应该包含。源代码管理中的 idea 文件夹。JetBrains 建议所有的内容。idea 文件夹，保存一个，放在源码控制中。您不应该签入的是 workspace.xml ，因为它包含您对项目的个人偏好；只是给你的。

SRC 文件夹

src 文件夹是我们完成大部分工作的地方。您可能已经猜到，src 是源代码的缩写，就像源代码一样。图 3-3 显示了编辑窗口中显示的源代码。

图 3-3

Main.java 显示在主编辑窗口中。

我们的小示例项目只有一个 Java 源文件，它在 com 下。公司文件夹，如图 3-3 所示。IntelliJ 将源文件放在与包声明同名的文件夹下。

当您添加代码(在同一个包中)时，您会在相同的文件夹名称下看到它们。当您添加一个代码时，不在同一个包中，一个新的文件夹(带有新包声明的名称)将被添加到 src 文件夹中。

Out 文件夹

当您运行或生成代码时，另一个文件夹将被添加到项目的根目录中。那就是 out 文件夹(如图 3-4 )。

图 3-4

out 文件夹的内容

out 文件夹包含可执行的 Java 文件(字节码)。如果你点击 Main.class 文件尝试查看其内容，IntelliJ 不会打开类文件的内容；而是会提示你是否要反编译(如图 3-5 )。

图 3-5

JetBrains 反编译程序

反编译器是一个很有价值的工具，尤其是当你不能访问可执行文件的源程序时。这里有一点来自 JetBrains 的警告，因为如你所知，反编译程序的使用是一个灰色地带。反编译器有合法的用途，也有不正当的原因。不管怎样，为了我们的好奇心，让我们反编译一下，好吗？毕竟这是我们自己的项目。要使用反编译器，必须点击“接受”(图 3-5 )。

图 3-6 显示了反编译后的 Main.class 。

图 3-6

反编译 Main.class

外部库

在“外部库”文件夹中，您可以看到项目所依赖的所有库。我们创建了一个简单的项目，所以除了 JDK 图书馆之外，现在没什么可看的(如图 3-7 所示)。

图 3-7

外部库文件夹的内容

关键要点

• IntelliJ 将其项目和 IDE 设置保存在内的 XML 文件中。创意文件夹。当您对项目、IDE 或您的环境进行更改时，这些更改会保存在中的文件中。创意文件夹。

• JetBrains 建议我们保留。源代码管理中的 idea 文件夹，除了 workspace.xml 。你应该把它放进去。 gitignore 文件(如果你使用 Git 的话)。

• IntelliJ 有一个内置的反编译器，可以用来查看反编译类的源代码。

四、IDE 工具

在本章中，我们将介绍以下内容:

• 项目工具窗口

• 导航栏

• 结构工具窗口

• 临时文件

• 待办事项

• 问题工具窗口

• 末端的

• 主要编辑

IntelliJ 是一个健壮的 IDE。虽然它很快，但它并不完全是轻量级的——这是有充分理由的。它的功能非常丰富。在这一章中，我们将看看一些最常用的 IntelliJ 工具。

IDE

让我们先熟悉一下 IDE。图 4-1 显示了你可能最常使用的 IDE 的一些部分。

图 4-1

IntelliJ IDEA(项目已打开)

| -什么 | **主菜单栏**–这是导航 IntelliJ 的主要方式，但这里的大多数项目都有键盘快捷键，所以知道这些快捷键是有好处的，尤其是对于你经常使用的命令。JetBrains 在其网站上维护了一个页面，列出了最常用的键盘快捷键；你应该把它做成书签——或者更好，把它打印出来贴在你的笔记本上，别在你的公告板上，等等。下面是链接: [`www.jetbrains.com/help/idea/mastering-keyboard-shortcuts.html`](http://www.jetbrains.com/help/idea/mastering-keyboard-shortcuts.html) 。 | | ➋ | **导航条**–该导航条是动态的。当你进行一项操作时，它会在这里留下你的脚印，就像一些网站上的面包屑一样。如果你想追溯你的步骤，这是非常有用的。 | | ➌ | **工具栏**–在这里你可以找到最常见的开发任务，例如，运行应用程序、调试应用程序、搜索、设置等。 | | -你好 | **编辑窗口**——节目的明星。这是你做编码工作的地方。当您启动一个文件(从项目工具窗口)时，IntelliJ 会在这里打开它进行编辑。 | | ➎ | **项目工具窗口**–您可以在这里浏览您的项目。您可以从该窗口启动任何项目文件。 | | ➏ | **工具窗口栏**–它沿着 IDE 的周边运行。如您所见，它包含了启动特定工具窗口所需的各个按钮，如收藏夹、结构、问题、待办事项、终端等。 | | -好的 | **显示/隐藏工具窗口**–显示或隐藏工具窗口栏。这是个开关。 |

项目工具窗口

在主编辑器窗口旁边，项目工具窗口可能是您花费大量时间的地方。此窗口显示项目的各种视图。它还允许您在项目中添加、移除或重新定位项目。项目工具窗口是将项目文件启动到主编辑器窗口的主要方式；双击它，它就会弹出来供编辑。

图 4-2 显示了带有默认项目视图的项目工具窗口。

图 4-2

项目工具窗口

如果主编辑器窗口需要更多的屏幕空间，可以通过点击工具窗口栏上的按钮隐藏项目工具窗口(如图 4-3 )。

图 4-3

项目工具窗口，隐藏

默认情况下，项目工具窗口使用项目视图显示文件；这个视图向我们展示了项目中的所有文件——甚至是那些与我们的代码不直接相关的文件，例如,。想法文件、 iml 文件等。您可以通过点击项目视图下拉菜单(如图 4-4 所示)然后选择“包”来改变这个视图，只显示与我们的应用程序代码直接相关的文件

图 4-4

切换到包视图

图 4-5 显示了“包”视图上的项目工具窗口。现在我们只能看到代码包中的代码——其他什么也看不到。

图 4-5

项目工具窗口，在包视图中

当您单击下拉菜单来更改项目工具窗口的视角时，您可能已经注意到还有其他选项，如打开文件、测试、划痕和控制台。

项目工具窗口视图的其他选项(简要)解释如下:

• 如果您创建了任何单元测试类，那么当您选择这个视图时，它们就会显示出来。

• 打开的文件–显示主编辑器中所有打开的文件。

• scratch and Consoles–显示你所有的 scratch 文件。

结构工具窗口

项目工具窗口的正下方是结构窗口。正如您可能已经从它的名字中猜到的，它显示了类(和接口)的结构。

结构窗口的内容反映了项目工具窗口中当前选中的类或接口的结构，如图 4-6 所示。

图 4-6

结构工具窗口

结构窗口显示所选类的所有字段(成员变量)、方法、lambdas 和属性。它甚至会告诉你类成员是否被继承。

结构窗口是导航您的类的有用工具，尤其是当您的类变得更加复杂时。

导航栏

导航栏未被充分重视。许多程序员认为这个工具只是一个美化了的面包屑——好吧，它确实是某种面包屑机制，但不仅仅如此。您可以通过导航栏真正导航整个项目，就像您使用项目工具窗口导航一样。

面包屑中的每个项目都是可导航的；如图 4-7 所示，当我们点击“套接字编程”(项目名称)上的面包屑时，它会显示项目上的其他文件和文件夹——就像在项目工具窗口中一样。

图 4-7

导航栏显示项目级别的下拉列表。

图 4-8 显示了显示包装内容的导航栏。

图 4-8

显示包级别下拉列表的导航栏

图 4-9 显示了显示类成员的导航栏，就像在结构窗口中一样。

图 4-9

导航栏显示课程级别的下拉列表

临时文件

这个名字泄露了秘密。草稿文件可让您为项目创建草稿。这是一种写下东西或跟踪事情的便捷方式，但是您不确定是否希望这些代码成为项目的一部分。

您可以使用“Scratches and Consoles”(在项目工具窗口中)上的上下文菜单创建一个 scratch 文件；点击新建 ➤ 暂存文件(如图 4-10 )。

图 4-10

创建新的暂存文件

在随后的弹出窗口中，选择您想要创建的暂存文件类型；您可以从各种类型中进行选择，例如，Java 文件、HTML、JSON 等。(如图 4-11 所示)。

图 4-11

新暂存文件

您可以编译 Java 临时文件(并运行它们),就像您编译并运行实际上是项目一部分的 Java 文件一样；参见图 4-12 。

图 4-12

暂存文件，编译并运行

您可以很容易地更改暂存文件的文件格式；只需右键单击暂存文件，选择“覆盖文件类型”，然后选择新的文件类型。

待办事项

待办事项是对你自己(或团队其他成员)的指示。这是一个提示，提醒你做特定的事情或者在特定的类上实现特定的特性。

你可能认为这没什么大不了的；毕竟所有的编程编辑都可以这么做吧？是也不是。是的，因为所有的编辑器都允许你写待办事项提醒。只需在 TODO 项前面加上注释字符，然后写下 TODO。就像这样:

// TODO Write a thread app, do the accepting and responding of msgs there

后面跟单词 TODO 的单行注释应该可以达到这个目的。这没什么，但 IntelliJ 的亮点在于它如何将你所有的待办事项收集在一个地方。

点击待办事项工具窗口(如图 4-13 所示)查看整个项目的所有待办事项。

图 4-13

整个窗口

“待办事项”窗口显示分散在项目文件中的所有待办事项。此外，如果双击任何 TODO 项，IntelliJ 将在主编辑器中打开包含 TODO 注释的文件。

问题

“问题工具”窗口显示整个项目中的所有问题和警告项。起初，您可能看不到问题工具窗口的价值，因为 IntelliJ 做了一项出色的工作，无论何时您搞砸了一个语法，它都会告诉您(似乎就在您的面前)——您会看到红色的卷线。但是这个窗口真正的亮点是在警告方面。在 IntelliJ 中，警告并不重要。只有当你的鼠标停留在一行代码(IntelliJ 认为它可以改进)上时，你才会意识到它们，然后你会看到一个黄色的灯泡——如图 4-14 所示。

图 4-14

IntelliJ 警告

否则，你甚至不会意识到这些警告。

“问题工具”窗口显示项目中的所有错误和警告。所以，如果你想全部看到，只需点击工具窗口栏中的“问题”按钮(如图 4-15 )。

图 4-15

问题工具窗口

单击问题工具窗口中的任何警告(或问题)项，会在主编辑器窗口中显示相关文件。

末端的

“终端工具”窗口打开时，是一个可以在 IntelliJ 中使用的实际终端。许多程序员使用这个工具，因为在键盘上打字仍然比用鼠标搜索和啄快。如果您非常熟悉 CLI 命令，您会喜欢终端窗口。它在 IDE 的底部弹出(并隐藏)，如图 4-16 所示。

图 4-16

终端窗口

当您打开终端窗口时，IntelliJ 会直接将您带到项目目录。没有必要 CD 到~/idea projects/name your project——仅仅是为了这个行为，我就不再使用我的原生终端工具了。我只使用 IntelliJ 中的终端。

您可能想要使用“终端”窗口的一些原因:

• 如果你是一个命令行忍者，你喜欢做你的 Git 推送，存储，提交，添加等。，但是您不想离开 IDE，那么终端就非常适合您。

• 您可能需要在 Maven 或 Gradle 上运行一些命令。

• 你运行的是 MongoDB (mongod 和 mongo)。您可以在 IDE 中创建多个终端会话，这非常适合这些任务。

主编辑器窗口

主编辑器窗口占据了最大的屏幕空间，这是创建和编辑代码的地方。

您可能不需要使用主编辑器窗口的说明；毕竟很直观。您可以在使用它的过程中了解它的功能，但我还是想指出一些事情。首先，主编辑器允许您折叠代码的各个部分。当你点击房屋形状的五边形时(如图 4-17 所示)，代码的各个部分将会折叠。如果你点击同一个五边形，它会展开。当你审计你的代码时，这是一个很好的工具。

图 4-17

代码折叠

接下来，当你正在编辑一个有 runnable main 方法的类时，编辑器栏上的 Run 按钮就会出现(如图 4-18 所示)。单击此按钮将允许您运行您的类，就像单击工具栏上的运行按钮一样。

图 4-18

编辑器栏上的运行按钮

接下来是编辑窗口右上角的警告图标(如图 4-19 )。IntelliJ 显示项目中发现的所有问题的摘要。单击警告摘要会打开问题工具窗口。

图 4-19

右上角的警告图标

接下来是 GUI 编辑器。你可能会使用 GUI 组件、Android 应用程序(如图 4-20 所示)或 JavaFX 应用程序(如图 4-21 所示)来处理项目。不管是什么情况，IntelliJ 都会保护你。它有所见即所得的能力来完成工作。

图 4-21

JavaFX 场景生成器

图 4-20

Android 项目

关键要点

• IntelliJ 不是一个简单的程序编辑器。这是一个全面的集成开发环境，加载了许多有用的功能。

• 在 IntelliJ 中导航项目文件的方法不止一种。导航项目文件的主要方式是通过项目工具窗口，但也可以通过导航栏来完成。

• IntelliJ 的 TODO 功能简单易用；只需写一行注释，后跟单词 TODO，就可以开始了。当您单击工具窗口栏中的待办事项工具窗口时，可以看到所有待办事项。

• 用 IntelliJ 的集成终端做一些 CLI 杂技；这里不需要 cmd、Terminal、iTerm 或 Terminator。

• 主编辑器窗口具有 GUI 编辑功能；当您使用 Android 项目或 JavaFX 项目时，这将非常方便。

五、代码导航和生成

在本章中，我们将介绍以下内容:

• 如何使用 IntelliJ 中的“到处搜索”功能

• 如何使用键盘快捷键进入任何 IDE 操作

• 如何在没有狩猎和北平的情况下寻找档案

• 如何生成样板代码

你见过谁信誓旦旦地认为 Vim 是最好的编辑器吗？你有吗？你知道他们为什么这么说吗？其中一个原因，我认为，是因为有了 Vim，你不用鼠标来导航。都是键盘。你的手永远不会离开键盘——对一些人来说，这让他们处于一种流畅的状态。

你可以用 IntelliJ 做类似的事情。如果你想尝试双手(几乎)不离开键盘的工作流程，这一章就是为你准备的。

航行

你可能想知道为什么我们专门为代码导航写了一章。“当然，我知道如何浏览我的代码，”你告诉自己。“打开项目工具窗口，向下钻取到包和层次结构，然后双击打开— et voila ！”

如果是一个小项目，或者当编码速度并不重要时，你可以通过搜索和啄文件、类、变量和方法来获得——任何以编码为生的人都不会告诉你速度不重要。这总是很重要——但是当你不再编写“hello world”项目时，发展你的编码习惯将是一件大事。

当你检查你的编码过程(我指的是你自己的编码过程)时，你会发现至少有一半的时间，你并不是真的在敲东西——你实际上是在做更多的导航而不是敲代码。

如果你在狩猎和啄食，你正在失去宝贵的时间。有更快的方法来得到你的代码，这一节就是关于这个的。

到处搜索

你在 IntelliJ 中需要的最重要的键盘快捷键实际上在 IDE 的后台开始屏幕上(如图 5-1 所示)；然而，这也是最容易被忽视的。大多数人不会关注开始屏幕；我们如此渴望打开源文件并开始输入。

图 5-1

IntelliJ 的开始屏幕

开始屏幕提示为我们提供了一些漂亮的键盘快捷键，但是让我们从搜索所有地方快捷键开始。

您可以通过快速连续按下 Shift 键两次来激活到处搜索对话框(图 5-2 显示了到处搜索对话框)。

图 5-2

到处搜索

您可以开始在搜索栏中键入内容，开始看到一些结果。您可以通过名称找到项目中或项目外的任何项。您可以从单个入口点搜索文件、操作、类、符号、设置、UI 元素和 Git 中的任何东西。如果你还记得你的正则表达式，你可以用它们在搜索所有地方对话框中查找项目。

对话框中有几个选项卡(类、文件、符号、动作和全部)。默认情况下，您被放置在 All 选项卡上，但是您可以通过用鼠标选择它们来切换选项卡。

现在您可能已经知道，当您想要搜索类时，使用 Classes 选项卡，当您在解决方案中查找文件时，使用 Files ，当您搜索 IDE 操作时，使用 Actions ，当您查找类名、变量、常量和方法名时，使用符号。

当您在解决方案中查找文件而不是动作时， All 选项卡更有用。当您使用这个搜索工具时，请注意对话框是如何划分的，这样您就可以掌握它的窍门了。

顺便说一下，您一定注意到了“搜索所有地方”对话框中的勾号框，上面写着“包括非项目项”当您检查它时，您可以在 Java 文档中搜索非项目项，如类(如果您下载了它)。搜索非项目项目的最快方法是使用双 Shift 键盘快捷键，然后再次按下双 Shift 将搜索扩展到非项目项目。

查找操作

动作是指 IDE 动作，如打开终端、构建项目、创建文件等。您可以通过执行以下任一操作来执行操作:

• 通过主菜单栏，然后浏览子菜单项，直到找到您需要的动作。

• 使用上下文菜单–如果你知道在哪里点击右键，你可以得到你需要的动作。

• 点击工具栏上的按钮–工具栏上会显示一些最常见的操作，如运行、调试、停止等。

• 使用键盘快捷键——这是最快的，但这也意味着你需要记住这个快捷键。你也许可以对那些你经常使用的动作这样做，但是你不能对所有的动作都这样做。

• 使用 到处搜索 对话框然后准备行动。开始键入操作的名称，然后按 ENTER。这是第二种最快的行动方式。

例如，如果您想要启动一个终端会话(在 IntelliJ 中)，您可以使用选项+ F12 (在 macOS 上)或 Alt + F12 (在 Linux 和 Windows 上)。如果你不记得键盘快捷键，你可以使用到处搜索对话框，然后选择动作。或者，如果你不想让你的手指离开键盘，你也可以使用 Shift + cmd + A 快捷键(对于 macOS)或者 Shift + CTRL + A (对于 Linux 和 Windows)来启动到处搜索对话框并直接进入动作标签。

图 5-3 显示了我们搜索终端动作时的动作对话框。

图 5-3

行动

这个对话框向我们展示了一些关于终端操作的信息。我们可以看到它的键盘快捷键，也可以看到这个动作在主菜单栏上的位置。此时，您只需按下 ENTER 键即可启动该操作。

打开文件

如果您一直使用项目工具窗口打开文件，您会很高兴知道有更快的方法来访问您的文件。

图 5-4 所示的项目很小，但足以演示如何使用项目工具窗口搜索文件。将鼠标放在项目工具窗口下箭头的右边(如图 5-4 ，然后开始输入(如图 5-5 )。

图 5-5

在项目工具窗口中搜索文件

图 5-4

单击项目工具窗口旁边的

但是，只有当文件在项目工具窗口中可见时，此技术才有效。如果不是，例如当 src 文件夹被折叠时，这种搜索方法就会失败(如图 5-6 所示)。嗯，无论如何，你都可以使用到处搜索对话框查找文件。

图 5-6

带有折叠 src 文件夹的项目工具窗口

开放课程

在命名 Java 源文件时，最好用类名来命名文件。这样，当您查看项目工具窗口时，只需查看实际的源文件，就可以知道类文件在哪里。如果你遵循了这个建议，那么对你有好处。如果你没有，IntelliJ 支持你是件好事。在 IntelliJ 中搜索类定义非常容易；只要在 macOS 上按下 cmd + O (大写字母 O，不是零)，在 Windows 和 Linux 上按下 CTRL + N ，然后开始输入。

图 5-7 显示了搜索类别对话框。

图 5-7

搜索课程

转到符号

为了完成我们在到处搜索对话框选项卡上的讨论，让我们看看符号。当你在寻找变量、方法名和常量时，到处搜索对话框的符号选项卡是一个不错的选择。

转到符号的快捷键在 macOS 上是 option + cmd + O (大写字母 O)在 Windows 和 Linux 上是 Shift + CTRL + Alt + N 。

图 5-8 显示了运行中的转到符号对话框。

图 5-8

标志

最近的更改和文件

您可能经常需要的另一个有用的 IDE 快捷方式是如何查看最近更改的文件，以及通常项目中最近的更改。

要查看您最近处理过的文件，请使用 cmd + E 快捷键(macOS)或CTRL+E(Windows 和 Linux)。图 5-9 显示最近的文件对话框。

图 5-9

最近的文件

当你有健忘的时候，这个对话框很有用，你可以试着记起你正在处理的源文件。这是一个伟大的记忆慢跑者。请注意，它不仅会告诉您最近接触过的文件；它还会告诉您最近的一些操作(在对话框的左侧)。

另一个你可以使用的记忆点动器是最近 地点对话框(如图 5-10 )。可以使用 Shift + cmd + E (macOS)或者 Shift + CTRL + E (Windows 和 Linux)来激活。

图 5-10

最近位置

如果你想查看你最近在项目中所做的所有更改的列表，例如，创建一个新文件，使用快捷键 Shift + cmd + C (macOS)或 Shift + Alt + C (Windows 和 Linux)。图 5-11 显示最近变更对话框列表。

图 5-11

最近的变化

该对话框显示了所做的更改(在本例中是创建一个文件)以及更改的时间。列表上的项目是可点击的。它就像指向已更改文件的超链接，因此您只需单击它们就可以快速查看或编辑它们。

开放目标类型

有时候，你会遇到一些你不太熟悉的类型。在这些时候，快速浏览一下文档(或实际的代码实现)会非常有用。IntelliJ 可以让你做到这一点。将光标放在您想要调查的类型上，如图 5-12 所示，我将光标放在雇员类型上。然后用 cmd + B (macOS)或者 CTRL + B (Linux 和 Windows)打开定义了类型的源文件。

图 5-12

程序员源文件

IntelliJ 启动定义了类型的源文件(如图 5-13 所示)。

图 5-13

员工源文件

您不局限于解决方案中的文件；您也可以查看标准 Java 库中的文件。图 5-14 显示我的光标位于螺纹型；按下 cmd + B 快速将我带到线程类的定义(如图 5-15 所示)。

图 5-15

线程类别定义

图 5-14

主程序源文件

cmd + B 快捷方式不仅限于类型——它也适用于方法。当您在方法上使用该快捷方式时，IDE 将向您显示该方法在解决方案中的所有用法(如图 5-16 所示)。

图 5-16

解决方案中方法的用法

窥视定义

查看定义类似于打开目标类型(我们在上一节中讨论过)，但是与打开目标类型不同的是，查看定义不启动或打开文件。相反，它会显示一个弹出对话框，您可以在其中看到类型的定义。

要检查这一点，将光标放在您想要查看的类型上，就像我们在中所做的那样打开目标类型，然后按下按键 option + space (macOS)或 Shift + CTRL + I (Windows 和 Linux)。示例如图 5-17 所示。

图 5-17

窥视雇员类型的定义

显示成员

你把成员变量放在哪里？你是在类开始的时候，在所有方法之前一次性定义它们，还是在接近使用点的时候定义它们？以一个真正的编码惯例的名义发动了一场激烈的战争，但是这已经无关紧要了，因为像 IntelliJ 这样的 ide 可以在一个简洁的窗口中显示所有的类成员。

至少有两种方法可以看到该类的所有成员。第一种是通过使用 cmd + F12 (macOS)或者 CTRL + F12 (Windows 和 Linux)；样品如图 5-18 所示。

图 5-18

显示成员

查看成员的另一种方法是显示结构窗口(图 5-19)；使用 cmd + 7 (macOS)或者 Alt + 7 (Windows 和 Linux)。

图 5-19

结构窗口

使用 cmd + 7 来切换结构窗口的可见性，这样你就可以在不需要的时候把它移开。

查看类层次结构

IntelliJ 的另一个简洁的特性允许您在主编辑器中查看当前所选类的类层次结构。只需使用快捷键 CTRL + H (这是 macOS、Linux 和 Windows 的按键)来显示类层次结构窗口——如图 5-20 所示。

图 5-20

显示类层次结构

这是我想向您展示的关于代码导航的最后一个技巧。下一站，代码生成。

代码生成

IntelliJ 的另一个节省时间的特性是代码生成器；它的名字恰如其分，因为它确实做了你认为它会做的事情——它生成代码。

激活代码生成对话框的快捷键是 cmd + N (macOS)或者 Alt + Insert (Linux 和 Windows)。图 5-21 显示了运行中的代码生成对话框。

图 5-21

代码生成对话框

如您所见，您并不局限于构造函数生成。我将让你来试验其他的选择。

我想展示的下一个例子是如何为 getters 和 setters 生成代码——这是 Java 编程中非常常见的任务。

图 5-21 显示了带有两个成员变量的类程序员， mLastname 和 mFirstname 。显示代码生成对话框，然后选择 Getter 和 Setter ，如图 5-22 所示。

图 5-22

生成 getters 和 setters

IntelliJ 显示所有自动检测的成员变量(如图 5-23 所示)。您可以选择想要为其生成 getters 和 setters 的所有成员，您可以在这里进行多项选择。

图 5-23

选择字段以生成 getters 和 setters

单击确定按钮生成代码。清单 5-1 展示了我们的程序员类，它为 mFirstname 和 mLastname 自动生成了 getters 和 setters。

public class Programmer implements Employee{

  String mLastname;
  String mFirstname;

  public String getmLastname() {
    return mLastname;
  }

  public void setmLastname(String mLastname) {
    this.mLastname = mLastname;
  }

  public String getmFirstname() {
    return mFirstname;
  }

  public void setmFirstname(String mFirstname) {
    this.mFirstname = mFirstname;
  }

  @Override
  public void work() {

  }
}

Listing 5-1Class Programmer with Generated Getters and Setters

这已经很不错了。任何能让我们节省击键次数的东西都是好东西。我猜你可能只对这个例子有一点挑剔；方法命名不正确。你可能更喜欢称为 setLastname() 而不是 **setmLastname()，**不是吗？让我们解决这个问题。

转到 IntelliJ 的偏好设置—使用快捷键 cmd +，macOS 使用(逗号)。对于 Linux 和 Windows 来说是 CTRL + Alt + S ，然后进入代码风格➤ Java ➤代码生成，如图 5-24 所示。

图 5-24

首选项➤代码风格➤ Java ➤代码生成

在字段名前缀中，告诉 IntelliJ 如何给成员变量加前缀。在我的例子中，我用字母 m 作为成员变量的前缀，因此， mLastname 作为姓氏变量。

单击 Apply 或 OK 按钮保存更改，然后再次为 mFirstname 和 mLastname 生成 getters 和 setters。

清单 5-2 显示了重新生成的程序员类。

public class Programmer implements Employee{

  String mLastname;
  String mFirstname;

  public String getLastname() {
    return mLastname;
  }

  public void setLastname(String lastname) {
    mLastname = lastname;
  }

  public String getFirstname() {
    return mFirstname;
  }

  public void setFirstname(String firstname) {
    mFirstname = firstname;
  }

  @Override
  public void work() {

  }
}

Listing 5-2Programmer Class with Autogenerated Getters and Setters

这还差不多！

关键要点

• 所有 IDE 操作都可以通过主菜单栏来执行，但是激活这些操作的最快方式是通过键盘快捷键。

• 在 IntelliJ 中激活一个动作的第二种最快方法是使用 cmd + A (macOS)或 Shift + CTRL + A (Windows 和 Linux)搜索动作。

• 如果你能记住一些快捷键，你将会节省很多时间，但是如果你只能记住一个快捷键，那就让它变成双 Shift 吧。只需连续按下 Shift 键两次，就可以打开“到处搜索”对话框。

六、检查和意图

在本章中，我们将介绍以下内容:

• 代码检查

• 意图

你使用 IntelliJ 已经有一段时间了。我很确定你已经看到了灯泡(红色和黄色)、带有感叹号的黄色三角形和下面带有一条曲线的绿色复选标记——这些是 IntelliJ 用来告诉我们代码有问题的图标。他们被称为检查图标。我们将在本章中讨论它们。

代码检查

IntelliJ IDEA 是智能的(双关语)；它比你更了解你的代码。当你打字时，它在后台努力工作，试图看到你弄糟了代码的哪些部分；在代码被修改的地方，IntelliJ 会给出警告信号——请注意，这一切甚至发生在你编译代码之前。如果 IDE 是哑的，它就不会被称为 IntelliJ。名不虚传。

代码检查是 IDE 的一项功能，它可以扫描、检测和纠正项目中的异常代码，甚至可以在编译之前进行。IDE 可以发现并突出显示各种问题。它可以定位死代码，发现拼写问题(比您希望的更多)，并改进整体代码结构。

IntelliJ 可以发现的问题从良性到严重都有，比如尾部的分号(如图 6-1 所示)。黄色灯泡表示警告；它们是良性的，因为它们不会阻止你编译，但是 IntelliJ 警告你，因为代码不是最佳的。

图 6-1

IntelliJ 标记尾部分号

其他时候，你会看到一个红色的灯泡(如图 6-2 中的灯泡)。

图 6-2

红色灯泡，表示有错误

红色灯泡是错误标志。您需要对有问题的代码进行更改，以免您的项目无法编译。

解决检查问题

最容易处理的检查是那些相当明显的检查，例如，不可及的语句，如图 6-3 所示。

图 6-3

不可达语句

最后一条 println() 语句下面的红色曲线清楚地表明您的代码有问题。假设你按下 option + ENTER (macOS)或者 Alt + ENTER (Windows 和 Linux)，IntelliJ 的快速修复就开始了。IDE 向您展示您可能想要采取的检查操作，以便您可以解决问题，如图 6-4 所示。

图 6-4

检查行动

在我们的例子中，操作很简单；只需删除不可及的语句，如果你选择，问题立即消失——但这是显而易见的；当然，您可以看到 println() 是无法到达的。你不需要为此检查。让我们试试另一个。

看看你能不能认出这个。在图 6-5 的第 6 行，我给打了个电话。 AnotherMethod() 和 IntelliJ 通过用红色波浪线给这个的调用加下划线来升起一面旗帜。你能说出原因吗？

图 6-5

对另一个方法()的非静态调用的检查操作

在我们的例子中很容易发现错误，因为它是一段很短的代码，但是当您的源文件已经有几百行长时，很容易忘记 AnotherMethod() 是静态的；这也是为什么把叫做的原因。 *另一种方法()*进行标记。但是不要担心，让我们看看检查行动提供了什么。再次执行选项+ ENTER (或者如果您在 Linux 或 Windows 上，执行 Alt + ENTER )来显示检查操作。

图 6-6

检验行动选项

检查中有几个建议:

• 使主要的，而不是静态的-这是不可行的。主方法必须是静态的。有时候，检查操作提供的选项没有帮助(也不正确)，这就是其中之一。

• 进入静态主程序。AnotherMethod()via class main program reference——这只是一种花哨的说法，“删除第 6 行中的 this 关键字，并简单地调用 another method()，而不使用自引用。”这将解决我们的问题。

• 清理代码–这将做与第二个(前面的)选项完全相同的事情。它将简单地删除没有自引用的调用 AnotherMethod()。大多数时候，这是正确的选择。所以，让我们选择这个，清单 6-1 显示了结果代码。

public class MainProgram {
  public static void main(String[] args) {
    NumberGenerator numgen = new NumberGenerator();
    this.AnotherMethod();
  }

  static void AnotherMethod() {
    System.out.println("another method");
  }
}

Listing 6-1The resulting code

大多数时候，检查操作非常简单，就像在代码中使用一个类型而没有先停下来导入它一样——为什么要这么麻烦呢？只需要一个 Alt + ENTER 就可以了(见图 6-7 )。

图 6-7

使用检查操作导入类

检验代码

IntelliJ 在我们键入时标记我们的错误；如果您希望在运行过程中得到次优代码的警告，这是非常方便的。IntelliJ 在后台实际检查整个项目的错误和警告。

IDE 会让您在浏览当前行时注意到错误(或警告),但是如果您想知道整个文件的错误/警告，您可以通过单击右侧的检查图标来做到这一点——它是编辑器右上角的小部件，显示当前文件中的问题数量(及其严重性)。如图 6-8 所示。

图 6-8

检查图标

如果点击 inspection widget，IntelliJ 会显示问题工具窗口(如图 6-9 )。

图 6-9

显示问题工具窗口的主编辑器

“问题工具”窗口显示当前文件中所有问题的综合列表。你可以通过简单地点击问题列表上的每一项来逐一查看它们。

当您单击每个项目时，IDE 会将光标移动到发现问题的特定行；然后，您可以使用 option + ENTER (对于 Windows 和 Linux 为 Alt + ENTER)来选择一个修复(如图 6-10 )。

图 6-10

修复无法实现的语句

或者，您可以在问题工具窗口中使用每个问题项的上下文菜单(如图 6-11 所示)。

图 6-11

在问题工具窗口中使用上下文菜单

如果你选择“显示快速修复”，IntelliJ 会在问题工具窗口中显示快速修复的选项(如图 6-12 所示)；这样，您就不必返回到源文件来执行修复。这会节省你的时间。

图 6-12

显示“快速修复”选项

当快速修复有多个选项时，IntelliJ 会向您显示选项，以便您可以滚动并选择合适的选项。在图 6-13 中，IntelliJ 试图提供帮助，并展示了它的建议，以修复它认为是一个打字错误——在我的例子中，我真的打算将它拼写为“firstnumber”IntelliJ 的词典中没有此项；这就是为什么它被标记为打字错误。我打算忽略它。

图 6-13

快速修复选项

导航问题列表中项目的另一种方法是拆分问题工具窗口的窗格。点击工具窗口的分格 图标(如图 6-14 )，可以在工具窗口看到程序源代码。可以使用常用的快速修复(选项+回车或者 Alt +回车)来修复问题。

图 6-14

问题工具窗口的拆分窗格

IntelliJ 给了我们很多处理检查问题的方法。导航检查问题的另一种方法是将鼠标悬停在滚动条的条纹上(如图 6-15 所示)。

图 6-15

滚动条上的条纹

黄色条纹显示警告，红色条纹显示错误。当您将鼠标悬停在条纹上时，警告和错误会显示在弹出对话框中，检查会在标注气球中突出显示(这样您就可以很容易地发现它们)。

IntelliJ 不仅能让您轻松发现检查问题，还能让您轻松解决这些问题。从滚动条中，您还可以访问快速修复(如图 6-16 所示)。

图 6-16

从滚动条快速修复

最后，您可以使用检测小工具的上下箭头键导航检测问题，如图 6-17 所示。

图 6-17

检测小部件的上下箭头键

如果您不喜欢使用鼠标，您可以使用 F2 或 Shift + F2 键跳过检查问题。

检查整个项目

您已经知道如何处理单个源文件中的问题；我们只需点击每个源文件上的检查小部件——任务完成。但是项目通常有多个源文件。如果您的项目有 100 个源文件，这是否意味着您需要单击检查小部件 100 次才能看到整个项目的问题？当然不是。IntelliJ 有办法对整个项目进行检查。

要对整个项目进行检查，进入主菜单栏，然后分析 ➤ 检查代码。或者，使用动作快捷键( Shift + cmd + A 或 Shift + CTRL + A )，然后选择检查代码，如图 6-18 所示。

图 6-18

检查代码操作

无论哪种方式，都将进入指定检查范围对话框(如图 6-19 )。

图 6-19

指定检查范围

选择“整个项目”来运行整个项目的检查。然后 IntelliJ 对整个项目运行检查扫描，并弹出问题工具窗口来显示检查问题的完整列表。如果你有一个大项目，这可能需要一些时间。

图 6-20 显示了问题工具窗口，其中列出了检查发现的所有问题。

图 6-20

整个项目的检查清单

问题是按类别组织的，而不是按位置(源文件)组织的。正如您在我们的小示例项目中看到的，它按类别列出了问题，如数据流、声明冗余、可能的错误和校对。

现在，您可以浏览每个问题，并使用各种解决方法来解决它们。

在可能的情况下，IntelliJ 以一组布局良好的按钮提供解决方案，如图 6-21 所示。如果你想使用这个或者你更愿意使用可靠的选项+ ENTER 快捷键，这完全取决于你。

图 6-21

IntelliJ 提供了可能的解决方案。

意向行动

灯泡并不总是意味着你的代码有问题。IntelliJ 还使用黄色灯泡向您展示可以改进代码的地方。

让我们举一个简单的例子来说明如何使用意图动作。考虑图 6-22 中所示的以下代码。

图 6-22

打印时的意图

使用我们的快速修复快捷方式(option + ENTER 或 Alt + ENTER)，IntelliJ 为我们提供了几种改进代码的方法。正如你在图 6-23 中看到的，我们可以选择用 StringBuilder.append()或 MessageFormat.format()替换字符串表达式，或者用格式化的 printf()替换 println 选择哪一个完全取决于你的喜好。我偏向于 printf()选项，但这只是我自己。

图 6-23

我们 println 示例的意图操作

不是所有的意图行为都是有用的(或正确的，取决于你的上下文)。事实上，其中一些是彻头彻尾的讨厌，就像图 6-24 中显示的这个。

图 6-24

分割申报意向行动

它建议我们这样做。

Random random;
random = new Random();

而不是这个；

Random random = new Random();

这个建议在这种情况下没有意义。内联声明和定义更有意义。

幸运的是，您可以为任何意图定制行为。所以，让我们现在解决那个讨厌的分裂声明意图。

使用快速修复快捷键(option + ENTER 或 Alt + ENTER)，然后点击右箭头(如图 6-25 )。

图 6-25

编辑意向设置

从这里，您可以禁用“拆分声明”意图或编辑意图设置；任何一种选择都会使意图行动沉默。IntelliJ 不会再用它来烦你了。但是，出于某种原因，您希望恢复意图操作，您可以在 IDE 的首选项或设置中这样做。这是在编辑 ➤ 的意图下的。使用到处搜索键盘快捷键(双 Shift)，然后输入“意图”(如图 6-26 )。

图 6-26

弹出意图对话框的快捷键

在随后的对话框中，在意向对话框中查找“拆分申报项”，如图 6-27 所示。您可以使用意向对话框中的搜索文本字段来快速缩小选项范围。

图 6-27

意向对话框中的拆分申报条目

如您所见，Split 声明被禁用了——因为我们不久前取消了它。当您在主编辑器或问题工具窗口中抑制一个意图时，该意图动作在首选项(或设置，如果您在 Linux/Windows 上)中被禁用。

使用偏好 ➤ 意图来定制 IntelliJ 在建议代码改进时的行为。如果你对某些意图感到恼火，就压制它们。

关键要点

• 注意编辑器的灯泡和曲线。当您看到它们时，意味着 IDE 发现了一些次优代码。

• 无论你在哪里看到灯泡或曲线，只要按下 option + ENTER(对于 Windows/Linux，按 Alt + ENTER)就可以快速修复。快速解决的捷径是你的朋友。

• IntelliJ 并不总是正确的。有些建议对你来说可能没有意义。你可以在偏好设置(或设置) ➤ 编辑 ➤ 意图中关闭它们。

七、重构

在本章中，我们将介绍以下内容:

• 重构概述

• 常见的(也是重要的)重构操作

• IntelliJ 如何重构

“技术债务”、“干燥原则”、“干净的代码”——在代码评审中听过这些术语吗？开发会议，也许？我打赌你有。这些可能是现在的流行语，但它们不是空的。这些术语被创造出来(并变得流行)是有充分理由的。

构建一个新应用最令人兴奋的部分(至少对我来说)是最初的编码阶段。这总是一个爆炸，但随着项目进入维护阶段——您最初的技术决策开始困扰您——它变得越来越不有趣。事实上，它开始感觉像一件苦差事。维护阶段不令人兴奋的一个常见原因是，当您在大量代码的基础上编写新功能时，添加新功能要困难得多。最微小的错误可以破坏很多东西，当你修复一件东西时，你会破坏两件东西。这就是为什么你真的应该养成对你的代码进行单元测试的习惯——但是我们在这里超越了自己；这不是本章的内容；我们很快就会处理测试的问题。无论如何，关键是，如果代码是干净的，易读的，并且有点条理，那么维护代码的工作就不那么可怕了。

重构基本上是重写和改进源代码——使它们易于阅读——而不改变其可观察到的行为。有组织的、整洁的、易读的代码比无组织的、混乱的、复杂的代码更好——这使得代码更容易维护和扩展。在这一章中，我们将讨论重构以及 IntelliJ 是如何让重构变得容易的。

重构

没有人会着手编写复杂、混乱和无组织的代码。代码复杂性不是任何程序员开始项目时的目标。代码开始很简单，如果你能相信的话；然后，随着我们添加更多的代码，复杂性越来越多——一个接一个。如果你不能控制复杂性，你很可能会以“意大利面条式的代码”而告终，这些代码真的很难解开。那么，我们如何管理这种情况呢？很多方法，其中之一是通过重构。

当你重构时，你只是以一种更有组织性的方式移动代码片段；但是它不会改变代码的行为。让我们考虑清单 7-1 中的代码；该方法只需调用一个例程来打印一些横幅数据，计算未清余额，打印发票，最后打印未清余额。

void printSomething(Invoice invoice) {

  printBanner();
  double outstanding = calculateOutstanding();

  // print details
  System.out.println(customer);
  System.out.println(outstanding);

}

Listing 7-1printSomething() Method

在某些时候，我们可能需要打印客户发票和代码库中其他地方的未清余额。创建一个打印详细信息的方法，这样我们就不必编写前面示例代码的最后两个 println()语句，难道不是很有意义吗？清单 7-2 向我们展示了如何操作。

void printSomething(Invoice invoice) {
  printBanner();
  double outstanding = calculateOutstanding();

  printDetails(invoice, outstanding);
}

private void printDetails(Invoice invoice, double outstanding) {
  System.out.println(invoice);
  System.out.println(outstanding);
}

Listing 7-2Refactored printSomething() Method

看到多简单了吧？我们只是移动了一些代码。现在，每当我们需要打印客户的详细信息时，我们只需调用 printDetails()。

我们刚刚做的重构叫做“提取方法”重构。这些重构行为有一个完整的目录——你可以在 https://refactoring.com/catalog/ 找到。目录中列出了 60 多个重构操作。我怀疑你会需要全部 60 个。作为实验，你可以去 GitHub 搜索每个重构动作的名字。例如，搜索“重命名变量”(如图 7-1 )。

图 7-1

GitHub 上的“重命名变量”搜索

GitHub 上有超过 100 万次的“重命名变量”操作。当然，并不是所有的重构操作都记录在提交消息中，但是这是对现实世界重构活动的一个不错的近似。

用这些简陋的研究方法，下面是我在 GitHub 上的发现。在撰写本文时,“重命名变量”操作以超过 100 万次提交高居榜首。

以下列表显示了我的部分发现:

• 重命名变量–1M+

• 重命名方法–178k

• 重命名类别–143k

• 移动方法–109k

• 移动等级–97K

• 提取方法–95K

• 内嵌方法–81K

• 提取等级–23K

• 提取接口–18K

• 提取超类–2K

• 引入断言–2K

• 上拉方法–1K

• 引入参数对象- 674

• 下推方法–168

何时重构

你怎么知道什么时候应该重构？

肯特·贝克是“极限编程”的创始人，也是“敏捷宣言”的 17 个原始签名人之一，他推广了“代码气味”这个术语。在马丁·福勒的《重构:改进现有代码的设计》一书中，这个术语的使用增加了。

当一个代码需要重构时，它被称为有“味道”，不是字面上的意思——它只是意味着代码读起来没有吸引力或不愉快。以下是一些代码气味的例子:

• 大类–在现有的类中添加新的方法或行为通常更容易；这就是一个阶层成长的原因。随着时间的推移，太多的功能被塞进了这个类。您可能需要将它的一些功能重新定位到一个新类中。

• 长方法(Long method)——当你把很多功能塞进一个方法时，就会出现这种情况。节约切换和简单地将行为保持在现有方法内的冲动太强烈了，因此该方法不断发展。这里有一个小提示:当你觉得你必须写一个注释来解释下一行代码时，这通常是一个信号，你应该把下一行代码放到它自己的方法中。

• 大量原始类型被使用–当原始成员变量的数量随着时间增长时，可能是时候回顾一下你对问题域的抽象了。

• 参数过多–这通常与前面提到的“长方法”同时发生。参数太多，可能是因为这个方法做得太多了。它实现了太多的算法。或者是时候再次回顾你的抽象了。与其传递许多参数，不如传递一个对象。

有很多代码的味道；在这一章中，我们不可能把它们都讲清楚，因为我们应该讨论如何在 IntelliJ 中进行重构。

Note

随着您获得更多的经验，您手动检测“代码气味”的能力将会增强——在此之前，您可能希望使用一些工具来帮助您找到不良代码。SonarLink 是一个不错的起点。它是 IntelliJ 的一个插件。你可以从 www.sonarlink.org 网站获取 SonarLink。

IntelliJ 中的重构

现在我们已经对重构有了相当多的了解，是时候看看它的实际应用了。

要开始重构，您需要选择想要重构的代码片段(目标)。它可以是一个符号，也可以只是一段代码。您可以在编辑器或结构工具窗口中选择符号—我通常只在编辑器中选择代码；这样感觉更自然。通常在符号上有插入符号就足够了。IntelliJ 自动扩展选择，如图 7-2 所示，我在姓氏符号的某处放置了插入符号。

图 7-2

IntelliJ 自动扩展选择

如您所见，IntelliJ 已经突出显示了姓氏符号的用法，即使我还没有要求它做任何事情。IDE 会预测您的行动。

一旦选择了目标，现在就可以选择重构操作了。您可以通过几种方式做到这一点:

• 通过主菜单栏，选择重构，然后选择重构操作。

• 使用上下文菜单。右键单击该符号，然后选择重构，再选择重构操作。

• 使用键盘快捷键 CTRL + T (macOS)或者CTRL+Shift+Alt+T(Linux/Windows)，然后选择重构动作。

继续我们的例子，让我们将变量的姓氏重命名为的名字。一旦我在姓氏符号上有了插入符号，我将使用键盘显示“重构这个”对话框(如图 7-3 所示)。顺便说一下，当你显示“重构这个”对话框时，显示了各种重构操作的键盘快捷键:Shift + F6 用于重命名，F6 用于移动成员，F5 用于复制类，等等。您可以选择记住这些单独的快捷方式(这是访问它们的最快方式)，或者如果您有点懒(像我一样)，我可以只使用右键单击或 CTRL+T——反正它会带我到“重构这个”对话框。

图 7-3

“重构此”对话框

让我们选择“重命名”；毕竟，我们想要重命名一个变量。选择“重命名”后，IntelliJ 会高亮显示正在编辑的符号，并立即相应地更改符号的出现，如图 7-4 所示。

图 7-4

重构变量

完成编辑后，按 ENTER 键。

如果您注意到了，在我们的示例代码中，变量 lastName 和 firstName 有 getters 和 setters。IntelliJ 还建议我们是否要改变 getters 和 setters(如图 7-5 所示)。

图 7-5

重命名 Getters 和 Setters

对话框的底部面板显示了代码更改的预览(图 7-5 )。单击确定完成操作。

清单 7-3 显示了重构后的 Person 类。

class Person {
  private String lname;
  private String firstName;

  public String getLname() {
    return lname;
  }

  public void setLname(String lname) {
    this.lname = lname;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }
}

Listing 7-3Refactored Person class

你可能会认为这只是一个美化了的“搜索和替换”操作，任何一个像样的编辑器都可以做，但它不仅仅是这样。当您需要在更大范围内重命名一些东西时，比如一个类、包或者一个广泛使用的公共方法，重构操作的价值就变得显而易见了。在重命名操作期间，IntelliJ 执行以下操作:

• 它检查当前作用域中的名称冲突。

• 它验证新名称在语法上是合法的。

• 如果你重命名一个类或包，它会创建新的文件和目录，并删除旧的。

• 它会更新版本控制系统中由于名称更改而从源代码树中添加或删除的任何文件。

• 它会更正对您重命名的符号的所有直接代码引用，以确保它们使用新名称。

• 它甚至更新 JavaDoc 注释。

• 它更新任何受影响的导入语句。

IntelliJ 中的更多重构

我相信您已经掌握了它的窍门，我可能会让您自己去尝试如何做其他的重构操作——但是让我们再做几个，好吗？

提取方法

当你“闻到”代码越来越长时，你可能想要使用“提取方法”重构操作。您将提取方法，因为您想要抽象操作并将一些行为封装在一个单独的方法中；这样，就可以从代码的其他部分重用它。

图 7-6 显示了 printSomething()方法——你之前已经看过这段代码了。我在本章前面用这个作为例子。您已经知道这将如何被重构。

图 7-6

printSomething()方法

我们希望提取第 13 行和第 14 行，并将它们放在一个单独的方法中。为此，我将突出显示第 13 行和第 14 行(如图 7-7 所示)，然后弹出“Refactor This”对话框。

图 7-7

提取方法

选择“提取方法”操作；一旦我选择了动作，IntelliJ 就会显示一个变化的实时预览。提取的方法——恰当地命名为“extracted()”——在后台显示并点亮(如图 7-8 所示)。

图 7-8

提取的()方法显示在预览中

此时，IntelliJ 还没有完成重构操作。如您所见，选择“extracted()”方法签名是因为 IntelliJ 正在等我键入新方法的名称。因此，我将输入新提取的方法的名称。我将名称改为“printDetails()”，如图 7-9 所示。

图 7-9

print 细节()方法

像以前一样，IntelliJ 会在您键入时显示更改的实时预览。

当您对方法名的更改感到满意时，按 ENTER 键完成重构操作。重构之后，您可能需要做一些清理工作——不多，但有时可能需要做一些小的修改。

移动成员

您可以将成员变量或方法从一个类移动到另一个类，但是请注意，您只能移动静态成员——IntelliJ 不允许您移动实例成员。

要移动一个类成员，将插入符号定位在你想要移动的符号上，然后弹出“重构”对话框，如图 7-10 所示。

图 7-10

移动成员

选择“移动成员”在接下来的屏幕中(图 7-11 ，您可以选择目的地。您需要告诉 IntelliJ 您想要将成员移动到哪里。

图 7-11

移动静态成员

单击省略号按钮(在“完全限定名称”字段的右侧)。您可以在随后的对话框中选择目标类别(如图 7-12 所示)。

图 7-12

选择目的地类别

点击 OK 以完成选择，之后您将返回到上一个对话框，但是这一次，destination 字段包含目标类的全限定名称(如图 7-13 所示)。

图 7-13

移动静态成员(填满)

点击重构完成动作。

更改签名

如果您需要更改方法的签名，在手动更改之前请三思。IntelliJ 真的可以在处理变更的后果方面为您节省大量时间。如果您手动执行，您可能无法获得该方法的所有引用 IDE 不会错过任何一个节拍。

让我们更改我们前面的示例“printDetails()”方法的签名。将插入符号放在方法名上，弹出“重构”对话框，如图 7-14 所示。

图 7-14

更改 printDetails()的签名

选择“更改签名”操作。弹出更改签名对话框(如图 7-15 )。

图 7-15

更改签名对话框

在此对话框中，您可以更改成员的可见性、返回类型、名称，甚至参数的顺序。

图 7-16 显示了我所做的一些更改的更改签名对话框。

图 7-16

更改签名(包含我的更改)

如您所见，我将方法的名称更改为“printSomeDetails()”，将返回类型更改为 int，还将其可见性更改为“protected”。

对话框的底部面板显示了方法签名的预览(包含您的更改)。此时，如果您已经对您的更改感到满意，您可以单击“重构”来完成操作。或者，您可以单击“预览”按钮，在提交操作之前查看重构预览。重构预览如图 7-17 所示。

图 7-17

重构预览

您可以在预览中检查建议的重构的细节。当您对更改满意时，单击“Do Refactor”按钮完成操作。否则，单击“取消”按钮中止操作。

关键要点

• 重构不仅为其他人，也为我们自己保持我们代码库的健全。三个月后，你将不会记得在写那段漂亮的代码时的想法。

• IntelliJ 的重构工具比“查找和替换”要好得多。在手动操作之前，尽可能尝试使用重构工具。

• 如果你只能记住一个重构的快捷方式，那就让它成为 CTRL + T (对于 macOS 用户)或者 CTRL + Shift + Alt + T (对于 PC 用户)。

八、实时模板

在本章中，我们将介绍以下内容:

• 实时模板

• 使用实时模板

• 创建您自己的实时模板

出于各种原因，Java 与开发人员之间有一种又爱又恨的关系。如果我是一个打赌的人，我会说 Java 被讨厌的原因之一是因为冗长。要完成任何事情，你必须忍受它的锅炉板代码。您有几个选择:

• 转到 Python——你需要转行，可能会离开现在的工作(剧烈的)。

• 切换到科特林——有可能。许多 Java 商店现在都在采用 Kotlin。你也许根本不需要跳槽，但你真的想跳槽吗？Java 是你的初恋吧？

• 咬紧牙关，奋力前进，输入密码–哎哟！你好，腕管综合症。

• 使用 IntelliJ 的实时模板–耶！你的手指(和键盘)会为此感谢你的。这就是本章的全部内容。

那么什么是活模板呢？

你以前使用过文本扩展器吗——你输入一些字母模式，比如 datetoday 它会扩展到当前日期或者 tgif ，它会扩展到“谢天谢地今天是星期五”？实时模板与此非常相似。这是 IntelliJ 的一个特性，你可以输入一个助记符(或类似的东西)，它可以扩展为一个表达式或结构。

你想看看实际情况吗？下次定义一个类并且需要编写 main()方法时，键入单词“main”(如图 8-1 所示)，然后按 ENTER 或 TAB 展开模板。

图 8-1

使用“main”live 模板插入公共静态 void main

当模板展开时，您将拥有一个空的 main()方法(如图 8-2 所示)。IDE 还会将插入符号放在方法的第一个空行上。想得很周到。这样，您就可以开始在方法中键入第一行，而无需重新定位光标。

图 8-2

扩展了“主”实时模板

main 方法还有另一个模板。尝试输入“psvm”，如图 8-3 所示。

图 8-3

使用“psvm”模板

按 ENTER 或 TAB 也将“psvm”扩展为public static void main()方法。现在，在到达 main 的第一个空行后，尝试输入“so”，如图 8-4 所示。

图 8-4

IntelliJ 展示了一些以“so”开头的实时模板

我们想写 *System.out.println()，所以选择“sout”选择“sout”时按 ENTER 或 TAB 键，将模板展开到system . out . println()；*如图 8-5 所示。

图 8-5

“sout”扩展为 system . out . println()；

到目前为止，您已经输入了八个键(“main”和“So”，包括选项卡)，它扩展到了 58 个字符。这就意味着你再也不用输入 50 个字符了——非常简洁，对吧？想象一下，如果你真的可以使用 Java 的所有 38 个实时模板。击键的节省是巨大的。

参数化模板

我们再举一个例子；在主方法中，输入“for”，如图 8-6 所示。

图 8-6

使用“fori”模板

可以看到，IntelliJ 为我们呈现了三个选项:(1)，扩展为 for 循环结构；(2) fori ，扩展成更全面的 for 循环结构；以及(3) foreach ，这是您在处理集合时可能会用到的。让我们用“fori”；选择“fori”时，按 TAB 或 ENTER 键。IntelliJ 将其扩展为近乎完整的 for 循环结构(如图 8-7 )。

**

图 8-7

“fori”扩展了

它有一个起始计数器值、极限表达式和计数器增量表达式。随着模板的扩展，脱字符号落在 " i "上，以防您想要更改计数器变量(我通常不去管它)。如果您再次按 TAB，插入符号会停留在您应该键入限制表达式的值的地方(如图 8-8 所示)。

图 8-8

按 TAB 键会将您带到限制表达式

请注意，每次按 TAB 都会将插入符号定位到一个占位符上，您应该在这里输入值以完成语句。

再按一次 TAB，它应该将脱字符号放在“for”语句的第一个空行上(如图 8-9 所示)。

图 8-9

最后一次按 TAB 键

你应该已经找到窍门了。使用实时模板非常容易。你应该随时随地使用它们。他们节省时间。

显示所有可用模板

实时模板知道它们的上下文。你不能在任何地方使用它们。例如，尝试在方法之外键入“fori”(如图 8-10 所示)。

图 8-10

在方法外部键入“fori”

看看 IntelliJ 是如何将其标记为错误的？“fori”模板在方法之外没有意义。模板知道上下文。他们知道他们应该在哪里。

IntelliJ 总是尽力提供帮助。当您在编辑器中键入一串字符时，很难预测您要做什么。在图 8-11 中，当我键入“p”时，它试图建议一堆选项，很难区分哪些是实时模板，哪些不是。根据经验，如果它(1)没有括号或花括号，并且(2)没有有用的描述，那么它就不是一个活模板。

图 8-11

显示以“p”开头的可能模板

你能在图 8-11 中找出哪些是实时模板吗？

如果你猜对了 prsf、psf 和 psfi，那你就猜对了。

如果你想显示所有实时模板的列表(插入符号所在)，只需使用 cmd + J (macOS)或 CTRL + J (Windows 和 Linux)并滚动即可。图 8-12 显示了所有实时模板的下拉列表。

图 8-12

实时模板列表

环绕实时模板

考虑清单 8-1 中的代码；这是一组典型的 Java 类，演示了如何实现单例——它不是一个合适的单例，所以不要在生产中使用它，但它足以演示如何控制对象实例数量的基本流程。

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

    Tree objTree = null;

    objTree = TreeFactory.getTree();

  }
}

class TreeFactory {
  private static Tree tree;
  private TreeFactory() {
    tree = new Tree();
  }
  public static Tree getTree() throws Exception {
    return tree;
  }
}

class Tree { }

Listing 8-1TreeFactory, Tree, and MainProgram Classes

假设我们想用 try-catch 包围 getTree()调用；您可以使用实时模板来节省一些击键。

要用任何控制流结构包围一个语句，将插入符号放在您想要包围的行上，然后使用键盘快捷键 cmd + option + T (macOS)或 CTRL + Alt + T (Linux 和 Windows)。

弹出包围对话框，选择要使用的控制结构，如图 8-13 所示。

图 8-13

使用“包围”模板

选择 try-catch，然后按 ENTER 键。

图 8-14 显示了活动模板完成的动作。

图 8-14

扩展的试玩直播模板

如您所见，try-catch 模板用适当的 catch 表达式甚至 printStackTrace()语句预先填充了控制结构。

让我们进一步举个例子。现在，将插入符号放在 try-catch 结构的外部。我们将检查对 getTree()的调用是否返回 null。图 8-15 向我们展示了如何使用实时模板来完成这项工作。

图 8-15

使用 if null (ifn)模板

键入“if”并等待实时模板显示选项。

选择“ifn”并按回车键。

图 8-16 显示实时模板知道哪些变量在范围内。

图 8-16

显示哪些变量在范围内的实时模板

当然，我们想要测试的是 objTree 变量，所以选择它。清单 8-2 显示了我们完成的主程序。

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

    Tree objTree = null;

    try {
      objTree = TreeFactory.getTree();
    } catch (Exception e) {
      e.printStackTrace();
    }

    if (objTree == null) {

    }
  }
}

Listing 8-2MainProgram

一旦你掌握了其中的诀窍，你会想知道没有这些你是如何编码的。它们真的会节省你无数的打字时间。

创建您自己的模板

您可以在 IDE 的首选项或设置中多了解一些实时模板。要得到它，在 macOS 上使用 cmd +，在 Windows/Linux 上使用(逗号)或CTRL+Alt+S；然后进入编辑器 ➤ 直播模板。

您会看到模板是按语言分组的(如图 8-17 所示)。

图 8-17

首选项对话框中的实时模板

单击“Java 语言”展开选择；这显示了所有 38 个 Java 实时模板(如图 8-18 所示)。

图 8-18

Java Live 模板

当您单击每个项目时，IntelliJ 会显示每个实时模板的详细信息。您可以看到模板文本和几个影响模板行为的其他选项，如图 8-19 所示。

图 8-19

模板文本

为了深入挖掘实时模板，我们为什么不创建一个自己的模板。我们可以创建一个实时模板，并将其添加到现有的模板组中，但我不想弄乱现有的一组实时模板。因此，让我们创建一个新的模板组。

点击实时模板对话框上的加号(如图 8-20 所示)并点击“模板组”

图 8-20

添加模板组

在随后的屏幕中，输入模板组的名称；我将称之为“我的模板”，如图 8-21 所示。

图 8-21

创建新组

选中“mytemplates”组时，再次单击加号；这次，点击“实时模板”，如图 8-22 所示。

图 8-22

新建实时模板

在接下来的屏幕中，您可以填写模板详细信息，如图 8-23 所示。

图 8-23

新模板详细信息

• 缩写–这将是实时模板的快捷键。这不能与任何现有的实时模板相同。此外，花时间想清楚这一点；它也需要容易记忆。至于我们的例子，我将使用 publicmethod。

• 描述–这是您将在实时模板右侧看到的描述，如下拉列表所示。

• 模板文本–这是模板展开时的正文。模板文本中的变量(被美元符号包围的那些)是程序员在模板扩展时必须填充的变量。在我们的例子中，我使用了四个变量——您可以使用更多(或更少)。模板文本中的所有变量都是任意的，这意味着我只是编造了它们，除了 $END$ 变量；那是一个预定义的模板变量，对 IntelliJ 有特殊的意义。$END$变量指示代码完成时插入符号或光标的结束位置。您不能再使用 TAB 键导航到下一站。

我想再次参考图 8-23 。注意到左下方写着“没有适用的上下文”吗？这意味着我们必须告诉 IntelliJ 我们的新模板可以从哪个上下文中调用——我们是否可以在方法之外、方法之内调用它，等等。

要为我们的新模板定义上下文，请单击“定义”链接，如图 8-24 所示。然后选择“声明”

图 8-24

模板上下文

当我们选择“声明”时，意味着我们可以在任何需要声明的地方使用我们的模板。

现在，对其进行测试(参见图 8-25 )。

图 8-25

我们正在使用的新模板

选择“publicmethod”，然后按 ENTER 键。图 8-26 显示了扩展的模板——它工作了！

图 8-26

扩展的 publicmethod 模板

共享模板

如果你用的是其他 JetBrains 的 IDE (WebStorm，Rider，PyCharm 等。)，将您的 IntelliJ 模板导出到那些其他 ide——或者其他也使用 IntelliJ 的人。

您可以通过导出 live 模板来共享它们；为此，您需要

图 8-27

导出设置

1. 进入主菜单栏，然后文件 ➤ 管理 IDE 设置 ➤ 导出设置。

2. 在“导出设置”对话框(如图 8-27 所示)中，确保选择了 Live Templates 框，并指定保存导出设置的档案的路径和名称。

3. 单击确定完成导出操作。

要导入模板，请执行以下操作:

1. 在主菜单栏上，进入文件 ➤ 管理 IDE 设置 ➤ 导入设置。

2. 使用导出的模板配置指定归档文件的路径。

3. 在导入设置对话框中，选择实时模板复选框，然后点击确定按钮完成导入操作。

4. 重新启动 IntelliJ(或另一个 JetBrains IDE)。你应该在 IDE 设置的编辑器 ➤ 实时模板页面上看到导入的实时模板。

关键要点

• Java 是一种相当冗长的语言。如果不使用文本扩展工具，可能会严重伤害手指。谢天谢地，IntelliJ 有实时模板。如果你想知道你节省了多少击键次数，只要去 IntelliJ 的主菜单栏，然后去帮助➤生产力指南。它会显示您的使用统计数据。

• IntelliJ 有 38 个模板(仅针对 Java 学好它们是值得的。你的手指(和键盘)会为此感谢你的。

• 你不局限于预定义的模板；您可以添加自己的模板。如你所见，这很容易做到。**