2021-10-01 22:53:16

docs/handson-auto-test-java-beginners/01.md

@@ -107,7 +107,7 @@ JDK 包含 JRE、Java 文档、调试工具和其他很酷的东西。这是一
 
 ![](img/0c733616-f358-4044-91c0-9a6a0c79ff3d.png)
 
-正如我们所看到的，有很多不同的框架可用，比如 Java Project、C/C++和 Android，但是我们只对 Java 项目感兴趣，所以我们选择 Java Project，然后单击 Next。我们将获得一个新的 Java 项目窗口，在该窗口中，我们将填写新项目的所有信息，如以下屏幕截图所示：
+正如我们所看到的，有很多不同的框架可用，比如 Java Project、C/C++ 和 Android，但是我们只对 Java 项目感兴趣，所以我们选择 Java Project，然后单击 Next。我们将获得一个新的 Java 项目窗口，在该窗口中，我们将填写新项目的所有信息，如以下屏幕截图所示：
 
 ![](img/b882a9d4-72e6-4fcb-b2eb-987ac4fa0327.png)
 
@@ -115,7 +115,7 @@ JDK 包含 JRE、Java 文档、调试工具和其他很酷的东西。这是一
 
 ![](img/554a8c9d-9946-41db-ae31-a0d9d9f65ca3.png)
 
-这将成功创建`coreJavaTraining`。在项目中，有一个自动创建的源文件夹。这意味着我们需要在这个源文件夹中编写类。课程到底是什么？基本上，所有 Java 代码都写在一个类中。当我们在记事本中编写 Java 时，我们打开记事本，编写 Java 代码，并用`.java`扩展名保存特定的记事本文件。但是在 Eclipse 中，所有这些工作都是由这个工具本身完成的。所以我们所需要做的就是创建一个类，这将为我们提供一个合适的模板。我们右键单击源（`src`文件）并单击 New | Class。我们将得到一个 Java 类提示，在这里输入类名。我们将该类命名为`Firstclass`并确保选中公共静态 void main（String[]args）复选框；我们稍后将讨论这一点的重要性。最后，我们点击 Finish。这显示在以下屏幕截图中：
+这将成功创建`coreJavaTraining`。在项目中，有一个自动创建的源文件夹。这意味着我们需要在这个源文件夹中编写类。课程到底是什么？基本上，所有 Java 代码都写在一个类中。当我们在记事本中编写 Java 时，我们打开记事本，编写 Java 代码，并用`.java`扩展名保存特定的记事本文件。但是在 Eclipse 中，所有这些工作都是由这个工具本身完成的。所以我们所需要做的就是创建一个类，这将为我们提供一个合适的模板。我们右键单击源（`src`文件）并单击“新建类”。我们将得到一个 Java 类提示，在这里输入类名。我们将该类命名为`Firstclass`并确保选中`public static void main (String[] args)`复选框；我们稍后将讨论这一点的重要性。最后，我们点击“完成”。这显示在以下屏幕截图中：
 
 ![](img/bcb92860-b758-4a6b-8a6b-ee6cd6b6619d.png)
 
@@ -138,7 +138,7 @@ Firstclass.java
 让我们运行代码。有两种方法可以运行代码：
 
 *   在项目资源管理器中右键单击文件名，单击运行方式，然后选择 Java 应用程序。
-*   或者，我们可以单击工具栏中的 run 图标，然后单击 Save and Launch 窗口中的 OK。图标如下所示：
+*   或者，我们可以单击工具栏中的“运行”图标，然后单击`Save and Launch`窗口中的 OK。图标如下所示：
 
 ![](img/8837d0df-f67f-4d4f-8e2c-33e7a974ab22.png)
 
@@ -146,7 +146,7 @@ Firstclass.java
 
 ![](img/a6869a1c-2f13-4dbb-a8ac-b77ba30eddd4.png)
 
-按照代码显示 hello world 的输出
+按照代码显示`hello world`的输出
 
 简而言之，`System.out.println()`用于在我们的控制台中打印。我们将在几乎所有的示例中使用它来演示实际示例。如果我们从语句中删除`ln`，它将不会在下一行打印输出。
 
@@ -186,7 +186,7 @@ Firstclass.java
 
 ![](img/8bafaa90-b7b8-4472-aad2-25032cc69f34.png)
 
-将值 4 指定给变量 a
+将值 4 指定给变量`a`
 
 因此，使用这种类型的代码，我们可以在外部键入它，但是如果我们想打印它，我们必须在主块中键入它。在本例中，我们希望打印`a`的值，因此我们添加了另一条`System.out.println(a)`语句。编辑器将在`print`语句中为变量`a`抛出一个错误。要知道错误是什么，我们将鼠标悬停在错误上，会显示一个弹出窗口，显示错误以及可能的修复，如以下屏幕截图所示：
 
@@ -200,7 +200,7 @@ Firstclass.java
 
 ![](img/697afa9e-3e5a-440f-8fcc-01f96333b0d6.png)
 
-根据代码显示 a 值的输出
+根据代码显示`a`值的输出
 
 我们将在后面的章节中详细介绍`static`到底是什么
 

docs/handson-auto-test-java-beginners/02.md

@@ -16,9 +16,9 @@
 
 ![](img/95c911f9-6b23-4f44-a268-444f52f7de93.png)
 
-根据代码显示 a 值的输出
+根据代码显示`a`值的输出
 
-如果我们不使用双引号，Java 将检查是否有使用此字母定义的变量。如果是，则打印该变量中的值。如果没有定义变量，则会给出一个错误。如果我们注释掉变量声明，我们看到的是一个错误。将鼠标悬停在变量上，我们将得到一个提示，提示我们创建一个局部变量“a”，或者我们可以通过添加双引号来使用它：
+如果我们不使用双引号，Java 将检查是否有使用此字母定义的变量。如果是，则打印该变量中的值。如果没有定义变量，则会给出一个错误。如果我们注释掉变量声明，我们看到的是一个错误。将鼠标悬停在变量上，我们将得到一个提示，提示我们创建一个局部变量`a`，或者我们可以通过添加双引号来使用它：
 
 ![](img/701160b8-1228-4ed6-a4ea-2c80aeadbda7.png)
 
@@ -49,7 +49,7 @@ public void getData()
 
 在这里，我们不返回任何内容，因此我们将其保留为`void`。
 
-让我们在`System.out.println(" I am in method");`下方添加一行`return 2;`。这里，我们返回一个整数。这就是为什么我们会在这里收到一个错误。如果我们将鼠标悬停在`return 2;`上显示的错误上，您将看到一个建议，将方法返回类型更改为“int”：
+让我们在`System.out.println(" I am in method");`下方添加一行`return 2;`。这里，我们返回一个整数。这就是为什么我们会在这里收到一个错误。如果我们将鼠标悬停在`return 2;`上显示的错误上，您将看到一个建议，将方法返回类型更改为`int`：
 
 ![](img/bbef302b-2ad0-4e6f-ac27-7403c44d3042.png)
 
@@ -166,7 +166,7 @@ public class Firstclass {
 
 根据代码输出显示我在方法中
 
-`I am in method`是我们在输出中看到的；这是因为控件从内存分配行开始，创建一个对象，并使用我们称之为该类方法的对象。控件返回到`getData()`块并完成该特定块中存在的代码行；它执行 print 语句，我们看到它被打印出来了。这就是为什么对象在调用方法时功能强大。
+`I am in method`是我们在输出中看到的；这是因为控件从内存分配行开始，创建一个对象，并使用我们称之为该类方法的对象。控件返回到`getData()`块并完成该特定块中存在的代码行；它执行`print`语句，我们看到它被打印出来了。这就是为什么对象在调用方法时功能强大。
 
 同样的技术也可以用于调用整数。假设我们在`a`类中声明一个变量，并为其赋值。我们可以通过在`main`方法中添加以下行来打印变量值：
 

docs/handson-auto-test-java-beginners/03.md

@@ -5,7 +5,7 @@
 本章将介绍以下主题：
 
 *   引入字符串
-*   String 类及其方法
+*   `String`类及其方法
 *   反转字符串的逻辑
 
 # 引入字符串
@@ -42,7 +42,7 @@
 
 现在，在为这个`hello`字符串创建对象之前，`b`变量首先检查`String`池中是否已经定义了任何`hello`字符串实例。如果已经定义了，它只是将`a`引用到`b`对象，而不是单独创建一个或多个对象。
 
-# 创建 String 类的对象
+# 创建`String`类的对象
 
 我们创建一个`String`类的对象，如下代码行所示：
 

docs/handson-auto-test-java-beginners/04.md

@@ -4,9 +4,9 @@
 
 在本章中，我们将介绍以下主题：
 
-*   for 循环
-*   if…else 条件
-*   while 循环
+*   `for`循环
+*   `if…else`条件
+*   `while`循环
 *   嵌套循环连接
 
 # for 循环
@@ -62,7 +62,7 @@ for (int i=0;i<5;i++)
 
 这就是`for`循环的工作原理。
 
-现在，如果我们将条件设置为以下值，它将不会进入`for`循环，即使是第一次，因为条件为 false：
+现在，如果我们将条件设置为以下值，它将不会进入`for`循环，即使是第一次，因为条件为`false`：
 
 ```java
 for (int i=5;i<3;i++)
@@ -98,7 +98,7 @@ for (int i=0;i<10;i+2 )
 
 ![](img/4c8a86a1-3c08-4821-861f-825c7fcc5da4.png)
 
-根据代码输出 if…else 条件
+根据代码输出`if…else`条件
 
 但所有这些都只发生一次，不像`for`循环，循环中的条件在返回并执行之前是满足的。
 
@@ -121,7 +121,7 @@ for (int i=0;i<10;i+2 )
 
 “快速修复”下拉列表中包含更正代码错误的建议
 
-第一个错误是删除可忽略的 include 条件。在运行前面的程序时，您将看到输出为`success`，因为进入的`5`大于`2`的条件为真：
+第一个错误是删除可忽略的包含条件。在运行前面的程序时，您将看到输出为`success`，因为进入的`5`大于`2`的条件为真：
 
 ![](img/f7022ae4-60cb-484f-ba03-1aeef6950efe.png)
 
@@ -141,7 +141,7 @@ for (int i=0;i<10;i+2 )
 
 这就是`if`条件的工作原理。
 
-请注意，如果块中只有一行，则可以去掉这些大括号，因为它最终假定如果条件为 true，将执行下一行。这意味着，如果块中只有一行，则可以去掉大括号。但是，如果您想要有多个语句，如果您的条件为 true，那么请确保使用大括号来编写该语句，以避免冲突。如果不指定大括号，它仍将打印为`success`，如下图所示：
+请注意，如果块中只有一行，则可以去掉这些大括号，因为它最终假定如果条件为`true`，将执行下一行。这意味着，如果块中只有一行，则可以去掉大括号。但是，如果您想要有多个语句，如果您的条件为`true`，那么请确保使用大括号来编写该语句，以避免冲突。如果不指定大括号，它仍将打印为`success`，如下图所示：
 
 ![](img/2c1551ea-22ed-4bd1-bee1-09fa506a241d.png)
 
@@ -157,7 +157,7 @@ for (int i=0;i<10;i+2 )
 
 请注意前面屏幕截图中标记的语法错误。要么你应该保持一个支撑，要么你应该避免这一步。为了解决这个问题，我们只需将整个块放在大括号中。这样，错误就消失了。
 
-# 在 for 循环中引入 if…else 条件
+# 在`for`循环中引入`if…else`条件
 
 现在，让我们将`if...else`条件引入`for`循环。让我们在代码中添加以下内容：
 
@@ -177,7 +177,7 @@ for (int i=0;i<10;i=i+2)
 
 ![](img/8c71b43a-21c1-4dd2-a8a9-2f73d9d39404.png)
 
-“8 显示”和“我没有找到”显示为输出
+`" 8 is displayed"`和`"I did not find"`显示为输出
 
 现在，如果我们说`i=9`，它将永远不会被打印，因为我们设置的条件是`i+2`，这将是一个递增的偶数。这意味着不满足条件，并且不执行`if`条件之后的下一步。因此，我们可以说，如果一个条件是真的，只有到那时它才会被执行；否则，将执行`else`块中的条件或语句。当你运行它时，你总是得到输出为`"I did not find"`
 
@@ -189,7 +189,7 @@ for(int i=0;i<10;i=i+3)
 
 这就是使用`for`循环时`if...else`条件的工作方式。在下一节中，我们将详细了解`for`循环
 
-# while 循环
+# `while`循环
 
 在本节中，我们将详细学习`while`循环。首先，创建一个新类。现在让我们看看在编写代码时如何利用这个`while`循环。假设我们要按顺序打印从 1 到 10 的数字。我们如何使用`while`循环打印此内容？`while`循环的基本语法是：
 
@@ -216,9 +216,9 @@ while(i<10)
 }
 ```
 
-如您所见，在前面的代码示例中，我们可以看到给定的条件为 true。因此，它进入循环并打印`i`的值。此循环将继续执行，直到表达式的计算结果为 false。根据我们的例子，条件总是正确的；因此，它将进入无限循环并打印零。
+如您所见，在前面的代码示例中，我们可以看到给定的条件为`true`。因此，它进入循环并打印`i`的值。此循环将继续执行，直到表达式的计算结果为`false`。根据我们的例子，条件总是正确的；因此，它将进入无限循环并打印零。
 
-这就是`while`循环的工作原理。除非此参数中的条件变为 false，否则此循环将永远不会停止执行。现在，如果我们在打印变量后增加值呢？让我们看看这样做会发生什么：
+这就是`while`循环的工作原理。除非此参数中的条件变为`false`，否则此循环将永远不会停止执行。现在，如果我们在打印变量后增加值呢？让我们看看这样做会发生什么：
 
 ```java
 //While loop 
@@ -237,7 +237,7 @@ while(i<10)
 
 ![](img/a85aed48-a67a-4728-ac07-197732c9b00a.png)
 
-根据代码输出 while 条件
+根据代码输出`while`条件
 
 如果我们使用以下条件：
 
@@ -249,7 +249,7 @@ while(i<=10)
 
 ![](img/e3cd184f-cdc3-4586-9c75-a5b9d32a5402.png)
 
-修改代码后 while 条件的输出
+修改代码后`while`条件的输出
 
 类似地，您可以按如下方式反转条件：
 
@@ -295,7 +295,7 @@ while(i>0)
 
 这就是我们如何在 Java 程序中使用`while`循环语法的方法。在下一节中，我们将看到如何处理`do...while`循环。
 
-# do…while 循环
+# `do…while`循环
 
 `do...while`循环的语法是：
 
@@ -361,7 +361,7 @@ for(int i=1;i<=4;i++)  // this block will loop for 4 times
 
 ```
 
-因此，当我们完成之前的迭代一次时，一个循环系统就完成了。要完成一个外循环，我们必须完成所有四个内循环。这意味着我们必须运行这个内部循环 16 次（4 次 4 次）才能完成这个外部循环 4 次。
+因此，当我们完成之前的迭代一次时，一个循环系统就完成了。要完成一个外循环，我们必须完成所有四个内循环。这意味着我们必须运行这个内部循环 16 次（4x4 次）才能完成这个外部循环 4 次。
 
 输出如以下屏幕截图所示：
 

docs/handson-auto-test-java-beginners/05.md

@@ -200,7 +200,7 @@ class Z extends X, Y
 }
 ```
 
-在前面的代码片段中，我们有`X`和`Y`类以及其中的一些数据字段或方法。`Z`类继承`X`和`Y`类。允许这样做吗？答案是否定的。java 不允许多个继承，而 C++则允许。因此，在这里，我们可以得出结论，前面的代码片段是不正确的，将抛出一个错误。
+在前面的代码片段中，我们有`X`和`Y`类以及其中的一些数据字段或方法。`Z`类继承`X`和`Y`类。允许这样做吗？答案是否定的。java 不允许多个继承，而 C++ 则允许。因此，在这里，我们可以得出结论，前面的代码片段是不正确的，将抛出一个错误。
 
 这也是继承和接口之间的区别之一，因为接口允许我们一次使用多个接口。
 

docs/handson-auto-test-java-beginners/06.md

@@ -33,7 +33,7 @@ int a[] = new int[5];
 
 我们已经声明了一个数组并为这些值分配了内存，现在我们需要传递这些值。第一个值将放在索引`0`中，第二个值放在索引`1`中，依此类推。索引命名从`0`索引开始，因此第一个值将分配给`0`索引。这意味着我们实际上初始化了数组中的值。现在，`a`数组保存我们分配给它的所有值。对于我们的示例，我们为数组声明任何随机值。
 
-现在让我们从数组中检索值。为此，我们在声明数组的值后，在`main`类中键入以下代码，创建一个`for`循环，然后留下一个 print 语句：
+现在让我们从数组中检索值。为此，我们在声明数组的值后，在`main`类中键入以下代码，创建一个`for`循环，然后留下一个`print`语句：
 
 ```java
 for(int i=0; i<a.length;i++);
@@ -60,7 +60,7 @@ int b[] = {1,4,3,5,7,8};
 
 在前面的示例中，我们分配内存，然后分配值。在本例中，我们不是分配内存，而是直接将值传递给数组。这里，内存是动态分配的，如果我们在数组声明中添加一个值，就会自动分配一个内存，并将该值传递给它。在大多数情况下，编码人员使用此方法声明数组值，而不是声明分配然后分配值。
 
-与前面的示例类似，第一个值被分配给索引`0`。如果我们编写一个类似于上一个示例的 print 语句并运行代码，我们将看到显示的`b`数组的值。
+与前面的示例类似，第一个值被分配给索引`0`。如果我们编写一个类似于上一个示例的`print`语句并运行代码，我们将看到显示的`b`数组的值。
 
 它包含了一维数组；让我们来谈谈多维数组。
 
@@ -93,13 +93,13 @@ a[1][1]=4;
 a[1][2]=7;
 ```
 
-这样，我们将把所有的值输入到一个多维数组中。如果我们想显示第二行第一列的值，我们就写一个 print 语句，并给出要显示其值的元素的位置。在这种情况下，我们希望显示第二行第一列，因此 print 语句将写为：
+这样，我们将把所有的值输入到一个多维数组中。如果我们想显示第二行第一列的值，我们就写一个`print`语句，并给出要显示其值的元素的位置。在这种情况下，我们希望显示第二行第一列，因此`print`语句将写为：
 
 ```java
 System.out.println(a[1][0]);
 ```
 
-print 语句将显示`3`，这是该位置元素的值。在下一节中，我们将举一个示例，帮助解释如何在解决编码问题时使用所有这些概念。
+`print`语句将显示`3`，这是该位置元素的值。在下一节中，我们将举一个示例，帮助解释如何在解决编码问题时使用所有这些概念。
 
 如何打印本例中声明的数组的所有值？在前面的示例中，我们通过简单地创建一个`for`循环来打印数组，将其从`0`迭代到数组的长度，然后显示数组。
 
@@ -113,7 +113,7 @@ int b[][]= {{2,4,5},{3,4,7},{5,2,1}};
 
 # 多维数组的逻辑编程
 
-现在我们来看看如何打印上一节中使用的整个多维数组（即 a 数组）的所有值。
+现在我们来看看如何打印上一节中使用的整个多维数组（即`a`数组）的所有值。
 
 如果我们分析数组的声明，我们将看到需要两个`for`循环来打印整个数组，一个用于行，一个用于列。
 
@@ -129,7 +129,7 @@ for(int i=0;i<2;i++)
 for(int j=0;j<3;j++)
 ```
 
-最后，为了打印数组，我们在内部`for`循环中添加了一个 print 语句来显示所有的值。最终代码如下：
+最后，为了打印数组，我们在内部`for`循环中添加了一个`print`语句来显示所有的值。最终代码如下：
 
 ```java
 for(int i=0;i<2;i++) //row
@@ -165,7 +165,7 @@ for(int i=0;i<2;i++) //row
 
 让我们尝试一些练习，帮助我们理解和使用数组。这些练习还将在面试时解释概念。
 
-# 打印 3 x 3 矩阵中的最小数字
+# 打印`3 x 3`矩阵中的最小数字
 
 让我们为本练习创建另一个类，将其命名为`InterviewMinnumber`，并在主块中定义数组。定义代码如下：
 
@@ -173,7 +173,7 @@ for(int i=0;i<2;i++) //row
 int abc[][]={{2,4,5},{3,2,7},{1,2,9}};
 ```
 
-此代码声明了一个名为`abc`的 3 x 3 矩阵。现在我们需要遍历矩阵中的每个数，并寻找其中的最小数。要遍历多维数组中的每个数字，我们需要使用在“多维数组上的逻辑编程”部分中使用的相同概念。
+此代码声明了一个名为`abc`的`3 x 3`矩阵。现在我们需要遍历矩阵中的每个数，并寻找其中的最小数。要遍历多维数组中的每个数字，我们需要使用在“多维数组上的逻辑编程”部分中使用的相同概念。
 
 我们在这里使用两个`for`循环：一个外部`for`循环遍历行，一个内部`for`循环遍历列。两个`for`循环代码如下所示：
 
@@ -234,7 +234,7 @@ public class InterviewMinnumber
 int abc[][]={{2, 4, 5}, {3, 0, 7}, {1, 2, 9}}
 ```
 
-让我们转到第 2 步。如果我们观察代码，我们会看到，`i`代表行号，`j`代表列号。因此，`j`将取存在最小数字的列的值，我们将取这个值`j`并将其分配给一个调用`mincolumn`的变量。因此，我们在 swapping 命令下编写代码，该命令将`j`的值分配给`mincolumn`。代码将如下所示：
+让我们转到第 2 步。如果我们观察代码，我们会看到，`i`代表行号，`j`代表列号。因此，`j`将取存在最小数字的列的值，我们将取这个值`j`并将其分配给一个调用`mincolumn`的变量。因此，我们在交换命令下编写代码，该命令将`j`的值分配给`mincolumn`。代码将如下所示：
 
 ```java
 mincoloumn=j;
@@ -268,7 +268,7 @@ if(abc[k][mincoloumn]>max)
 }
 ```
 
-因此，对于`k`的第一个值，即`0`，我们转到第一行和第二列，并将该值分配给`max`；在本例中，值为`4`。在`if`条件下，我们将第一行第二列的值与`max`的值进行比较。在本例中，两个值相同，因此不执行`if`循环，我们迭代`k`并再次进入`while`循环。接下来，我们将第二行、第二列的值与`max`的值进行比较；我们移动到第二行，因为`k`的值被`1`迭代，`k`的当前值是`1`。因此，在比较中，我们看到`o`小于`4`，其中`4`是`max`变量的值。再次不满足该条件，`if`循环再次被跳过。第三行也是如此，`max`的最终值为`4`，这是列中最大的数字。最后，我们留下一个 print 语句，在末尾打印`max`的值。
+因此，对于`k`的第一个值，即`0`，我们转到第一行和第二列，并将该值分配给`max`；在本例中，值为`4`。在`if`条件下，我们将第一行第二列的值与`max`的值进行比较。在本例中，两个值相同，因此不执行`if`循环，我们迭代`k`并再次进入`while`循环。接下来，我们将第二行、第二列的值与`max`的值进行比较；我们移动到第二行，因为`k`的值被`1`迭代，`k`的当前值是`1`。因此，在比较中，我们看到`o`小于`4`，其中`4`是`max`变量的值。再次不满足该条件，`if`循环再次被跳过。第三行也是如此，`max`的最终值为`4`，这是列中最大的数字。最后，我们留下一个`print`语句，在末尾打印`max`的值。
 
 # 使用/不使用临时变量交换变量
 
@@ -298,7 +298,7 @@ temp=a[i];
  a[j]=temp;
 ```
 
-最后，我们添加一个 print 语句来显示比较和重新排列值后的最终数组。
+最后，我们添加一个`print`语句来显示比较和重新排列值后的最终数组。
 
 最终输出将显示如下：
 

docs/handson-auto-test-java-beginners/07.md

@@ -118,7 +118,7 @@ Calendar cal=Calendar.getInstance();
 Date d=new Date();
 ```
 
-步骤与`Date`类类似。然而，`Calendar`对象有一些 date 不支持的独特特性。让我们来探索一下。
+步骤与`Date`类类似。然而，`Calendar`对象有一些`Date`不支持的独特特性。让我们来探索一下。
 
 使用以下代码段：
 
@@ -132,7 +132,7 @@ Date d=new Date();
 
 ![](img/5f8f48c1-689c-4c56-b27a-debebf8a514f.png)
 
-使用 calendar 类显示日期和时间的输出
+使用`Calendar`类显示日期和时间的输出
 
 现在，假设我们也要打印每月和每周的日期。我们将在前面的代码段中添加以下代码行：
 
@@ -145,7 +145,7 @@ System.out.println(cal.get(Calendar.DAY_OF_WEEK_IN_MONTH));
 
 ![](img/e36a6cb9-d914-4aab-9863-b121a07af33a.png)
 
-使用 calendar 类输出显示月份中的日期、时间、月日和周日
+使用`Calendar`类输出显示月份中的日期、时间、月日和周日
 
 类似地，我们可以从以下屏幕截图中看到，有多个属性可供选择：
 

docs/handson-auto-test-java-beginners/08.md

-# super 和 this 关键字和异常在 Java 中的重要性
+# `super`和`this`关键字和异常在 Java 中的重要性
 
 在本章中，我们将了解两个关键词：`super`和`this`。在编写 Java 代码时，我们将挑选一些示例并解释如何在各种情况下使用它们。我们还将研究异常，以及如何使用它们来处理由于某些错误导致代码失败的情况。我们将在`finally`部分结束本章。
 
 在本章中，我们将介绍以下主题：
 
-*   超级关键字
-*   super 关键字的实际使用
+*   `super`关键字
+*   `super`关键字的实际使用
 *   这个关键词的重要性
 *   不同种类的例外
-*   处理异常的 try…catch 机制
-*   finally 块在 Java 中的重要性
+*   处理异常的`try…catch`机制
+*   `finally`块在 Java 中的重要性
 
-# 超级关键字
+# `super`关键字
 
 通常，当人们从不同的类继承属性时，如果在父类和子类中使用相同的变量名，则可能存在冗余。为了区分父变量和子变量，我们使用了`super`关键字。
 
@@ -25,9 +25,9 @@ public class childDemo extend parentDemo{
 
 在此代码中，`childDemo`取`parentDemo`的属性。
 
-在`childDemo`类中添加一个字符串，将其命名为`name`，并将`QAClickAcademy`字符串分配给它。然后，我们在`childDemo`类中定义一个名为`public void getStringdata()`的方法，并给出一条语句来打印`name`的值作为输出。我们在`getStringdata()`之外定义了另一个名为`public static void main(String[] args)`的方法，并为子类`childDemo cd = new childDemo();`创建了一个对象。一旦对象被创建，我们会在下面添加另一行代码：`cd.getStringdata();`。这就调用了`getrStringdata()`方法，因此很明显，名称被打印为输出，即`QAClickAcademy`。尽管我们继承了`parentDemo`类的属性，该类也包含同名字符串，但 print 语句调用`childDemo`中字符串的值。这是因为 Java 优先考虑局部变量。
+在`childDemo`类中添加一个字符串，将其命名为`name`，并将`QAClickAcademy`字符串分配给它。然后，我们在`childDemo`类中定义一个名为`public void getStringdata()`的方法，并给出一条语句来打印`name`的值作为输出。我们在`getStringdata()`之外定义了另一个名为`public static void main(String[] args)`的方法，并为子类`childDemo cd = new childDemo();`创建了一个对象。一旦对象被创建，我们会在下面添加另一行代码：`cd.getStringdata();`。这就调用了`getrStringdata()`方法，因此很明显，名称被打印为输出，即`QAClickAcademy`。尽管我们继承了`parentDemo`类的属性，该类也包含同名字符串，但`print`语句调用`childDemo`中字符串的值。这是因为 Java 优先考虑局部变量。
 
-每当父级和子级的变量名发生冲突时，它会优先选择局部变量，在本例中是`childDemo`类。如果我们正在进行一个项目，需要在`parentDemo`类中打印字符串名称，该怎么办？为此，我们使用`super`关键字引用`parentDemo`类，从中我们将属性继承到`childDemo`类。因此，如果我们想从`parentDemo`类中调用 name 变量，我们将添加一个 print 语句，并在我们想要打印的变量之前添加一个`super`关键字，这将从`parentDemo`中获得值。当我们现在运行代码时，我们得到父对象和子对象作为输出，因为我们在两个类中都为名称字符串留下了一个 print 语句。`parentDemo`类的代码如下：
+每当父级和子级的变量名发生冲突时，它会优先选择局部变量，在本例中是`childDemo`类。如果我们正在进行一个项目，需要在`parentDemo`类中打印字符串名称，该怎么办？为此，我们使用`super`关键字引用`parentDemo`类，从中我们将属性继承到`childDemo`类。因此，如果我们想从`parentDemo`类中调用`name`变量，我们将添加一个`print`语句，并在我们想要打印的变量之前添加一个`super`关键字，这将从`parentDemo`中获得值。当我们现在运行代码时，我们得到父对象和子对象作为输出，因为我们在两个类中都为名称字符串留下了一个`print`语句。`parentDemo`类的代码如下：
 
 ```java
 public class parentDemo{
@@ -63,21 +63,21 @@ QAClickAcademy
 Rahul
 ```
 
-# super 关键字的实际使用
+# `super`关键字的实际使用
 
 在本节中，我们将了解在 Java 中使用`super`关键字的不同方式。
 
-# 对方法使用 super 关键字
+# 对方法使用`super`关键字
 
 我们看到了如何通过`super`关键字处理父变量。在本节中，我们将了解如何处理两个方法，如果它们在`parentDemo`和`childDemo`类中的名称相同。在本节中，我们也将使用前面的示例。
 
 在`parentDemo`类中，添加一个名为`getData()`的方法，并在该方法内部给出一条打印语句来显示`"I am in parent class"`消息。如果我们想在`childDemo`类中执行`getData()`方法，我们就在`childDemo`类的`main`方法中写入`cd.getData()`。我们可以访问`getData()`，因为我们继承了`parentDemo`类的属性。如果我们运行`childDemo`类，我们将收到前面示例的输出以及我们在`parentDemo`类`I am in parent class`中添加的新句子。
 
-在`childDemo`类中，我们将定义另一个与`parentDemo`类同名的方法，并添加一个 print 语句来显示`I am in child class`消息。如果我们运行`childDemo`类，我们将获得前面示例的输出，然后显示`I am in child class`。这是因为优先考虑了本地类，所以`childDemo`类中的`getData()`方法会覆盖`parentDemo`类中的`getData()`方法。
+在`childDemo`类中，我们将定义另一个与`parentDemo`类同名的方法，并添加一个`print`语句来显示`I am in child class`消息。如果我们运行`childDemo`类，我们将获得前面示例的输出，然后显示`I am in child class`。这是因为优先考虑了本地类，所以`childDemo`类中的`getData()`方法会覆盖`parentDemo`类中的`getData()`方法。
 
 现在，我们想在`childDemo`类中使用`parentDemo`类的`getData()`方法。要做到这一点，我们只需像对待变量那样：在`childDemo`类的`getData()`方法中添加`super.getData()`。当我们运行`childDemo()`类时，我们得到前面示例的输出，然后是`I am in parent class`和`I am in child class`。
 
-# 为构造函数使用 super 关键字
+# 为构造函数使用`super`关键字
 
 让我们在本节中为构造函数使用`super`关键字。这里我们也将使用前面的示例。
 
@@ -102,7 +102,7 @@ I am in child class
 
 Java 中还有一个类似于`super`关键字的关键字：`this`。在本节中，我们将看一看`this`关键字。
 
-让我们用一个例子来解释`this`关键字。创建一个名为`thisDemo`的类，声明一个变量`a`，并为其赋值`2`。我们在其类中定义了一个`getData()`方法，在其中声明了`a`变量，并为其赋值`3`。我们还添加了一个 print 语句。代码如下所示：
+让我们用一个例子来解释`this`关键字。创建一个名为`thisDemo`的类，声明一个变量`a`，并为其赋值`2`。我们在其类中定义了一个`getData()`方法，在其中声明了`a`变量，并为其赋值`3`。我们还添加了一个`print`语句。代码如下所示：
 
 ```java
 package coreJava;public class thisDemo
@@ -115,7 +115,7 @@ package coreJava;public class thisDemo
     }
 ```
 
-正如我们所看到的，`a`的值在整个类中是`2`，但是在一个具体的方法`getData()`中，我们希望变量的值是`3`。在这段代码中，我们希望调用`a`的两个值，即`2`和`3`。我们在 main 方法中创建了一个对象，并在其中添加了`td`对象。`td`对象的代码如下：
+正如我们所看到的，`a`的值在整个类中是`2`，但是在一个具体的方法`getData()`中，我们希望变量的值是`3`。在这段代码中，我们希望调用`a`的两个值，即`2`和`3`。我们在`main`方法中创建了一个对象，并在其中添加了`td`对象。`td`对象的代码如下：
 
 ```java
 thisDemo td=new thisDemo();
@@ -124,7 +124,7 @@ td.getData();
 
 如果我们运行代码，我们得到的输出是`3`。但我们也希望在同一块中将`a`的值打印为`2`。此时`this`关键字开始发挥作用。类对象的范围将在类级别，而不是方法级别。所以我们说`getData()`方法指的是当前对象，对象范围在类级别。所以`a= 2`对整个类有效，`a=3`只对`getData()`方法有效。这就是为什么我们将`getData()`方法中的`a`变量称为局部变量，将类中的`a`变量称为全局变量。
 
-要打印我们正在处理的示例的全局变量，我们需要在`getData()`方法中添加一个 print 语句，并在 print 语句中添加`this.a`。print 语句如下所示：
+要打印我们正在处理的示例的全局变量，我们需要在`getData()`方法中添加一个`print`语句，并在`print`语句中添加`this.a`。`print`语句如下所示：
 
 ```java
 System.out.println(this.a);
@@ -137,7 +137,7 @@ System.out.println(this.a);
 2
 ```
 
-这就结束了我们关于 This 变量的示例。现在让我们了解异常。
+这就结束了我们关于`this`变量的示例。现在让我们了解异常。
 
 # 不同种类的例外
 
@@ -176,7 +176,7 @@ public static void main(String[] args)
 I caught the error/exception
 ```
 
-# 处理异常的 try…catch 机制
+# 处理异常的`try…catch`机制
 
 在本节中，我们将使用一个`try`后跟多个`catch`块。Java 中有不同类型的异常，我们可以为每个异常添加单独的`catch`块。
 
@@ -199,7 +199,7 @@ I caught the Arithmeticerror/exception
 
 Java 中还有许多其他的例外：我们可以通过 Google 来查看它们。
 
-# finally 块在 Java 中的重要性
+# `finally`块在 Java 中的重要性
 
 还有一个类似于`try...catch`块的块：`finally`块。无论是否引发异常，`finally`块都将被执行。如果程序成功运行，则执行此块；如果程序未运行，则执行此块。
 

docs/handson-auto-test-java-beginners/09.md

@@ -11,9 +11,9 @@
 
 # 集合框架
 
-Java 集合框架基本上是接口和类的集合。为了高效地编程，或者利用 Java 方法的灵活性，Java 设计了一个由不同类和接口组成的框架。collections 框架有助于高效地存储和处理数据。这个框架有几个有用的类，它们有很多有用的函数，这使得程序员的任务非常简单。
+Java 集合框架基本上是接口和类的集合。为了高效地编程，或者利用 Java 方法的灵活性，Java 设计了一个由不同类和接口组成的框架。集合框架有助于高效地存储和处理数据。这个框架有几个有用的类，它们有很多有用的函数，这使得程序员的任务非常简单。
 
-我们已经看到了很多关于数组和多维数组的概念。例如，在一个数组中，如果我们想从一组新的数组中删除一个索引，我们可以使用集合框架来完成。假设在一个数组中有 10 个值，我们想要删除第五个值，或者在第五个值和第六个值之间插入一个值。在 collections 框架中有一些灵活的方法。
+我们已经看到了很多关于数组和多维数组的概念。例如，在一个数组中，如果我们想从一组新的数组中删除一个索引，我们可以使用集合框架来完成。假设在一个数组中有 10 个值，我们想要删除第五个值，或者在第五个值和第六个值之间插入一个值。在集合框架中有一些灵活的方法。
 
 本收集框架中可用的方法种类，以及如何有效地使用这些方法，将在后续章节中讨论。因此，为了给您一个想法，请记住集合是一组类和接口。
 
@@ -21,13 +21,13 @@ Java 集合框架基本上是接口和类的集合。为了高效地编程，或
 
 # 列表集合
 
-第一个是`List`采集/接口。列表是一个有序的集合，有时我们也将其称为序列。列表可能包含重复的元素，就像数组一样，但是数组和`ArrayList`之间有很多不同。您可以在这个`List`容器中插入多个值，它也可能包含重复的元素。实际上，您可以添加任何值，也可以从任何索引中删除任何值。假设您按顺序向列表中添加了 15 个元素，现在您想要删除 6 个<sup class="calibre84">th</sup>元素，或者您想要在 10 个<sup class="calibre84">th</sup>和 11 个<sup class="calibre84">th</sup>元素之间插入一个元素，或者您想要知道这 15 个元素中的一个元素在哪个索引处。有很多有用的 API 可以从列表容器中检索元素，而我们在数组中没有这些 API。数组只能初始化；除此之外，你不能在一个数组上执行任何方法，而使用`ArrayList`你可以使用很多灵活的方法。
+第一个是`List`采集/接口。列表是一个有序的集合，有时我们也将其称为序列。列表可能包含重复的元素，就像数组一样，但是数组和`ArrayList`之间有很多不同。您可以在这个`List`容器中插入多个值，它也可能包含重复的元素。实际上，您可以添加任何值，也可以从任何索引中删除任何值。假设您按顺序向列表中添加了 15 个元素，现在您想要删除第六个元素，或者您想要在第十个和第十一个元素之间插入一个元素，或者您想要知道这 15 个元素中的一个元素在哪个索引处。有很多有用的 API 可以从列表容器中检索元素，而我们在数组中没有这些 API。数组只能初始化；除此之外，你不能在一个数组上执行任何方法，而使用`ArrayList`你可以使用很多灵活的方法。
 
 `List`接口是一个集合，`ArrayList`、`LinkedList`、`vector`是实现该接口的三个类。此接口提供了一组方法。它公开了一些方法，而这三个类在它们的类中使用这些方法。
 
 在这三个问题中，让我们讨论一下`ArrayList`。这是最著名的一个，大多数 Java 程序员都使用它。一旦你理解了`ArrayList`，你就可以很容易地理解`LinkedLists`和`vector`。在下一节中，我们将创建一个`ArrayList`类并实现`List`接口中的方法，以了解这些方法在检索或组织数据方面的灵活性。当容器中有一组数据时，您可以借助`List`界面轻松组织该数据。
 
-# ArrayList 类
+# `ArrayList`类
 
 让我们从实现`List`接口的`ArrayList`类开始。创建一个新类并将其命名为`arrayListexample`。我们先看一下`ArrayList`中的方法，然后讨论数组和`ArrayList`之间的区别。
 
@@ -54,7 +54,7 @@ public class arrayListexample {
         a.add("java");
 ```
 
-传递参数类型后，您可以使用`a.`轻松添加一些字符串实例，它将显示`ArrayList`支持的不同类型的列表。对于`ArrayList`，我们没有定义特定的数组大小，而当您在数组中看到时，我们已经明确定义了一个大小。在数组中，一旦定义了大小，就不能减少或增加大小。但在`ArrayList`中，您可以随时从列表中添加或删除元素，这是一个动态大小数组。这是 array 与`ArrayList`的基本区别之一。
+传递参数类型后，您可以使用`a.`轻松添加一些字符串实例，它将显示`ArrayList`支持的不同类型的列表。对于`ArrayList`，我们没有定义特定的数组大小，而当您在数组中看到时，我们已经明确定义了一个大小。在数组中，一旦定义了大小，就不能减少或增加大小。但在`ArrayList`中，您可以随时从列表中添加或删除元素，这是一个动态大小数组。这是数组与`ArrayList`的基本区别之一。
 
 如果我们想打印这个`ArrayList`，我们只需添加以下代码行即可：
 
@@ -128,7 +128,7 @@ public class arrayListexample {
 
 关于`ArrayList`您还需要知道的一点是，实现`List`接口的所有类都可以接受重复的值。我们知道集合接口中扩展了`List`的类：`ArrayList`、`LinkedList`和`vector`。所有这些类都可以接受重复的值。
 
-# ArrayList 示例
+# `ArrayList`示例
 
 假设我们有一个具有重复数字的数组，例如`{4, 5, 5, 5, 4, 6, 6, 9, 4}`，我们想从中打印出唯一的数字，以及这个数字在这个数组中重复了多少次。我们的输出应该是“四重复三次，五重复三次，六重复两次，九重复一次。”
 
@@ -339,11 +339,11 @@ evening
 
 # 空键和空值
 
-`HashMap`允许一个空键和任意数量的空值，`HashTable`不允许`HashTable`对象中的空键和空值。假设您正在将员工记录输入数据库，并且在将员工详细信息上载到数据库时，您可能觉得您不知道他们的电话号码，但您在键值中输入了名为 phone number 的字段，此时索引值将保留为 null；您可以稍后更新它。这在`HashMap`中起作用，但当您使用`HashTable`时，它将不允许任何空键和空值。如果您觉得您的程序非常安全，并且希望阻止多个线程同时访问它，那么您应该使用`HashTable`。`HashTable`是线程安全的，在一个程序完成对`HashTable`的操作之前，它不会将其对象释放给另一个程序。
+`HashMap`允许一个空键和任意数量的空值，`HashTable`不允许`HashTable`对象中的空键和空值。假设您正在将员工记录输入数据库，并且在将员工详细信息上载到数据库时，您可能觉得您不知道他们的电话号码，但您在键值中输入了名为电话号码的字段，此时索引值将保留为`null`；您可以稍后更新它。这在`HashMap`中起作用，但当您使用`HashTable`时，它将不允许任何空键和空值。如果您觉得您的程序非常安全，并且希望阻止多个线程同时访问它，那么您应该使用`HashTable`。`HashTable`是线程安全的，在一个程序完成对`HashTable`的操作之前，它不会将其对象释放给另一个程序。
 
 # 迭代值
 
-`HashMap`使用`iterator`迭代对象值。`HashTable`是除 vector 之外唯一一个使用枚举器迭代`HashTable`对象值的类。
+`HashMap`使用`iterator`迭代对象值。`HashTable`是除`Vector`之外唯一一个使用枚举器迭代`HashTable`对象值的类。
 
 在`HashMap`和`HashTable`之间的操作是相同的，除了我们刚才描述的三个差异。
 

docs/handson-auto-test-java-beginners/10.md

@@ -60,7 +60,7 @@ import package.classname
 
 同时，我们还可以定义一个用户定义的 Java 包。在本例中，我们所有的测试用例都位于一个名为`coreJava`的不同包中。如果有人想使用我们的类，他们只需要运行`import coreJava.classname`。
 
-在下一节中，我们将研究 public 修饰符
+在下一节中，我们将研究`public`修饰符
 
 # Java 中的修饰符
 
@@ -120,7 +120,7 @@ public class arrayListexample {
 
 这是因为，如果我们将任何方法或变量标记为`private`，我们就无法在该特定类之外访问它。除非我们把它改成别的东西，否则它会抛出一个错误。这也适用于变量。
 
-如果你想要一个实时场景，假设你正在付款并购买一个产品；所有的信用卡详细信息都将作为`private`，因为它们在 buy 类之外无法访问。如果可以访问，那就是安全漏洞，对吗？因此，为了使信用卡详细信息仅限于该特定类，开发人员将`private`变量赋予所有信用卡详细信息，以便其他类无法使用它。即使他们使用了继承或导入了一个包，他们也无法访问这些敏感的细节；如果您正在测试框架上工作，那么可能存在一些您不应该更改的变量，并且始终保持其私有性。
+如果你想要一个实时场景，假设你正在付款并购买一个产品；所有的信用卡详细信息都将作为`private`，因为它们在`Buy`类之外无法访问。如果可以访问，那就是安全漏洞，对吗？因此，为了使信用卡详细信息仅限于该特定类，开发人员将`private`变量赋予所有信用卡详细信息，以便其他类无法使用它。即使他们使用了继承或导入了一个包，他们也无法访问这些敏感的细节；如果您正在测试框架上工作，那么可能存在一些您不应该更改的变量，并且始终保持其私有性。
 
 # 受保护的
 

docs/high-perform-app-java9/2.md

@@ -244,7 +244,7 @@ java -XX:CompileThreshold=500 -XX:-TieredCompilation Test
 
 ## 静态编译与动态编译
 
-许多高级编程语言如 C 或 C++从一开始就使用 AOT 编译。它们也被称为**静态编译**语言。由于 AOT（或静态）编译器不受性能要求的约束（至少没有运行时的解释器（也称为**动态编译器**）那么多），因此它们可以花时间进行复杂的代码优化。另一方面，静态编译器没有运行时（评测）数据，这在动态类型语言的情况下尤其有限，Java 就是其中之一。由于 Java 中的动态类型功能（向下转换到子类型、查询对象的类型以及其他类型操作）是面向对象编程（多态原理）的支柱之一，因此 Java 的 AOT 编译变得更加有限。Lambda 表达式暂停了静态编译的另一个挑战，目前还不受支持。**
+许多高级编程语言如 C 或 C++ 从一开始就使用 AOT 编译。它们也被称为**静态编译**语言。由于 AOT（或静态）编译器不受性能要求的约束（至少没有运行时的解释器（也称为**动态编译器**）那么多），因此它们可以花时间进行复杂的代码优化。另一方面，静态编译器没有运行时（评测）数据，这在动态类型语言的情况下尤其有限，Java 就是其中之一。由于 Java 中的动态类型功能（向下转换到子类型、查询对象的类型以及其他类型操作）是面向对象编程（多态原理）的支柱之一，因此 Java 的 AOT 编译变得更加有限。Lambda 表达式暂停了静态编译的另一个挑战，目前还不受支持。**
 
 动态编译器的另一个优点是，它可以做出假设并相应地优化代码。如果假设被证明是错误的，编译器可以尝试另一个假设，直到达到性能目标。这样的过程可能会减慢应用程序的速度和/或增加预热时间，但从长远来看，它可能会带来更好的性能。概要文件引导的优化也可以帮助静态编译器沿着这条路径前进，但与动态编译器相比，静态编译器的优化机会总是有限的。
 

docs/master-soft-test-junit5/1.md

@@ -693,7 +693,7 @@ JUnit 是 JVM 最流行的测试框架之一，被认为是软件工程中最有
 
 多亏了 JUnit，测试已经转移到编程的核心部分。因此，在 JUnit 中实现的底层测试模型已被移植到 JVM 边界之外的一组测试框架中，即所谓的 xUnit 系列。在这个模型中，我们找到了测试用例、运行器、夹具、套件、测试执行、报告和断言的概念。举几个例子，考虑以下框架。他们都属于 xUnit 家族：
 
-*   [GoogleTest](https://github.com/google/googletest)：谷歌的 C++测试框架。
+*   [GoogleTest](https://github.com/google/googletest)：谷歌的 C++ 测试框架。
 *   [JSUnit](http://www.jsunit.net/)：JavaScript 的单元测试框架。
 *   [MochaJS](https://mochajs.org/)：运行在 Node.js 上的单元测试框架。
 *   [NUnit](https://www.nunit.org/)：微软.NET 的单元测试框架。

docs/master-soft-test-junit5/5.md

@@ -1863,7 +1863,7 @@ Android 是一个基于 Linux 的软件栈，分为若干层。这些层（从
 *   **Linux 内核**：这是 Android 平台的基础。该层包含 Android 设备各种硬件组件的所有低级设备驱动程序。
 *   **硬件抽象层**（**HAL**）：该层提供标准接口，向更高级别的 Java API 框架公开硬件功能。
 *   **安卓运行时**（**ART**）：它为`.dex`文件提供了一个运行时环境，一种字节码格式，旨在减少内存占用。ART 是 Android 5.0 的第一个版本（见下表）。在该版本之前，Dalvik 是 Android 运行时。
-*   **原生 C/C++ 库**：该层包含用 C 和 C++编写的原生库，如用于高性能 2D 和 3D 图形处理的 OpenGL ES。
+*   **原生 C/C++ 库**：该层包含用 C 和 C++ 编写的原生库，如用于高性能 2D 和 3D 图形处理的 OpenGL ES。
 *   **Java API 框架**：Android 的整个功能集可以通过 Java 编写的 API 提供给开发者。这些 API 是创建 Android 应用程序的构建块，例如：视图系统（用于应用程序 UI）、资源管理器（用于 I18N、图形、布局）、通知管理器（用于状态栏中的自定义警报）、活动管理器（用于管理应用程序生命周期）或内容提供商（启用应用程序从其他应用程序（如联系人等）访问数据）。
 *   **应用**：Android 自带一套核心应用，如手机、通讯录、浏览器等。此外，还可以从 Google Play（以前的 Android Market）下载和安装许多其他应用程序：