2019-11-26 17:20:38

docs/22.md

@@ -12,7 +12,7 @@
 
 ![Requirements for java maven install](img/6513ceb11c96ae19c932f03be1c2aed6.jpg)
 
-单击此处的[并下载最新版本。 您可以选择二进制版本或完整版本（也可以包含源代码和文档）。 我建议下载二进制文件，因为无论如何您都可以在线找到所有源代码和文档。](https://maven.apache.org/download.cgi)
+单击此处的[并下载最新版本](https://maven.apache.org/download.cgi)。 您可以选择二进制版本或完整版本（也可以包含源代码和文档）。 我建议下载二进制文件，因为无论如何您都可以在线找到所有源代码和文档。
 
 ![How to install Maven on Windows](img/d287162d5681dc8136ccb49aba719f90.jpg)
 
@@ -26,18 +26,28 @@
 
 ![Folder path maven java example install](img/467dbd32f1bf73cf7630c031c201c25a.jpg)
 
-现在我们必须设置 M2_HOME。 在能够运行 Maven 之前，我们需要在环境变量中进行设置并将“ bin”添加到 PATH。
+现在我们必须设置`M2_HOME`。 在能够运行 Maven 之前，我们需要在环境变量中进行设置并将`bin`添加到`PATH`。
 
-**正在添加 M2_HOME**
+**添加`M2_HOME`**
 
 1.  右键单击此 PC 上的某个位置
     1.  选择属性
-    2.  在右侧，选择高级系统设置![Environmental variables java install maven example](img/16631ad8da78b6d1729c990a9bf2d478.jpg)
-    3.  之后，单击“环境变量…” ![java maven install exampleClcik on environmental variables](img/83c6e71c9641cd2d4abd92fb377ad193.jpg)
-    4.  在“系统变量”下，选择“新建…![System variables java maven example install](img/cca4227e39ca0a157a7518e78d106890.jpg)”
-    5.  输入框打开时，键入 M2_HOME 作为变量名和 Maven 的路径![System variables java maven example install](img/2fec3bbca142a4a622f0e68332ea4247.jpg)
-    6.  在系统变量下，选择“路径”，然后单击“编辑”。![Java maven install](img/08ca45b46f39b6deb9697b34cb2de797.jpg)
-    7.  添加路径“ C：\ Maven \ apache-maven-3.6.1 \ bin”
+    2.  在右侧，选择高级系统设置
+        
+        ![Environmental variables java install maven example](img/16631ad8da78b6d1729c990a9bf2d478.jpg)
+    3.  之后，单击“环境变量…” 
+    
+        ![java maven install exampleClcik on environmental variables](img/83c6e71c9641cd2d4abd92fb377ad193.jpg)
+    4.  在“系统变量”下，选择“新建…”
+    
+        ![System variables java maven example install](img/cca4227e39ca0a157a7518e78d106890.jpg)
+    5.  输入框打开时，键入`M2_HOME`作为变量名和 Maven 的路径
+    
+        ![System variables java maven example install](img/2fec3bbca142a4a622f0e68332ea4247.jpg)
+    6.  在系统变量下，选择“路径”，然后单击“编辑”。
+    
+        ![Java maven install](img/08ca45b46f39b6deb9697b34cb2de797.jpg)
+    7.  添加路径`C:\Maven\apache-maven-3.6.1\bin`
 
 **验证安装是否成功**
 
@@ -65,26 +75,26 @@ OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"
 
 *   [Oracle JDK 11](https://www.javahelps.com/2017/09/install-oracle-jdk-9-on-linux.html)
 
-1.  下载 [apache-maven-3.6.1-bin.tar.gz](https://maven.apache.org/download.cgi) 二进制文件（如果您不希望包含源代码和文档）。
+1.  下载[`apache-maven-3.6.1-bin.tar.gz`](https://maven.apache.org/download.cgi)二进制文件（如果您不希望包含源代码和文档）。
 2.  在终端中输入`cd /opt`
-3.  将 apache-maven 存档解压缩到 opt 目录中：`sudo tar -xvzf ~/Downloads/apache-maven-3.6.0-bin.tar.gz`
-4.  添加为环境变量：``M2_HOME="/opt/apache-maven-3.6.0`"``` 并将 bin 目录附加到 Path 变量：`/opt/apache-maven-3.6.0/bin`
-5.  更新 mvn 命令：
+3.  将 apache-maven 存档解压缩到`opt`目录中：`sudo tar -xvzf ~/Downloads/apache-maven-3.6.0-bin.tar.gz`
+4.  添加为环境变量：`M2_HOME="/opt/apache-maven-3.6.0"`并将`bin`目录附加到`Path`变量：`/opt/apache-maven-3.6.0/bin`
+5.  更新`mvn`命令：
     1.  `sudo update-alternatives --install "/usr/bin/mvn" "mvn" "/opt/apache-maven-3.6.0/bin/mvn" 0`
     2.  ``sudo update-alternatives --set mvn /opt/apache-maven-3.6.0/bin/mvn``
-6.  将 bash 完成添加到 mvn：`sudo wget https://raw.github.com/dimaj/maven-bash-completion/master/bash_completion.bash --output-document /etc/bash_completion.d/mvn`。 这将使您可以通过单击 Tab 两次来完成 Maven 命令。
-7.  键入 mvn –version 以验证其是否有效
+6.  将 bash 完成添加到`mvn`：`sudo wget https://raw.github.com/dimaj/maven-bash-completion/master/bash_completion.bash --output-document /etc/bash_completion.d/mvn`。 这将使您可以通过单击 Tab 两次来完成 Maven 命令。
+7.  键入`mvn –version`以验证其是否有效
 
 ## MAC
 
 1.  打开终端并转到提取文件的目录并以超级用户身份登录
-2.  通过键入**删除 tar.gz 存档。rm Downloads / apache-maven * bin.tar.gz**
-3.  修复权限： **chown -R root：wheel 下载/ apache-maven ***
-4.  切换 Maven 内容： **mv 下载/ apache-maven * / opt / apache-maven**
-5.  存档管理会话：**退出**
+2.  通过键入删除`tar.gz`存档。`rm Downloads/apache-maven*bin.tar.gz`
+3.  修复权限：`chown -R root:wheel Downloads/apache-maven*`
+4.  切换 Maven 内容：`mv Downloads/apache-maven* /opt/apache-maven`
+5.  存档管理会话：`exit`
 6.  将 Maven 二进制文件添加到路径，然后追加：
-    1.  **nano $ HOME / .profile**
-    2.  **export PATH = $ PATH：/ opt / apache-maven / bin**
-7.  **Ctrl + x** 保存并退出 nano
-8.  要加载新设置，请执行 **bash**
-9.  要测试安装是否成功，请键入 **mvn -version**
\ No newline at end of file
+    1.  `nano $HOME/.profile`
+    2.  `export PATH=$PATH:/opt/apache-maven/bin`
+7.  `Ctrl + x`保存并退出`nano`
+8.  要加载新设置，请执行 bash
+9.  要测试安装是否成功，请键入`mvn -version`
\ No newline at end of file

docs/23.md

@@ -8,16 +8,16 @@
 
 在继续学习本教程的内容之前，假定您已经安装了 Maven。 如果您不这样做，请按照本教程 的逐步指南进行操作。
 
-要在 Maven 中指定配置文件，您需要使用 **pom.xml** 文件中的 activeProfiles 或配置文件元素。 pom.xml 在**运行时**时被修改。
+要在 Maven 中指定配置文件，您需要使用`pom.xml`文件中的`activeProfiles`或配置文件元素。`pom.xml`在**运行时**时被修改。
 
 有 3 种构建配置文件类型。
 
 1.  每个项目
-    1.  在 pom.xml 文件中定义
+    1.  在`pom.xml`文件中定义
 2.  每位使用者
-    1.  在 Maven 设置 xml 文件（% USER_HOME% /。m2 / settings.xml）中定义
+    1.  在 Maven 设置 xml 文件（`%USER_HOME%/.m2/settings.xml`）中定义
 3.  全球
-    1.  在 Maven 全局设置 xml 文件（% M2_HOME% / conf / settings.xml）中定义
+    1.  在 Maven 全局设置 xml 文件（`%M2_HOME%/conf/settings.xml`）中定义
 
 如何提示 Maven Build 配置文件？ 有两种方法：
 
@@ -29,9 +29,9 @@
 
 ### 显式激活配置文件
 
-创建您的 Maven 项目（如果尚未创建），然后创建第一个简单的配置文件 test1。
+创建您的 Maven 项目（如果尚未创建），然后创建第一个简单的配置文件`test1`。
 
-这是我添加的 pom.xml 代码
+这是我添加的`pom.xml`代码
 
 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -72,17 +72,17 @@
 
 ```
 
-配置文件-&gt;配置文件-&gt; **id** ； 那是我们指定如何引用配置文件的地方。 不要错过该行，这很重要，因为它不仅是必填项，而且如果您省略它，则将无法访问您的个人资料。
+`<profiles>` -&gt; `<profile>` -&gt; `id`；那是我们指定如何引用配置文件的地方。 不要错过该行，这很重要，因为它不仅是必填项，而且如果您省略它，则将无法访问您的个人资料。
 
-我们在 pom.xml 文件中所做的是，我们已覆盖了编译器插件设置。 我们已将编译器的版本设置为 1.5，并将 fork 设置为 true。
+我们在`pom.xml`文件中所做的是，我们已覆盖了编译器插件设置。 我们已将编译器的版本设置为 1.5，并将`fork`设置为`true`。
 
-请记住，在这种情况下，我们仅创建了 1 个配置文件，但是我们也可以在&lt;配置文件&gt;标签内添加更多&lt;配置文件&gt;标签。
+请记住，在这种情况下，我们仅创建了 1 个配置文件，但是我们也可以在`<profiles>`标签内添加更多`<profile>`标签。
 
-覆盖所需的插件之后，该运行我们的配置文件了。 您可以通过在命令行中输入 **mvn test -P &lt; id &gt;** 来运行它
+覆盖所需的插件之后，该运行我们的配置文件了。 您可以通过在命令行中输入`mvn test -P <id>`来运行它
 
-在我们的例子中，我们需要编写 **mvn test -Ptest1** ，因为我们创建的个人资料给我们提供了值为“ test1”的 ID。
+在我们的例子中，我们需要编写`mvn test -Ptest1`，因为我们创建的个人资料给我们提供了值为`test1`的 ID。
 
-现在转到项目的文件夹位置，然后输入 **mvn test -P &lt;您的配置文件 ID &gt;。** 如果我在上面的示例中运行此命令，则得到的结果是：
+现在转到项目的文件夹位置，然后输入`mvn test -P <您的配置文件 ID>`。如果我在上面的示例中运行此命令，则得到的结果是：
 
 ```java
 [INFO] Scanning for projects...
@@ -128,7 +128,7 @@ Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
 
 ### 使用 Maven 设置激活配置文件
 
-导航到您的用户主目录，然后打开 **.m2** 文件夹。 如果那里没有 settings.xml 文件，请创建一个。
+导航到您的用户主目录，然后打开`.m2`文件夹。 如果那里没有`settings.xml`文件，请创建一个。
 
 然后将我们创建的配置文件添加为活动配置文件。 使用以下代码：
 
@@ -151,11 +151,11 @@ Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
 </settings>
 ```
 
-现在，导航到包含 **pom.xml** 文件的文件夹并执行 **mvn 测试。**
+现在，导航到包含`pom.xml`文件的文件夹并执行`mvn test`。`
 
 ### 使用环境变量激活配置文件
 
-删除 settings.xml 文件并在**名称**标签中添加 **env** 值。 像这样：
+删除`settings.xml`文件并在`name`标签中添加`env`值。 像这样：
 
 ```java
 <profile>
@@ -169,8 +169,8 @@ Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
 </profile>
 ```
 
-您必须创建一个称为 env 的环境变量，并将其值设置为“ test1”。
+您必须创建一个称为`env`的环境变量，并将其值设置为`test1`。
 
-导航到包含 pom.xml 的文件夹，然后键入 **mvn test。**
+导航到包含`pom.xml`的文件夹，然后键入`mvn test`。
 
 如果您希望将自定义库包含到 maven 本地存储库中，可以遵循[本文](https://javatutorial.net/how-to-include-custom-library-into-maven-local-repository)。
\ No newline at end of file

docs/24.md

@@ -21,7 +21,8 @@ mvn install:install-file
 -Dpackaging=<packaging>
 ```
 
-Using the template above, simply populate the fields that correspond to your library. Dfile => the path to the file groupdId, artifactId and version are entirely up to you. Dpackaging => the package type, a.k.a. jar, war, etc.
+使用上面的模板，只需填充与您的库相对应的字段。`Dfile =>`文件路径，`groupdId`，`artifactId`和版本完全取决于您。`Dpackaging =>`包类型，例如 JAR 和 WAR 等。
+
 
 ## 第 2 步
 
@@ -36,4 +37,4 @@ Using the template above, simply populate the fields that correspond to your lib
 </dependency>
 ```
 
-在将其添加为依赖项之后，只需使用 **mvn 软件包**来构建项目并添加繁荣，就可以向 Maven 项目中添加自定义库了。
\ No newline at end of file
+在将其添加为依赖项之后，只需使用`mvn package`来构建项目并添加繁荣，就可以向 Maven 项目中添加自定义库了。
\ No newline at end of file

docs/25.md

@@ -18,9 +18,9 @@ Java 有多种可用的测试框架，但是，在本教程中，我们将重点
 
 ## 设置 JUnit
 
-如果您使用的是通用的 [IDE](https://javatutorial.net/choose-your-java-ide-eclipse-netbeans-and-intellij-idea) ，例如 Eclipse，IntelliJ 或 NetBeans，则默认情况下已安装 JUnit。 如果您不使用 IDE，而仅使用 Maven 或 Gradle，则需要将其安装在 pom.xml 或内部版本中。 gradle 文件。
+如果您使用的是通用的 [IDE](https://javatutorial.net/choose-your-java-ide-eclipse-netbeans-and-intellij-idea) ，例如 Eclipse，IntelliJ 或 NetBeans，则默认情况下已安装 JUnit。 如果您不使用 IDE，而仅使用 Maven 或 Gradle，则需要在`pom.xml`或 gradle 文件中将其安装。
 
-如果在 Eclipse 中创建 [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) 项目，然后选择 archetype-quickstart 并导航到 pom.xml 文件，您将看到 Eclipse 自动将 JUnit 添加为依赖项。
+如果在 Eclipse 中创建 [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) 项目，然后选择`archetype-quickstart`并导航到`pom.xml`文件，您将看到 Eclipse 自动将 JUnit 添加为依赖项。
 
 ![JUnit added by Eclipse by default](img/9554941a0f7e57ce7c3d0acfe56063a7.jpg)
 
@@ -32,10 +32,9 @@ Java 有多种可用的测试框架，但是，在本教程中，我们将重点
 
 ![JUnit 4 pom.xml](img/711748446c9e8c60c4c233eded1607af.jpg)
 
-但是，在将其添加为依赖项并且无法识别 org.junit 之后，请执行以下操作：
+但是，在将其添加为依赖项并且无法识别`org.junit`之后，请执行以下操作：
 
-在 Eclipse 中：
-属性-> Java 构建路径->库->添加库-> JUnit
+在 Eclipse 中：属性 -> Java 构建路径 -> 库 -> 添加库 -> JUnit
 
 ![Adding JUnit as a library in Eclipse](img/d3ee8b59046389040167996d0f23a1aa.jpg)
 
@@ -51,15 +50,15 @@ Java 有多种可用的测试框架，但是，在本教程中，我们将重点
 
 ![Test class example](img/0f3a5e694b2885b1685d342f2c3e7ac1.jpg)
 
-而已！ 我们只在 exmipeMethod 方法上运行了 2 个测试。
+而已！ 我们只在`exmipeMethod`方法上运行了 2 个测试。
 
 ### 分解
 
-注意，方法 testConversion（）带有 JUnit @Test 注释。 这样做是为了使单元测试运行程序知道此方法代表单元测试，应该执行。 如果没有此注释，则不会将其表示为 Test 类，而且不会由测试运行者运行。
+注意，方法`testConversion()`带有 JUnit `@Test`注释。 这样做是为了使单元测试运行程序知道此方法代表单元测试，应该执行。 如果没有此注释，则不会将其表示为`Test`类，而且不会由测试运行者运行。
 
-**assertEquals（）**是执行实际测试的方法。 您真正关心的是第 13 和 17 行。assertEquals（）方法有两个参数，第一个参数是预期结果，第二个参数是实际结果。 您可以看到这是多么有用并且非常容易实现。
+`assertEquals()`是执行实际测试的方法。 您真正关心的是第 13 和 17 行。`assertEquals()`方法有两个参数，第一个参数是预期结果，第二个参数是实际结果。 您可以看到这是多么有用并且非常容易实现。
 
-重要的是要指出，如果预期结果与实际结果匹配，则什么也不会发生，但是，如果预期结果与实际结果不匹配，则 assertEquals 会引发异常，并且测试方法将停止进一步执行。
+重要的是要指出，如果预期结果与实际结果匹配，则什么也不会发生，但是，如果预期结果与实际结果不匹配，则`assertEquals`会引发异常，并且测试方法将停止进一步执行。
 
 您可以使用任意数量的测试方法。
 
@@ -67,14 +66,14 @@ Java 有多种可用的测试框架，但是，在本教程中，我们将重点
 
 ### 在 Eclipse 中运行
 
-在 Eclipse 中，在 Package Explorer 上，找到 JUnit 测试，右键单击，然后选择 Run As-> JUnit Test。
+在 Eclipse 中，在 Package Explorer 上，找到 JUnit 测试，右键单击，然后选择“Run As -> JUnit Test”。
 
 ![Run As Junit Eclipse](img/722c5b4aefe2dde61ae4bbb9371e9ec3.jpg)
 
 ### 在 Maven 中运行
 
-如果要使用 Maven 运行 JUnit，则可以使用 **mvn 测试**运行整个测试套件，也可以运行特定的测试： **mvn -Dtest = TestName 测试。**
+如果要使用 Maven 运行 JUnit，则可以使用`mvn test`运行整个测试套件，也可以运行特定的测试：`mvn -Dtest=TestName test`。
 
 ### 在 Gradle 中运行
 
-在 gradle 中，对于整个测试套件： **gradlew test** ，对于特定测试： **gradlew -Dtest.single = testName 测试。**
\ No newline at end of file
+在 gradle 中，对于整个测试套件：`gradlew test`，对于特定测试：`gradlew -Dtest.single=testName test`。
\ No newline at end of file

docs/26.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javatutorial.net/how-to-run-junit-test-with-maven](https://javatutorial.net/how-to-run-junit-test-with-maven)
 
-本教程将介绍如何使用 [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) 的 Surefire 插件运行单元测试。 如果您不熟悉单元测试，则可以按照本教程的[快速了解。](https://javatutorial.net/how-to-use-junit-for-unit-testing)
+本教程将介绍如何使用 [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) 的 Surefire 插件运行单元测试。 如果您不熟悉单元测试，则可以按照本教程[快速了解](https://javatutorial.net/how-to-use-junit-for-unit-testing)。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
@@ -25,9 +25,9 @@
 </dependencies>
 ```
 
-junit-jupiter-engine 依赖项包含运行我们的单元测试的 JUnit Jupiter 测试引擎的实现。
+`junit-jupiter-engine`依赖项包含运行我们的单元测试的 JUnit Jupiter 测试引擎的实现。
 
-junit-jupiter-api 依赖项提供了 API，使我们能够编写使用 JUnit 5 的测试和扩展。
+`junit-jupiter-api`依赖项提供了 API，使我们能够编写使用 JUnit 5 的测试和扩展。
 
 因此，让我们创建一个非常简单的 Java 文件：
 
@@ -61,7 +61,7 @@ public class TestExample1 {
 }
 ```
 
-**最后，我们可以使用 mvn clean build 运行程序，并且应该看到 Superfire 插件正在运行我们的单元测试**
+**最后，我们可以使用`mvn clean build`运行程序，并且应该看到 Superfire 插件正在运行我们的单元测试**
 
 ```java
 [INFO]

docs/27.md

@@ -17,29 +17,30 @@ Maven 的多模块到底是什么？
 我们为什么要使用多模块？
 减少重复。 如果我们有一个包含多个模块的项目并对其进行更改，则不必分别构建所有模块。 取而代之的是，我们可以运行一个 Maven 命令来为我们执行此操作。
 
-什么是父母？
+什么是父级？
 
 maven 项目中的父项是 pom 打包类型，它使该项目充当聚合器，这意味着它将不再产生其他工件。
 
 什么是模块？
 
-将模块视为**子项目**，可以有效地继承父项目（聚合器）的属性。 同样，所有模块都可以使用单个命令构建，从而帮助我们节省了大量时间。 不同的孩子可以有不同的包装类型，这太棒了！ 一个子项目可能是 jar 项目，可以打包到战争项目中，依此类推。
+将模块视为**子项目**，可以有效地继承父项目（聚合器）的属性。 同样，所有模块都可以使用单个命令构建，从而帮助我们节省了大量时间。 不同的孩子可以有不同的包装类型，这太棒了！ 一个子项目可能是 JAR 项目，可以打包到 WAR 项目中，依此类推。
 
 让我们开始构建我们的应用程序！
 
-要在 **Eclipse** 中的项目中创建 pom.xml 文件和整个 Maven，请执行以下步骤：
+要在 **Eclipse** 中的项目中创建`pom.xml`文件和整个 Maven，请执行以下步骤：
 
-*   点击新建->其他
+*   点击“新建 -> 其他”
 *   ![maven java submodules](img/425ef0401d30e0dbbd46f87e360ec1e1.jpg)
-*   之后，选择 Maven Project
+*   之后，选择“Maven Project”
 *   ![maven project](img/afa3e988dd7bbfb1b2ee1faeb10e3398.jpg)
-*   点击下一步
+*   点击“下一步”
 *   ![maven project](img/466f27c0385aaa11faa247439fccb96d.jpg)选择快速入门，如下所示：
-*   为其提供一个组 ID 和工件 ID：![maven project](img/62ebe485ca59fd2b5cc21befea48515e.jpg)
-*   单击完成。
-    *   好的，太好了！ 现在，我们建立了 Maven 项目。
+*   为其提供一个组 ID 和工件 ID：
+*   ![maven project](img/62ebe485ca59fd2b5cc21befea48515e.jpg)
+*   单击“完成”。
+*   好的，太好了！ 现在，我们建立了 Maven 项目。
 
-要使用终端创建 pom.xml 文件，请键入以下内容：
+要使用终端创建`pom.xml`文件，请键入以下内容：
 
 ```java
 mvn archetype:generate -DgroupId=com.submoduledemo                        
@@ -48,7 +49,7 @@ mvn archetype:generate -DgroupId=com.submoduledemo
 -DinteractiveMode=false
 ```
 
-现在，将 pom.xml 的文件打包类型更改为“ pom”。 这将在父级中进行。
+现在，将`pom.xml`的文件打包类型更改为`pom`。 这将在父级中进行。
 
 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  <modelVersion>4.0.0</modelVersion>  
@@ -72,7 +73,7 @@ packaging>pom</packaging>
 </project>
 ```
 
-现在该添加一些子模块（子项目）了。 转到父母的目录并运行以下命令：
+现在该添加一些子模块（子项目）了。 转到父级的目录并运行以下命令：
 
 ```java
 mvn archetype:generate -DgroupId= submoduledemo -DartifactId=example1
@@ -82,39 +83,39 @@ mvn archetype:generate -DgroupId= submoduledemo -DartifactId=example3
 
 这些命令中的每一个执行后，您应该看到类似以下的内容：
 
-![maven project java how to](img/1b77c0e81b58a0e818eca59b09508f00.jpg) ![maven project](img/e374e494deab3ae75f2c30ed4be833e4.jpg)
+![maven project java how to](img/1b77c0e81b58a0e818eca59b09508f00.jpg) 
 
-![maven project](img/92ec21ba3f4ca0169c078f9a527eda4c.jpg) Maven 之所以知道这些是子模块或子项目而不是父项目，是因为我们在父文件夹中创建了这最后 3 个子目录，因此请注意。
+![maven project](img/e374e494deab3ae75f2c30ed4be833e4.jpg)
 
-自动运行这三个命令（生成三个子项目）后， [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) 将生成它们并通过添加以下内容为我们修改 pom.xml 文件：
+![maven project](img/92ec21ba3f4ca0169c078f9a527eda4c.jpg) 
 
-&lt;模块&gt;
+Maven 之所以知道这些是子模块或子项目而不是父项目，是因为我们在父文件夹中创建了这最后 3 个子目录，因此请注意。
 
-&lt;模块&gt; example1 &lt; / module &gt;
+自动运行这三个命令（生成三个子项目）后， [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) 将生成它们并通过添加以下内容为我们修改`pom.xml`文件：
 
-&lt;模块&gt; example2 &lt; / module &gt;
-
-&lt;模块&gt; example3 &lt; / module &gt;
-
-&lt; /模块&gt;
-
-现在，关于构建子模块的最酷的事情是，当我们在父项目目录中运行 **mvn package** 命令时，Maven 将测试作为子级创建的所有三个模块，并以此结果进行构建。 如果一个子模块依赖于另一个子模块，例如 example1 依赖于 example2，则 Maven 将在构建 example1 之前构建 example2。
-
-构建整个项目之前的最后一件事，如果我们想在子模块之间共享配置，则应在其 pom.xml 文件中声明父对象，如下所示：
-
-&lt;父级&gt;
-
-&lt; groupId &gt; submoduledemo &lt; / groupId &gt;
+```
+<modules>
+<module>example1</module>
+<module>example2</module>
+<module>example3</module>
+</modules>
+```
 
-&lt; artifactId &gt; submoduledemo &lt; / artifactId &gt;
+现在，关于构建子模块的最酷的事情是，当我们在父项目目录中运行`mvn package`命令时，Maven 将测试作为子级创建的所有三个模块，并以此结果进行构建。 如果一个子模块依赖于另一个子模块，例如`example1`依赖于`example2`，则 Maven 将在构建`example1`之前构建`example2`。
 
-&lt;版本&gt; 1.0-快照&lt; /版本&gt;
+构建整个项目之前的最后一件事，如果我们想在子模块之间共享配置，则应在其`pom.xml`文件中声明父对象，如下所示：
 
-&lt; /父母&gt;
+```
+<parent>
+<groupId>submoduledemo</groupId>
+<artifactId>submoduledemo</artifactId>
+<version>1.0-SNAPSHOT</version>
+</parent>
+```
 
 最后，建立项目
 
-在 Eclipse 中，右键单击项目 Run As- &gt; Maven 构建，如下所示：
+在 Eclipse 中，右键单击“项目 Run As -&gt; Maven 构建”，如下所示：
 
 ![maven project java how to](img/de2b570773b34602bb0de338683d562d.jpg)
 
@@ -123,8 +124,9 @@ mvn archetype:generate -DgroupId= submoduledemo -DartifactId=example3
 ![maven project java how to package](img/ff0c34ce3dcefbac0a8d5bee8bd948f9.jpg)
 
 您应该看到类似以下内容：
+
 ![maven project java how to package build success](img/85dce99bb4542bb3a01bdbf1a883b9e9.jpg)
 
-该构建为我们所有的子模块生成了三个.jar 文件。
+该构建为我们所有的子模块生成了三个`.jar`文件。
 
-要在命令行中执行相同的操作，只需键入 mvn 软件包。
\ No newline at end of file
+要在命令行中执行相同的操作，只需键入`mvn package`。
\ No newline at end of file

docs/28.md

@@ -2,25 +2,33 @@
 
 > 原文： [https://javatutorial.net/how-to-create-java-jar-file-with-maven](https://javatutorial.net/how-to-create-java-jar-file-with-maven)
 
-创建可执行文件 jar 时，通常我们不需要其他依赖项。 我们需要做的就是创建一个 [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) Java 项目，并在 main 方法旁边至少有 1 个类。
+创建可执行文件 jar 时，通常我们不需要其他依赖项。 我们需要做的就是创建一个 [Maven](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac) Java 项目，并在`main`方法旁边至少有 1 个类。
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-请注意，我们假定您已在计算机上安装了 Maven。 如果您不这样做，请按照本教程的[获得快速的分步指南。](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac)
+请注意，我们假定您已在计算机上安装了 Maven。 如果您不这样做，请按照本教程的[分步指南](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac)。
 
 让我们从在 Eclipse 中创建 Maven 项目开始。
 
-步骤 1 –打开 Eclipse 并创建一个新的 Maven 项目（文件->新建->其他-> Maven 项目）![How to generate WAR file using Maven java example](img/e015b5975e479d17af96f6c852f62685.jpg)
+步骤 1 – 打开 Eclipse 并创建一个新的 Maven 项目（文件 -> 新建 -> 其他 -> Maven 项目）
 
-步骤 2 –创建 Maven 项目后，在新窗口中单击“下一步”，如下所示：![How to generate WAR file using Maven java example](img/d45a478cce51758e82f390a444eaa532.jpg)
+![How to generate WAR file using Maven java example](img/e015b5975e479d17af96f6c852f62685.jpg)
 
-步骤 3 –选择 maven-archetype-quickstart，然后单击 Next，如下所示：![java jar file install exaple](img/e401f3624440f7a0f6475077f34df1f8.jpg)
+步骤 2 – 创建 Maven 项目后，在新窗口中单击“下一步”，如下所示：
 
-第 4 步–提供组和工件 ID，然后点击完成：![java jar file eclipse install](img/80a08c9dfff5de59b4cbbf8b487c6c28.jpg)
+![How to generate WAR file using Maven java example](img/d45a478cce51758e82f390a444eaa532.jpg)
+
+步骤 3 – 选择`maven-archetype-quickstart`，然后单击“Next”，如下所示：
+
+![java jar file install exaple](img/e401f3624440f7a0f6475077f34df1f8.jpg)
+
+步骤 4 – 提供组和工件 ID，然后点击“完成”：
+
+![java jar file eclipse install](img/80a08c9dfff5de59b4cbbf8b487c6c28.jpg)
 
 现在，我们的 Maven 项目已在 Eclipse 中创建。
 
-打开 **pom.xml** 时，它应如下所示：
+打开`pom.xml`时，它应如下所示：
 
 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -53,26 +61,32 @@
 
 ![java jar file create maven eclipse project](img/8c43eec79394ff64cbe1bb29ff05c5af.jpg)
 
-xml 文件中突出显示的行指定将要创建的文件为 **jar** 。 您也可以删除它，因为默认情况下，包装为 **jar。**
+xml 文件中突出显示的行指定将要创建的文件为 **jar** 。 您也可以删除它，因为默认情况下，包为 **jar**。
+
+到目前为止，我们已经在 Eclipse 中创建了 Maven 项目，并且还指定了将要创建的文件，其类型为 **jar**。
 
-到目前为止，我们已经在 Eclipse 中创建了 Maven 项目，并且还指定了将要创建的文件，其类型为 **jar** 。 大。
+步骤 5 – 让我们添加一个具有`main`方法的类。 重要提示：我们需要将其添加到`src/main/`中：
 
-步骤 5 –让我们添加一个具有 main 方法的类。 重要提示：我们需要将其添加到 src / main /中：![java jar file create maven eclipse project](img/99fcfbb90a9cd896fced1317e48f936f.jpg)
+![java jar file create maven eclipse project](img/99fcfbb90a9cd896fced1317e48f936f.jpg)
 
-在 main 方法中添加一条打印语句。 该 wlil 用于本教程。
+在`main`方法中添加一条打印语句。将会用于本教程。
+
+步骤 7 – 要最终创建 jar 文件，请右键单击“Project -&gt; Run As -&gt; Maven build -&gt; input package”：
 
-步骤 7 –要最终创建 jar 文件，请右键单击 Project- &gt; Run As- &gt; Maven build- &gt;输入“ package”：
 ![maven install jar create file java](img/37c29c9c1b74aa85c0463af2d7147a7a.jpg)
 
 之后，只需输入包：
+
 ![maven install jar create file java](img/5e42c6335eb33defe783c1feda68864b.jpg)
 
 点击运行，您应该看到类似以下内容的内容：
+
 ![maven install jar create file java](img/60935cbaa901da9a376f3bd754e4ecce.jpg)
 
-蓝色突出显示的文本显示了我的 jar 文件的存储位置。 通常，它存储在目标文件夹中。 让我们从此处复制 path 文件夹并将其粘贴，然后查看 jar 文件是否在那里。
+蓝色突出显示的文本显示了我的 jar 文件的存储位置。 通常，它存储在目标文件夹中。 让我们从此处复制`path`文件夹并将其粘贴，然后查看 jar 文件是否在那里。
 
 那里是：
+
 ![java jar file example](img/d6b6689f8ae55aec667c498629ff833d.jpg)
 
-另外，如果您使用终端，要获取 jar 文件，则需要键入 **mvn 程序包**，这将导致相同的结果。
\ No newline at end of file
+另外，如果您使用终端，要获取 jar 文件，则需要键入`mvn package`，这将导致相同的结果。
\ No newline at end of file

docs/29.md

@@ -6,19 +6,25 @@
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-如果您尚未安装 JDK，请点击此处的[。](https://javatutorial.net/install-java-8-jdk-on-ubuntu)
+如果您尚未安装 JDK，[请点击此处](https://javatutorial.net/install-java-8-jdk-on-ubuntu)。
 
-如果您尚未安装 Maven，请点击此处的[。](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac)
+如果您尚未安装 Maven，[请点击此处](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac)。
 
 ## 使用 Eclipse 生成 WAR 文件
 
-步骤 1 –打开 Eclipse 并创建一个新的 Maven 项目（文件->新建->其他-> Maven 项目）![How to generate WAR file using Maven java example](img/e015b5975e479d17af96f6c852f62685.jpg)
+步骤 1 – 打开 Eclipse 并创建一个新的 Maven 项目（文件 -> 新建 -> 其他 -> Maven 项目）
 
-步骤 2 –创建 Maven 项目后，在新窗口中单击“下一步”，如下所示：![How to generate WAR file using Maven java example](img/d45a478cce51758e82f390a444eaa532.jpg)
+![How to generate WAR file using Maven java example](img/e015b5975e479d17af96f6c852f62685.jpg)
 
-步骤 3 –选择 maven-archetype-webapp 并单击 Next，如下所示：![How to generate WAR file using Maven java example](img/1d50c47b3c02a31d78c682bc4c33eab6.jpg)
+步骤 2 – 创建 Maven 项目后，在新窗口中单击“下一步”，如下所示：
 
-步骤 4 –输入详细信息，例如我的，然后单击完成
+![How to generate WAR file using Maven java example](img/d45a478cce51758e82f390a444eaa532.jpg)
+
+步骤 3 – 选择`maven-archetype-webapp`并单击“Next”，如下所示：
+
+![How to generate WAR file using Maven java example](img/1d50c47b3c02a31d78c682bc4c33eab6.jpg)
+
+步骤 4 – 输入详细信息，例如我的，然后“单击完成”
 
 ![How to generate WAR file using Maven java example](img/d3405c528e542ef87734e7f6ead65988.jpg)
 
@@ -26,7 +32,7 @@
 
 ![How to generate WAR file using Maven java example](img/e2dd3cee1e9ed427a02a960868755faf.jpg)
 
-并且 pom.xml 应该看起来像这样：
+并且`pom.xml`应该看起来像这样：
 
 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -53,7 +59,7 @@
 
 ```
 
-步骤 6 –将 pom.xml 替换为以下代码：
+步骤 6 – 将`pom.xml`替换为以下代码：
 
 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -108,17 +114,25 @@
 
 这就是我们有效地将其转换为 WAR 的地方。
 
-步骤 7 –右键点击 Project- &gt; Run As- &gt; Maven build…：![java maven install](img/286a29eb65c5c30381f15a2053adb3da.jpg)
+步骤 7 – 右键点击“Project- &gt; Run As -&gt; Maven build…”
+
+![java maven install](img/286a29eb65c5c30381f15a2053adb3da.jpg)
+
+步骤 8 – 在“目标”部分中键入`clean install`，然后单击“运行”，如下所示：
 
-步骤 8 –在“目标”部分中键入**全新安装**，然后单击运行，如下所示：![maven clean install java](img/861088aaf532e2ae1cb56f2957e4892c.jpg)
+![maven clean install java](img/861088aaf532e2ae1cb56f2957e4892c.jpg)
+
+步骤 9 – 您应该看到`BUILD SUCCESS`，像这样：
+
+![Java maven clean install build success](img/619532c4a014cc880c1d07b561715edc.jpg)
+
+恭喜！ 您有您的`.war`文件。
 
-步骤 9 –您应该看到 BUILD SUCCESS，像这样：![Java maven clean install build success](img/619532c4a014cc880c1d07b561715edc.jpg)
-恭喜！ 您有您的.war 文件。
 ![java war file maven install](img/a78656f303a23f8d7f3f305bcbb6d817.jpg)
 
 ## 使用 CMD 生成 WAR 文件
 
-步骤 1 –通过在我们安装了 Java 的地方添加编译器来修改 pom.xml 文件。
+步骤 1 – 通过在我们安装了 Java 的地方添加编译器来修改`pom.xml`文件。
 
 **pom.xml**
 
@@ -160,12 +174,13 @@
 </project>
 ```
 
-**注意：**，&lt;可执行文件&gt;是重要的部分。 您的 Java 版本可能有所不同，请确保牢记这一点并放置正确的文件夹路径。
+**注意**：`<executable>`是重要的部分。 您的 Java 版本可能有所不同，请确保牢记这一点并放置正确的文件夹路径。
+
+步骤 2 – 在终端中导航到项目的文件夹路径，例如：
 
-第 2 步–在终端中导航到项目的文件夹路径，例如：
 ![maven war file install cmd](img/8f85c2389fcd7a6003c8149afd59721f.jpg)
 
-步骤 3-运行 **mvn clean install** ，它将负责创建 war 文件：
+步骤 3 - 运行`mvn clean install`，它将负责创建 WAR 文件：
 
 ![java maven clean install command cmd eclipse](img/b1806dbee2e98bfcad3f1c06de909dd8.jpg)
 
@@ -173,6 +188,6 @@
 
 ![Java maven install war file cmd eclipse clean install build](img/ccbb472243ff045ace7419d27d5ee877.jpg)
 
-而已！ 我们已经成功使用 Eclipse 和 Terminal 生成了战争文件。
+而已！ 我们已经成功使用 Eclipse 和 Terminal 生成了 WAR 文件。
 
-如果您有兴趣生成 JAR 文件，我已经有关于该主题的文章。 您可以通过单击此处的[来遵循它。](https://javatutorial.net/how-to-create-java-jar-file-with-maven)
\ No newline at end of file
+如果您有兴趣生成 JAR 文件，我已经有关于该主题的文章。 您可以通过[单击此处](https://javatutorial.net/how-to-create-java-jar-file-with-maven)来遵循它。
\ No newline at end of file

docs/30.md

@@ -12,13 +12,13 @@ Java 虚拟机问题在求职面试中非常受欢迎。 采访者喜欢提出
 
 ## 什么是 Java 虚拟机
 
-Java 被设计为可在各种平台上运行，其概念为“一次编写，随处运行”。 这是什么意思？ 例如，与像 C++这样的编程语言不同，在 C++中，代码是针对特定平台进行编译并在其上本地运行的，而 Java 源代码则首先被编译为字节码- .class 文件。 编译后，类文件将由虚拟机（VM）解释。 看下图
+Java 被设计为可在各种平台上运行，其概念为“一次编写，随处运行”。 这是什么意思？ 例如，与像 C++ 这样的编程语言不同，在 C++ 中，代码是针对特定平台进行编译并在其上本地运行的，而 Java 源代码则首先被编译为字节码`.class`文件。 编译后，类文件将由虚拟机（VM）解释。 看下图
 
 ![Run Java bytecode on different platforms - the "write once, run anywhere" concept](img/d6063e9fd37d275ba1f59efb6ad449ae.jpg)
 
 在不同平台上运行 Java 字节码–“一次编写，随处运行”的概念
 
-首先，我们将 Java 源代码（.java 文件）编译为字节码（.class 文件）。 字节码是 Java 和机器语言之间的中间语言。 您可以在任何 JVM 实现上执行相同的字节码，而无需调整一个或另一个 OS 或平台的代码。
+首先，我们将 Java 源代码（`.java`文件）编译为字节码（`.class`文件）。 字节码是 Java 和机器语言之间的中间语言。 您可以在任何 JVM 实现上执行相同的字节码，而无需调整一个或另一个 OS 或平台的代码。
 
 ## Java 虚拟机架构
 
@@ -36,17 +36,17 @@ Java 虚拟机架构图
 
 ### 类加载器子系统
 
-我们已经在单独的教程中介绍了类加载器。 您可能需要查看 [Java 类加载器，以了解更多](https://javatutorial.net/java-class-loaders-explained)详细信息。
+我们已经在单独的教程中介绍了类加载器。 您可能需要查看 [Java 类加载器](https://javatutorial.net/java-class-loaders-explained)，以了解更多详细信息。
 
 #### 载入
 
-编译的类存储为.class 文件。 当我们尝试使用类时，Java [ClassLoader](https://javatutorial.net/java-class-loaders-explained) 将该类加载到内存中。 在已经运行的类中通过名称引用类时，这些类将引入 Java 环境。 一旦第一个类运行，以后将由类加载器完成加载类的尝试。 通常，通过声明并使用静态 main（）方法来完成第一类的运行。
+编译的类存储为`.class`文件。 当我们尝试使用类时，Java [类加载器](https://javatutorial.net/java-class-loaders-explained)将该类加载到内存中。 在已经运行的类中通过名称引用类时，这些类将引入 Java 环境。 一旦第一个类运行，以后将由类加载器完成加载类的尝试。 通常，通过声明并使用静态`main()`方法来完成第一类的运行。
 
 有三种类型的类加载器：
 
-1.  **Bootstrap Class Loader** -它加载 JDK 内部类，通常加载 rt.jar 和其他核心类，例如 java.lang。*包类
-2.  **Extensions Class Loader** -它从 JDK 扩展目录（通常是 JRE 的 lib / ext 目录）加载类。
-3.  **系统类加载器**-从系统类路径加载类，可以在使用-cp 或-classpath 命令行选项调用程序时进行设置。
+1.  **自举类加载器** - 它加载 JDK 内部类，通常加载`rt.jar`和其他核心类，例如`java.lang.*`包类
+2.  **扩展类加载器** - 它从 JDK 扩展目录（通常是 JRE 的`lib/ext`目录）加载类。
+3.  **系统类加载器** - 从系统类路径加载类，可以在使用`-cp`或`-classpath`命令行选项调用程序时进行设置。
 
 #### 链接
 
@@ -108,7 +108,7 @@ JIT 编译器消除了解释器的缺点。 执行引擎将使用解释器的帮
 
 #### 垃圾收集器
 
-垃圾收集器（GC）收集并删除未引用的对象。 可以通过调用“ System.gc（）”来触发垃圾收集，但是不能保证执行。 JVM 的垃圾收集收集创建的对象。
+垃圾收集器（GC）收集并删除未引用的对象。 可以通过调用`System.gc()`来触发垃圾收集，但是不能保证执行。 JVM 的垃圾收集收集创建的对象。
 
 #### Java 本机接口（JNI）