2020-06-23 10:45:30

docs/10.md

@@ -6,15 +6,15 @@
 
 ## 创建项目
 
-要创建我们的项目，请从菜单中选择 ***文件> >新建> > Java Project*** 。 如果找不到“Java 项目”作为选项，请单击“其他”，如下所示。
+要创建我们的项目，请从菜单中选择“**文件 -> 新建 -> Java 项目**”。 如果找不到“Java 项目”作为选项，请单击“其他”，如下所示。
 
 ![1](img/e7d9fc1772e8c1c27fcf36aefc4041bf.png)
 
-从下一个窗口中选择 Java 项目，然后单击 ***下一步*** 。 提供一个项目名称，如下所示。
+从下一个窗口中选择 Java 项目，然后单击“**下一步**”。 提供一个项目名称，如下所示。
 
 ![3](img/32b060afa9b923ccc6971614ca91eaea.png)
 
-单击 ***完成*** 。 Eclipse 将要求您将透视图更改为 Java Perspective。 单击是。 如您所见，一个新的 Java 项目将出现在 **Java Perspective** 的 **Package Explorer 视图**中。
+单击“**完成**”。 Eclipse 将要求您将透视图更改为 Java 视图。 单击是。 如您所见，一个新的 Java 项目将出现“**Java 视图**”的“**包浏览器视图**”中。
 
 ![4](img/a9ce9baa74bb4e80e4361fe07fe5155f.png)
 
@@ -22,7 +22,7 @@
 
 现在，我们将为我们的 Java 项目创建一个程序包。 **包**用于避免*命名冲突*，以便*控制访问*（访问修饰符）和*来捆绑相关类型*的组。
 
-要创建包，请在 Java 项目（`JBTProject`）中选择`src`文件夹，右键单击该文件夹并选择 ***新的> >包*** 。
+要创建包，请在 Java 项目（`JBTProject`）中选择`src`文件夹，右键单击该文件夹并选择“**新建 -> 包**”。
 
 ![6](img/4b5ed46224997e82dcb1c4ebc6955164.png)
 
@@ -30,7 +30,7 @@
 
 ## 创建 Java 类的步骤
 
-创建包后，我们可以在包内创建 Java 类。 右键单击要在其中创建 Java 类的包，然后选择 ***新> >类。*** 
+创建包后，我们可以在包内创建 Java 类。 右键单击要在其中创建 Java 类的包，然后选择“**新建 -> 类**”。
 
 ![7](img/6d4e87c0b4ff2d17e794eb61e35da4e9.png)
 
@@ -48,15 +48,15 @@
 
 ### 编译代码
 
-要编译代码，请使用键盘快捷键`CTRL + B`。 它将构建 Java 应用。 如果要构建单个应用，请单击该应用，然后从菜单中选择 ***项目> >构建项目*** 。
+要编译代码，请使用键盘快捷键`CTRL + B`。 它将构建 Java 应用。 如果要构建单个应用，请单击该应用，然后从菜单中选择“**项目 -> 构建项目**”。
 
 ### 运行代码
 
 要运行代码，您可以使用键盘快捷键`ALT + SHIFT + X`和`J`。
 
-或者，您可以单击文件，然后从菜单中选择 ***运行> >运行为> > Java 应用*** 。
+或者，您可以单击文件，然后从菜单中选择 ***运行 -> 运行为 -> Java 应用*** 。
 
-单击“运行”后，将执行 Hello World 应用，并且您的输出将显示在 ***控制台视图*** 中。
+单击“运行”后，将执行 Hello World 应用，并且您的输出将显示在“**控制台视图**”中。
 
 现在我们已经学会了在 Eclipse 中创建 Hello World 应用。 在下一篇文章中，我们将讨论 Eclipse 提供的一些其他功能，这些功能使编码更容易。
 

docs/12.md

@@ -68,11 +68,11 @@ Java 中的类只能使用`public`和默认访问修饰符。
 
 ## 变量的 Java 访问修饰符表
 
-| **Visibility** | **Public Access Modifier** | **专用访问修饰符** | **受保护的访问修饰符** | **Default Access Modifier** |
-| **在同一个类别中** | Yes | Yes | Yes | Yes |
-| **来自同一包装中的任何类别** | Yes | No | Yes | Yes |
+| **可见性** | **公共访问修饰符** | **私有访问修饰符** | **受保护的访问修饰符** | **默认访问修饰符** |
+| **在同一个类中** | Yes | Yes | Yes | Yes |
+| **来自同一包装中的任何类** | Yes | No | Yes | Yes |
 | **来自同一包中的任何子类** | Yes | No | Yes | Yes |
-| **来自不同程序包**的任何子类 | Yes | No | Yes（**仅通过继承**） | No |
+| **来自不同程序包的任何子类** | Yes | No | Yes（**仅通过继承**） | No |
 | **来自不同包装中的任何非子类** | Yes | No | No | No |
 
 ## 方法的访问修饰符
@@ -83,28 +83,28 @@ Java 中的类只能使用`public`和默认访问修饰符。
 
 当“方法”设置为默认值时，同一包中定义的类将可以访问该方法。 在同一包中定义的任何类中的任何方法都可以访问给定的方法或**继承**或**直接访问**。
 
-### 上市
+### `public`
 
 将方法设置为`public`时，可以从 Java 世界中可用的任何类中访问它。 任何类中的任何方法都可以访问或**继承**或**直接访问**的给定方法，具体取决于类级别的访问。
 
-**受保护的**
+`protected`
 
 如果将方法设置为在类内部进行保护，则可以从在相同或不同包中定义的子类访问该方法。
 
 > 受保护的访问权限和默认访问权限之间的唯一区别是受保护的访问修饰符遵守**的类-子类关系**，而默认的则不这样做。
 
-**私人**
+`private`
 
 只能从定义其的类内部访问定义为私有的方法。 此类方法无法从已定义的类外部访问，甚至不能从其子类访问。
 
 ## 方法的 Java 访问修饰符表
 
-| **Visibility** | **Public Access Modifier** | **Private Access Modifier** | **Protected Access Modifier** | **Default Access Modifier** |
-| **Within Same Class** | Yes | Yes | Yes | Yes |
-| **来自同一包中的任何类别** | Yes | No | Yes | Yes |
+| **可见性** | **公共访问修饰符** | **私有访问修饰符** | **受保护访问修饰符** | **默认访问修饰符** |
+| **相同类中** | Yes | Yes | Yes | Yes |
+| **来自同一包中的任何类** | Yes | No | Yes | Yes |
 | **来自同一包中的任何子类** | Yes | No | Yes | Yes |
-| **From Any Sub Class from Different Package** | Yes | No | Yes(**Only By Inheritance**) | No |
-| **From Any Non-Sub Class in Different Package** | Yes | No | No | No |
+| **来自不同程序包的任何子类** | Yes | No | Yes（**仅通过继承**） | No |
+| **来自不同包装中的任何非子类** | Yes | No | No | No |
 
 ## 局部变量的访问修饰符
 

docs/15.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-arithmetic-operator/](https://javabeginnerstutorial.com/core-java-tutorial/java-arithmetic-operator/)
 
-在本节中，我们将学习**算术**，**运算符**，**优先级**和**运算符关联** *。*
+在本节中，我们将学习**算术**，**运算符**，**优先级**和**运算符关联**。
 
 ## 运算符优先级
 
@@ -65,7 +65,7 @@ class OperatorPrecedenceExample {
 
 ## 运算符关联
 
-如果两个运算符在计算中具有相同的优先级，则将使用运算符的 ***关联性*** 来决定首先执行哪个运算符。
+如果两个运算符在计算中具有相同的优先级，则将使用运算符的**关联性**来决定首先执行哪个运算符。
 
 ## 关联性示例
 

docs/16.md

@@ -73,7 +73,7 @@ public class if_condition {
 
 ### 否则为
 
-如果条件为的情况为**，否则为**，而另一个的情况为*。 如果条件*为真，则它仅包含*才执行的代码的一部分，如果条件*为假，则将执行该代码的其他部分**。 *`if else`语句*** 仅采用***布尔表达式作为***有效条件。
+`if-else if`语句含有多个`if`条件和`else`语句。如果条件为真，包含的代码会被执行，如果条件为假，则将检查下一个条件。 如果下一个`if`条件为`true`，则将执行包含的代码，否则将执行代码的`else`部分。 `if else if`语句仅采用***布尔表达式作为***有效条件。
 
 > 与其他语言不同，java 不接受数字作为条件运算符。 它仅将*布尔表达式*视为返回`TRUE`或`FALSE`的条件。
 > 例如，`if(1 == 1)`被接受，因为它是布尔表达式，将返回`true`。 `if(x = 1)`语句在 Java 中是不允许的。
@@ -131,7 +131,8 @@ String is not Hi
 `if-else if`语句由多个`if`条件和`else`语句组成。 如果*条件*为真，则将执行随附的代码。 如果*如果条件*为假，则它将检查下一个`if`条件。如果条件为下一个下一个*，则将执行附带的代码，否则将执行代码的`else`部分。 `If Else If `语句仅将***布尔表达式***视为有效条件。
 
 > 与其他语言不同，Java 不接受数字作为条件运算符。 它仅将*布尔表达式*视为返回`TRUE`或`FALSE`的条件。
-> **例如**`if(x = 1)`不允许，而`if(1 == 1)`*被接受，因为它是布尔表达式 并将返回`true`。
+> 
+> **例如**`if(x = 1)`不允许，而`if(1 == 1)`被接受，因为它是布尔表达式 并将返回`true`。
 
 #### `if-else if`语句语法
 

docs/23.md

@@ -43,7 +43,7 @@ Java 中的变量可以在代码中的任何位置定义（*在类*旁，*在方
 
 ### 实例变量（非静态字段）
 
-对象使用实例变量存储其状态。 在没有方法声明的情况下未使用`STATIC`关键字定义的变量*是特定于对象的，称为实例变量。 这样的变量称为实例变量，因为它们的值是实例特定的，并且这些变量的值是实例之间共享的 ***而不是*** 。 有关更多详细信息，请转到[实例变量](https://javabeginnerstutorial.com/core-java-tutorial/instance-variable-java/)主题。*
+对象使用实例变量存储其状态。 在没有方法声明的情况下未使用`STATIC`关键字定义的变量是特定于对象的，称为实例变量。 这样的变量称为实例变量，因为它们的值是实例特定的，***而不是***是实例之间共享的。 有关更多详细信息，请转到[实例变量](https://javabeginnerstutorial.com/core-java-tutorial/instance-variable-java/)主题。
 
 ### 类变量（静态字段）
 

docs/24.md

@@ -7,7 +7,7 @@
 ## 局部变量规则
 
 *   局部变量不能使用任何[访问级别](https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/ "Access Modifiers in Java")，因为它的范围仅在方法内部。
-*   ***最终*** 是唯一可以应用于局部变量的[非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")。
+*   `final`是唯一可以应用于局部变量的[非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")。
 *   局部变量未分配默认值，因此需要对其进行初始化。
 
 ## 局部变量的例子

docs/25.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/instance-variable-java/](https://javabeginnerstutorial.com/core-java-tutorial/instance-variable-java/)
 
-对象使用 Java 中的实例变量存储其状态。 没有使用**`STATIC`关键字定义的变量，并且在任何方法声明之外的*都是特定于对象的，称为实例变量。 之所以这样称呼它们，是因为它们的值特定于实例，***而不是***在实例之间共享。
+对象使用 Java 中的实例变量存储其状态。 没有使用`STATIC`关键字定义的变量，并且在任何方法声明之外的都是特定于对象的，称为实例变量。 之所以这样称呼它们，是因为它们的值特定于实例，***而不是***在实例之间共享。
 
 ## 实例变量示例
 

docs/27.md

-# 可变阴影
+# 变量覆盖
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/variable-shadowing/](https://javabeginnerstutorial.com/core-java-tutorial/variable-shadowing/)
 
-今天，我们将探讨 Java 的一项罕见功能**：变量阴影**
+今天，我们将探讨 Java 的一项罕见功能：**变量覆盖**
 
-首先，让我们定义什么是阴影字段或方法：
+首先，让我们定义什么是覆盖字段或方法：
 
 当**被遮盖**时，该字段被视为
 
@@ -12,7 +12,7 @@
 *   在本地范围内声明具有相同名称和类型的变量
 *   用相同名称和类型声明方法参数/参数
 
-## 局部变量阴影
+## 局部变量覆盖
 
 ```java
 public class MyClass
@@ -36,9 +36,9 @@ public class MyClass
 
 上面的代码将输出
 
-> 计数= 5
+> `count=5`
 
-因为在**第 7 行**中声明的*计数* **局部变量**遮盖了在类级别声明的变量*计数*。 如果要访问实例变量，则需要添加**这个**关键字。
+因为在**第 7 行**中声明的`count`**局部变量**遮盖了在类级别声明的变量*计数*。 如果要访问实例变量，则需要添加`this`关键字。
 
 ```java
 private void localVariable()
@@ -49,7 +49,7 @@ private void localVariable()
 }
 ```
 
-## 方法参数阴影
+## 方法参数覆盖
 
 即使我们对此不太关注，这种情况也很常见。 下面是一个简单的 getter 定义
 
@@ -98,13 +98,13 @@ public class ChildClass extends SuperClass
 
 执行给出：
 
-> 值= SUPER_VAL
+> `value = SUPER_VAL`
 
-在**超级类**中声明了 *val* 字段，但在 **ChildClass** 中被遮盖了 ]，因为后者声明了另一个具有相同**名称和类型**的字段。 尽管已使用“ CHILD_VAL”实例化了 **ChildClass** ，但执行 *child.display（）*却给您“ SUPER_VAL”。
+在`SuperClass`中声明了`val`字段，但在`ChildClass`中被遮盖了，因为后者声明了另一个具有相同**名称和类型**的字段。 尽管已使用`CHILD_VAL`实例化了`ChildClass`，但执行`child.display()`却给您`SUPER_VAL`。
 
-原因很简单。 创建子实例时，有 2 个变量 *val* 。 通过构造器，来自 **SuperClass** 的一个具有值“ SUPER_VAL”，来自 **ChildClass** 的一个具有注入值“ CHILD_VAL”。
+原因很简单。 创建子实例时，有 2 个变量`val`。 通过构造器，来自`SuperClass`的一个具有值`SUPER_VAL`，来自`ChildClass`的一个具有注入值`CHILD_VAL`。
 
-调用 *display（）*方法时，由于它是在**超类**中定义的，因此它是超类的**上下文中的 *val* 字段。 ]。 输出显示“ SUPER_VAL”也就不足为奇了。**
+调用`display()`方法时，由于它是在**超类**中定义的，因此它是超类的**上下文**中的`val`字段。输出显示`SUPER_VAL`也就不足为奇了。
 
 ```java
 public class ChildClass extends SuperClass
@@ -125,9 +125,9 @@ public class ChildClass extends SuperClass
 }
 ```
 
-在上面修改的代码中，我们将 **SuperClass** 中隐藏的 *val* 字段的值强制为 *super.val =值*，输出给出：
+在上面修改的代码中，我们将`SuperClass`中隐藏的`val`字段的值强制为`super.val = value`，输出给出：
 
-> 值= CHILD_VAL
+> `value = CHILD_VAL`
 
 现在让我们在层次结构中添加另一个类
 
@@ -161,11 +161,11 @@ public class ChildClass extends SuperClass
 
 显然，输出将显示
 
-> val = SUPER_VAL
+> `val = SUPER_VAL`
 
-现在的问题是：如果要显示祖先类的 *val* 值，该怎么办？ 显然，仅**超级**关键字引用了类层次结构中的第一个父类。
+现在的问题是：如果要显示祖先类的`val`值，该怎么办？ 显然，仅`super`关键字引用了类层次结构中的第一个父类。
 
-救援人员来了。 实际上，我们可以将代表当前类实例的**关键字强制**应用于类层次结构中的特定类型！****
+救援人员来了。 实际上，我们可以将代表当前类实例的**关键字强制**应用于类层次结构中的特定类型！
 
 ```java
 public class ChildClass extends SuperClass

docs/29.md

@@ -11,7 +11,7 @@ Java for 循环和增强的 for 循环是一种控制流语句，它提供了一
 
 ## for 循环
 
-for 循环是 3 个表达式的组合，需要理解才能有效地将 ***用于循环*** 。
+for 循环是 3 个表达式的组合，需要理解才能有效地将其***用于循环***。
 
 *   *初始化* 表达式初始化循环； 它会在循环开始时执行一次。
 *   *终止表达式*用于停止循环。 每次迭代都会对它进行评估，并且当*终止*表达式的评估结果为`false`时，循环终止。
@@ -20,7 +20,7 @@ for 循环是 3 个表达式的组合，需要理解才能有效地将 ***用于
 ### 循环的*语法*
 
 ```java
-for(**Initialization**; **Termination**; **Increment/ Decrement**){
+for(Initialization; Termination; Increment/Decrement){
               //Code to execute in loop
          }
 ```
@@ -64,9 +64,9 @@ Value of k: 10
 Value of k: 11
 ```
 
-这里的代码在初始化表达式中声明了一个 int 变量 ***i*** 。 变量 ***i*** 的范围从其声明扩展到 for 语句块的末尾，因此它也可以在终止和增量表达式中使用。
+这里的代码在初始化表达式中声明了一个 int 变量`i`。 变量`i`的范围从其声明扩展到 for 语句块的末尾，因此它也可以在终止和增量表达式中使用。
 
-如果循环外不需要控制`for`语句的变量，则最好在初始化表达式中声明该变量。 如您在使用 ***i*** int 变量的第一个`for loop`中所看到的。 在初始化表达式中声明它们会限制它们的寿命并减少错误。
+如果循环外不需要控制`for`语句的变量，则最好在初始化表达式中声明该变量。 如您在使用`int i`变量的第一个`for`循环中所看到的。 在初始化表达式中声明它们会限制它们的寿命并减少错误。
 
 名称`i`，`j`和`k`通常用于控制`for`循环。
 
@@ -125,7 +125,7 @@ Hello Hi How are you?
 Hello Hi How are you?
 ```
 
-增强了循环**遍历给定集合或数组中的每个对象**，**将**存储在变量中 （obj）和**执行**循环的主体。
+增强了循环**遍历给定集合或数组中的每个对象**，**将**对象存储在变量中和**执行**循环的主体。
 
 > 建议尽可能使用增强的 for 循环。
 

docs/38.md

@@ -17,7 +17,7 @@ Java 继承定义了超类及其子类之间的 is-a 关系。 这意味着只
 
 这两个关键字 super 和 super 帮助您显式命名所需的字段或方法。 使用此关键字和超级关键字，您可以完全控制是否要调用同一类中的方法或字段，还是要从直接父类中调用。 ***此*** 关键字用作对作为当前 Class 实例的当前 Object 的引用。 super 关键字还引用当前的 Object，但作为当前类的超类的实例。
 
-***此*** 关键字引用当前对象，在局部变量隐藏或阴影相同名称的字段的情况下很有用。 如果某个方法需要将当前对象传递给另一个方法，则可以使用此引用进行传递。 注意，该引用不能在静态上下文中使用，因为在任何 Object 的上下文中都不会执行静态代码。
+***此*** 关键字引用当前对象，在局部变量隐藏或覆盖相同名称的字段的情况下很有用。 如果某个方法需要将当前对象传递给另一个方法，则可以使用此引用进行传递。 注意，该引用不能在静态上下文中使用，因为在任何 Object 的上下文中都不会执行静态代码。
 
 ## Java 继承备忘单
 

docs/55.md

@@ -56,7 +56,7 @@ Last Name of Employee: null
 
 ## 类层次结构和可序列化
 
-在这里，我将讨论 Serializable 接口对类层次结构的影响。 如果一个类实现了 Serializable 接口，则可以保存该类的状态。 但是，如果同一类扩展了另一个未实现可序列化接口的类，则不会保存超级类的状态。
+在这里，我将讨论 Serializable 接口对类层次结构的影响。 如果一个类实现了 Serializable 接口，则可以保存该类的状态。 但是，如果同一类扩展了另一个未实现可序列化接口的类，则不会保存超类的状态。
 
 为了了解区别，我们将更新原始的 Employee 类。 现在，该类将扩展另一个类 *superEmployee* 。 该超类将不会实现 Serializable 接口。
 

docs/74.md

@@ -33,7 +33,7 @@ Java ClassLoader 可以分为 4 种类型。
 
 ### Bootstrap 类加载器
 
-它是超级类加载器。 它没有任何父类 ClassLoader。 它将 Java 的核心类（如 java.lang，java.util 包中的类）加载。
+它是超类加载器。 它没有任何父类 ClassLoader。 它将 Java 的核心类（如 java.lang，java.util 包中的类）加载。
 
 ### 扩展类加载器
 

docs/8.md

@@ -17,7 +17,7 @@
 
 **`SUPER_CLASS_NAME`**：给定类扩展的类的名称。 （为此使用 `extends`关键字）
 
-**`INTERFACE_NAME`**：以上类实现的接口的名称。 `（implements`关键字用于此目的）
+**`INTERFACE_NAME`**：以上类实现的接口的名称。 （`implements`关键字用于此目的）
 
 ## 类的内部结构
 

docs/9.md

@@ -115,15 +115,15 @@ This is in method
 
 类中的构造器必须与给定的类具有相同的名称。 构造器的语法 *不包含返回类型* ，因为构造器从不返回值。 构造器还可以包括各种类型的参数。 使用`new`运算符调用构造器时，类型必须与构造器定义中指定的类型匹配。
 
-如果未提供显式构造器，则 Java 提供一个*默认构造器*，其中**不带*参数*** 并且不执行任何特殊操作或初始化。 隐式默认构造器执行的唯一操作是使用`super()`调用来调用超类构造器。
+如果未提供显式构造器，则 Java 提供一个*默认构造器*，其中**不带参数**并且不执行任何特殊操作或初始化。 隐式默认构造器执行的唯一操作是使用`super()`调用来调用超类构造器。
 
 ## Java 构造器规则
 
 *   构造器**不能**具有**返回类型**。
 *   构造器**必须**与类具有相同的名称。
-*   构造器**无法标记为**静态****
-*   构造器**不能标记为**抽象****
-*   构造器**不能**被**覆盖。**
+*   构造器**无法标记为静态**
+*   构造器**不能标记为抽象**
+*   构造器**不能**被**覆盖**。
 *   构造器**不能**是最终的。
 
 > 如果类定义了显式构造器，则它不再具有默认的构造器来设置对象的状态。 如果此类需要默认构造器（不带参数的构造器），则必须提供其实现。
@@ -138,7 +138,7 @@ This is in method
 
 ## 构造器链接：
 
-**每个构造器中都包含一个隐式`super()`调用，该调用不包含`this()`或显式`super()`调用作为第一个调用语句。** `super()`语句用于调用超类的构造器。
+**每个构造器中都包含一个隐式`super()`调用，该构造器不包含`this()`或显式`super()`调用作为第一个调用语句。** `super()`语句用于调用超类的构造器。
 
 隐式`super()`可以由显式`super()`代替。 超级语句必须是构造器的第一条语句。 显式超类允许将参数值传递给其超类的构造器，并且必须具有匹配的参数类型。 子类的构造器中的`super()`调用将基于调用的签名，导致超类中相关构造器的调用。 这称为构造器链接。