2020-05-20 16:13:21

docs/java/107.md

@@ -32,7 +32,7 @@ Table of Contents
 
 假设我们有`Employee`类。 雇员类具有组织中所有雇员必须具有的所有公共属性和方法。 也可以有其他专业员工，例如 `Manager`。 经理是组织的正式员工，但与其他员工相比，他们的属性却很少。 他们有报告人或下属。
 
-让我们设计以上课程。
+让我们设计以上类。
 
 ```java
 public class Employee 

docs/java/130.md

@@ -17,7 +17,7 @@ In this example, throttling will help in keeping the number of tasks in queue in
 
 ## 使用 CustomThreadPoolExecutor 和 RejectedExecutionHandler 的先前解决方案
 
-在此解决方案中，我们有以下课程：
+在此解决方案中，我们有以下类：
 
 **DemoTask.java**
 

docs/java/17.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/](https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/)
 
-在 *[面向对象](https://howtodoinjava.com/oops/object-oriented-principles/)* 范例中，类是编程的基本单位。 在本教程中，学习**编写 Java 类**和**如何在 Java 中创建对象**。
+在[*面向对象*](https://howtodoinjava.com/oops/object-oriented-principles/)范例中，类是编程的基本单位。 在本教程中，学习**编写 Java 类**和**如何在 Java 中创建对象**。
 
 ## 1\. 类与对象
 
@@ -24,8 +24,8 @@
 
 *   类声明可能具有**零个或多个修饰符**。
 *   关键字`class`用于声明一个类。
-*   < <类名称> >是该类的用户定义名称，应为有效标识符。
-*   每个类都有一个主体，该主体在一对大括号（{…}）中指定。
+*   `<<class name>>`是该类的用户定义名称，应为有效标识符。
+*   每个类都有一个主体，该主体在一对大括号（`{…}`）中指定。
 *   类的主体包含其不同的组件，例如字段，方法等。
 
 例如，
@@ -42,12 +42,12 @@ public class Main
 
 在 Java 中，可以有两种类型的类。
 
-1.  **抽象类**-这些类是`abstract`。 这些是**不完整的类**。 这意味着您无法创建此类的实例。 您只能扩展这些类以完成其规范。
-2.  **非抽象类** –这些类定义其完整状态和行为。 他们是完整的课程。 您可以创建此类的对象。
+1.  **抽象类** - 这些类是`abstract`。 这些是**不完整的类**。 这意味着您无法创建此类的实例。 您只能扩展这些类以完成其规范。
+2.  **非抽象类** – 这些类定义其完整状态和行为。 他们是完整的类。 您可以创建此类的对象。
 
 ## 3\. Java 类的渐进性
 
-在 Java 中，类用作**模板来创建对象**。 Java 中的类可能包含五个主要组件。 即
+在 Java 中，类用作**模板来创建对象**。 Java 中的类可能包含五个主要组件。 即：
 
 1.  领域
 2.  方法
@@ -76,7 +76,7 @@ public class Main
 
 ```
 
-假设“人类”类的每个对象都有两个属性：名称和性别。 人类类应该包括两个字段的声明：一个代表姓名，另一个代表性别。
+假设`Human`类的每个对象都有两个属性：名称和性别。 人类类应该包括两个字段的声明：一个代表姓名，另一个代表性别。
 
 ```java
 public class Human {
@@ -87,18 +87,18 @@ public class Human {
 
 ```
 
-Human 类在此处声明两个字段：名称和性别。 这两个字段均为`String`类型。 Human 类的每个实例（或对象）都将具有这两个字段的副本。
+`Human`类在此处声明两个字段：名称和性别。 这两个字段均为`String`类型。`Human`类的每个实例（或对象）都将具有这两个字段的副本。
 
 #### 3.2 方法
 
 Java 方法是语句的集合，这些语句被组合在一起以执行操作。 方法通常用于修改类字段的状态。 通过调用其他对象中的方法，方法也可以用于委派任务。
 
-在 Java 中，方法可以–
+在 Java 中，方法可以：
 
 *   接受零个或多个参数
-*   返回 void 或单个值
-*   重载–意味着我们可以定义多个具有相同名称但语法不同的方法
-*   被覆盖–意味着我们可以在父类和子类中使用相同的语法定义方法
+*   返回`void`或单个值
+*   重载 – 意味着我们可以定义多个具有相同名称但语法不同的方法
+*   被覆盖 – 意味着我们可以在父类和子类中使用相同的语法定义方法
 
 ```java
 public class Human {
@@ -126,12 +126,12 @@ public class Human {
 
 ```
 
-*   构造函数可以将其访问修饰符设为 public，private，protected 或 package 级别（无修饰符）。
+*   构造函数可以将其访问修饰符设为`public`，`private`，`protected`或包级别（无修饰符）。
 *   构造函数名称与类的简单名称相同。
 *   构造函数名称后跟一对左括号和右括号，其中可能包含参数。
-*   可选地，在右括号后面可以加上关键字 throws，而关键字 throws 之后是逗号分隔的异常列表。
+*   可选地，在右括号后面可以加上关键字`throws`，而关键字`throws`之后是逗号分隔的异常列表。
 *   与方法不同，构造函数没有返回类型。
-*   我们甚至不能将 void 指定为构造函数的返回类型。 如果有任何返回类型，则为方法。
+*   我们甚至不能将`void`指定为构造函数的返回类型。 如果有任何返回类型，则为方法。
 *   请记住，如果构造的名称与类的简单名称相同，则它可以是方法或构造函数。 如果指定返回类型，则为方法。 如果未指定返回类型，则为构造函数。
 
 #### 3.4 实例初始化块
@@ -155,8 +155,8 @@ public class Main
 *   一个类可以有多个实例初始化器。
 *   对于我们创建的每个对象，所有初始化程序都将按文本顺序自动执行。
 *   所有**实例初始化器的代码都在任何构造函数**之前执行。
-*   **实例初始化器不能具有 return 语句**。
-*   除非所有已声明的构造函数在其 throws 子句中列出那些已检查的异常，否则它不会抛出已检查的异常。
+*   **实例初始化器不能具有`return`语句**。
+*   除非所有已声明的构造函数在其`throws`子句中列出那些已检查的异常，否则它不会抛出已检查的异常。
 
 ```java
 public class Main {
@@ -193,7 +193,7 @@ Inside constructor
 *   我们可以在一个类中有多个静态初始化器。
 *   所有静态初始值设定项均按其出现的文本顺序执行，并在任何实例初始值设定项之前执行。
 
-静态初始化程序无法引发检查的异常。 它不能有一个 return 语句。
+静态初始化程序无法引发检查的异常。 它不能有一个`return`语句。
 
 ```java
 public class Main {
@@ -236,11 +236,11 @@ Human human = new Human();
 
 请记住，当我们不向类添加构造函数时，Java 编译器会为我们添加一个构造函数。 Java 编译器添加的构造函数称为**默认构造函数**。 默认构造函数不接受任何参数。 类的构造函数的名称与类的名称相同。
 
-在 new 运算符之后，将调用正在创建其实例的类的构造函数。 new 运算符通过在堆中分配内存来创建类的实例。
+在`new`运算符之后，将调用正在创建其实例的类的构造函数。`new`运算符通过在堆中分配内存来创建类的实例。
 
 ## 5\. `null`引用类型
 
-Java 具有称为`null`类型的特殊引用类型。 它没有名字。 因此，我们不能定义空引用类型的变量。 空引用类型只有 Java 定义的一个值，即**空文字**。 它只是 null。
+Java 具有称为`null`类型的特殊引用类型。 它没有名字。 因此，我们不能定义空引用类型的变量。 空引用类型只有 Java 定义的一个值，即**空字面值**。 它只是`null`。
 
 空引用类型是与任何其他引用类型兼容的分配。 也就是说，我们可以将空值分配给任何引用类型的变量。 实际上，存储在[引用类型](https://howtodoinjava.com/java/basics/data-types-in-java/)变量中的空值表示该引用变量没有引用任何对象。
 
@@ -252,7 +252,7 @@ john = new Human(); 	// Now, john is referring to a valid Human object
 
 ```
 
-请注意，null 是 null 类型的文字。 我们无法为[基本类型](https://howtodoinjava.com/java/basics/primitive-data-types-in-java/)变量分配 null，因此 Java 编译器不允许我们将基本值与 null 值进行比较。
+请注意，`null`是`null`类型的字面值。 我们无法为[基本类型](https://howtodoinjava.com/java/basics/primitive-data-types-in-java/)变量分配`null`，因此 Java 编译器不允许我们将基本值与`null`值进行比较。
 
 这是有关在 Java 中创建类的非常基础的教程的全部内容。
 

docs/java/18.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)
 
-[不变类](https://en.wikipedia.org/wiki/Immutable_object "immutable class")是其状态一旦创建便无法更改的类。 有某些准则可以**创建 Java** 中不可变的类。
+[不变类](https://en.wikipedia.org/wiki/Immutable_object)是其状态一旦创建便无法更改的类。 有某些准则可以**创建 Java** 中不可变的类。
 
 在这篇文章中，我们将重新审视这些准则。
 
@@ -19,27 +19,27 @@ Table of Contents
 
 Java 文档本身具有一些准则，这些准则可以确定[在此链接中编写不可变类](https://docs.oracle.com/javase/tutorial/essential/concurrency/imstrat.html "immutable classes")。 通过使用`Date`字段创建具有可变对象的不可变类，我们将理解这些准则的实际含义。
 
-1.  #### 不要提供“设置”方法-修改字段或字段引用的对象的方法。
+1.  #### 不要提供“设置”方法 - 修改字段或字段引用的对象的方法。
 
     该原则表明，对于您的类中的所有可变属性，请勿提供 setter 方法。 Setter 方法用于更改对象的状态，这是我们在此要避免的。
 
-2.  #### 将所有字段定为最终私有
+2.  #### 将所有字段定为`private final`
 
-    这是增加*不变性*的另一种方法。 声明为**私有**的字段将无法在课程之外访问，并且将它们设置为最终字段将确保即使您无意中也无法更改它们。
+    这是增加*不变性*的另一种方法。 声明为`private`的字段将无法在类之外访问，并且将它们设置为最终字段将确保即使您无意中也无法更改它们。
 
 3.  #### 不允许子类覆盖方法
 
-    最简单的方法是将该类声明为 ***final*** 。 Java 中的 final 类无法扩展。
+    最简单的方法是将该类声明为`final`。 Java 中的`final`类无法扩展。
 
 4.  #### 具有可变实例变量时要特别注意
 
     始终记住，实例变量将是**可变的**或**不可变的**。 标识它们并返回具有所有可变对象复制内容的新对象。 不变的变量可以安全地返回而无需额外的努力。
 
-    一种更复杂的方法是使构造函数 ***私有*** ，并在**工厂方法**中构造实例。
+    一种更复杂的方法是使构造函数`private`，并在**工厂方法**中构造实例。
 
 ## 2\. Java 不可变类示例
 
-让我们将以上所有规则应用于不可变类，并为 Java 中的**不可变类实现具体的类实现。**
+让我们将以上所有规则应用于不可变类，并为 Java 中的**不可变类实现具体的类实现**。
 
 ```java
 
@@ -115,7 +115,7 @@ public final class ImmutableClass
 
 ```
 
-现在该测试我们的课程了：
+现在该测试我们的类了：
 
 ```java
 
@@ -153,13 +153,13 @@ class TestMain
 
 除了您编写的类，JDK 本身还有很多不可变的类。 给出了这样的 Java 不可变类的列表。
 
-1.  串
-2.  包装器类，例如 Integer，Long，Double 等。
-3.  不可变的集合类，例如 Collections.singletonMap（）等。
-4.  java.lang.StackTraceElement
+1.  `String`
+2.  包装器类，例如`Integer`，`Long`，`Double`等。
+3.  不可变的集合类，例如`Collections.singletonMap()`等。
+4.  `java.lang.StackTraceElement`
 5.  Java 枚举（理想情况下应该如此）
-6.  java.util.Locale
-7.  java.util.UUID
+6.  `java.util.Locale`
+7.  `java.util.UUID`
 
 ## 3\. 使类不可变的好处
 
@@ -171,9 +171,9 @@ class TestMain
 4.  不需要克隆的实现
 5.  允许 [`hashCode()`](//howtodoinjava.com/java/related-concepts/working-with-hashcode-and-equals-methods-in-java/ "Working with hashCode and equals methods in java") 使用延迟初始化，并缓存其返回值
 6.  用作字段时不需要防御性地复制
-7.  制作好[映射键和 Set 元素](//howtodoinjava.com/java/collections/how-hashmap-works-in-java/ "How hashmap works in java")（在集合中这些对象不得更改状态）
+7.  作为良好的[映射和集合的键](//howtodoinjava.com/java/collections/how-hashmap-works-in-java/ "How hashmap works in java")（在集合中这些对象不得更改状态）
 8.  在构造时就建立了其类不变式，因此无需再次检查
-9.  始终具有“ **失败原子性**”（约书亚·布洛赫（Joshua Bloch）使用的术语）：如果不可变对象引发异常，则它永远不会处于不希望或不确定的状态
+9.  始终具有“**失败原子性**”（约书亚·布洛赫（Joshua Bloch）使用的术语）：如果不可变对象引发异常，则它永远不会处于不希望或不确定的状态
 
 ## 4\. 总结
 

docs/java/19.md

@@ -20,7 +20,7 @@ Table of Contents
 
 ## 1\. Java `main()`方法语法
 
-首先提醒一下 Java 中 main 方法的**语法。**
+首先提醒一下 Java 中`main`方法的**语法。**
 
 ```java
 public class Main 
@@ -35,7 +35,7 @@ public class Main
 
 ## 2\. 为什么 Java `main()`方法是公开的？
 
-这个大问题也许也是最困难的。 我尽力在我能获得的所有良好学习材料中找到找到此问题的一个很好的理由，但没有任何证据被证明是足够的。 因此，我的分析（与许多其他方法一样）说：**`main()`方法是公共的，因此可以在任何地方以及可能希望使用它启动应用程序**的每个对象中访问。 在这里，我并不是说 JDK / JRE 具有类似的原因，因为`java.exe`或`javaw.exe`（对于 Windows）使用 **Java 本机接口**（JNI）对`invoke`方法的调用，因此它们可以被调用 无论使用哪种访问修饰符，都可以采用这种方式。
+这个大问题也许也是最困难的。 我尽力在我能获得的所有良好学习材料中找到找到此问题的一个很好的理由，但没有任何证据被证明是足够的。 因此，我的分析（与许多其他方法一样）说：**`main()`方法是公共的，因此可以在任何地方以及可能希望使用它启动应用程序**的每个对象中访问。 在这里，我并不是说 JDK / JRE 具有类似的原因，因为`java.exe`或`javaw.exe`（对于 Windows）使用 **Java 本机接口**（JNI）对`invoke`方法的调用，因此无论使用哪种访问修饰符，它们都可以被调用。
 
 回答这个问题的第二种方法是另一个问题，为什么不公开？ Java 中的所有方法和构造函数都有一些访问修饰符。 `main()`方法也需要一个。 没有理由不应该将其设置为`public`，而应使用任何其他修饰符（默认/受保护/私有）。
 
@@ -62,7 +62,7 @@ Error: Main method not found in class Main, please define the main method as:
 
 ## 3\. 为什么 Java `main()`方法是静态的？
 
-另一个大问题。 为了理解这一点，假设我们没有 main 方法为`static`。 现在，要调用任何方法，您需要它的一个实例。 对？
+另一个大问题。 为了理解这一点，假设我们没有`main`方法为`static`。 现在，要调用任何方法，您需要它的一个实例。 对？
 
 **众所周知，Java 可以具有重载的构造函数。 现在，应该使用哪一个，重载的构造函数的参数将从何处来**。 这些只是更困难的问题，这些问题帮助 Java 设计人员下定了决心，并将`main()`方法设为`static`。
 
@@ -79,7 +79,7 @@ public class Main
 
 ```
 
-Program Output:
+程序输出：
 
 ```java
 Error: Main method is not static in class main, please define the main method as:
@@ -91,19 +91,19 @@ Error: Main method is not static in class main, please define the main method as
 
 为什么不应该无效？ 您是否从代码中调用过此方法？ 没有。 **因此，没有任何将值返回给实际调用此方法**的 JVM 的用途。 它根本不需要任何返回值。
 
-应用程序唯一想与调用过程进行通信的是正常终止还是异常终止。 使用`*System.exit(int)*`已经可以做到这一点。 非零值表示异常终止，否则一切正常。
+应用程序唯一想与调用过程进行通信的是正常终止还是异常终止。 使用`System.exit(int)`已经可以做到这一点。 非零值表示异常终止，否则一切正常。
 
 ## 5\. 为什么名字叫`main`？
 
-没有坚如磐石的理由。 假设因为**它已经与 C 和 C++语言**一起使用。 因此，大多数开发人员已经对这个名称感到满意。 否则，没有其他充分的理由。
+没有坚如磐石的理由。 假设因为**它已经与 C 和 C++ 语言**一起使用。 因此，大多数开发人员已经对这个名称感到满意。 否则，没有其他充分的理由。
 
 ## 6\. 调用`main`方法在内部会发生什么？
 
 Java 中`main()`方法的**用途是程序执行的起点。**
 
-当您运行`java.exe`，然后运行**时，有几个 Java 本机接口（JNI）调用**。 这些调用会加载真正是 JVM 的 DLL（是的-`java.exe`不是 JVM）。 JNI 是我们在虚拟机世界和 C，C++等世界之间架起桥梁时所使用的工具。反之亦然。 如果不使用 JNI，就不可能真正使 JVM 运行。
+当您运行`java.exe`，然后运行**时，有几个 Java 本机接口（JNI）调用**。 这些调用会加载真正是 JVM 的 DLL（是的-`java.exe`不是 JVM）。 JNI 是我们在虚拟机世界和 C，C++ 等世界之间架起桥梁时所使用的工具。反之亦然。 如果不使用 JNI，就不可能真正使 JVM 运行。
 
-基本上，`java.exe`是一个超级简单的 C 应用程序，**解析命令行**，**在 JVM 中创建一个新的 String 数组**来保存这些参数，**解析出类名 您指定为包含`main()`的**，**使用 JNI 调用来查找 main（）**方法本身，然后**调用 main（）**方法，传入新创建的字符串 数组作为参数。
+基本上，`java.exe`是一个超级简单的 C 应用程序，解析命令行，在 JVM 中创建一个新的`String`数组来保存这些参数，解析出您指定来包含`main()`的类名，使用 JNI 调用来查找`main()`方法本身，然后调用`main()`方法，传入新创建的字符串数组作为参数。
 
 这非常类似于使用 Java 反射时的操作，只是使用了令人困惑的命名本机函数调用。
 
@@ -148,11 +148,11 @@ goto leave;
 
 ```
 
-因此，在这里您可以看到**用主方法**调用 Java 程序时会发生什么。
+因此，在这里您可以看到**用`main`方法**调用 Java 程序时会发生什么。
 
 ## 8\. 我们是否总是需要`main`方法来运行 Java 程序？
 
-我相信不是。 我们有 applet，在这里我们没有编写 main 方法。 我仍然需要检查它们是如何执行的。 如果您已经知道，请与我分享。
+我相信不是。 我们有 applet，在这里我们没有编写`main`方法。 我仍然需要检查它们是如何执行的。 如果您已经知道，请与我分享。
 
 ## 9\. 总结
 

docs/java/20.md

@@ -2,11 +2,11 @@
 
 > 原文： [https://howtodoinjava.com/java/basics/java-comments/](https://howtodoinjava.com/java/basics/java-comments/)
 
-了解有关 **Java 注释**，**类型的 Java 注释**， **Javadoc** 工具，**注释的性能影响**和**最佳做法**的所有信息 ] 跟随。
+了解有关 **Java 注释**，**Java 注释的类型**， **Javadoc** 工具，**注释的性能影响**和需要遵循的**最佳做法**的所有信息。
 
 ## 1\. 为什么要编写 Java 注释？
 
-顾名思义， [Java](https://howtodoinjava.com/java/basics/what-is-java-programming-language/) 注释是出于各种原因在程序之间编写的注释。 例如，您可以将注释写给–
+顾名思义， [Java](https://howtodoinjava.com/java/basics/what-is-java-programming-language/) 注释是出于各种原因在程序之间编写的注释。 例如，您可以将注释写给：
 
 *   编写有关变量，方法，类或任何语句的信息或说明。
 *   编写可在 Java 文档中使用的文本。
@@ -89,7 +89,7 @@ Java 中有 **3 种类型的注释。**
 
     > 文档注释以`/**`开头，以`*/`结尾。
 
-    您可以在这些注释中使用 **javadoc 批注**，例如 `@param`和`@return`。
+    您可以在这些注释中使用 **javadoc 注解**，例如 `@param`和`@return`。
 
     ```java
     /**
@@ -109,11 +109,11 @@ Java 中有 **3 种类型的注释。**
 
 ## 3\. 注释快捷方式
 
-在 Eclipse IDE 中，只需在公共方法或类之前键入**“ / ** [Enter]”** ，它将自动在所有必要的`@param`，`@author`和`@return`属性中生成。
+在 Eclipse IDE 中，只需在公共方法或类之前键入`/**[Enter]`，它将自动在所有必要的`@param`，`@author`和`@return`属性中生成。
 
 ![Java Comment shortcut in eclipse](img/1265b8d929bc6c71664f1e29fa450018.png)
 
-Eclipse 中的 Java Comment 快捷方式
+Eclipse 中的 Java 注释快捷方式
 
 ## 4\. `javadoc`实用程序
 
@@ -121,7 +121,7 @@ Eclipse 中的 Java Comment 快捷方式
 
 #### 4.1 从命令提示符运行`javadoc`
 
-首先，确保`javadoc`实用程序位于**路径**中。 如果没有，则将 **JDK / bin** 文件夹添加到 PATH 变量。
+首先，确保`javadoc`实用程序位于**路径**中。 如果没有，则将 JDK `/bin`文件夹添加到`PATH`变量。
 
 ```java
 $ set PATH=.;C:\BAML\DFCCUI\installs\jdk1.8.0_31\bin
@@ -146,13 +146,13 @@ $ javadoc -d C:/temp Main.java
 您也可以从 Eclipse IDE 生成 Java 文档。 遵循以下简单步骤：
 
 1.  在**程序包浏览器**中，右键单击所需的项目/程序包。
-2.  Select `**Export.../Javadoc**` and click `Next`.
+2.  选择`Export.../Javadoc`并点击`Next`.
 
     ![Export Java Doc Option](img/a85bc7cb53271d68dee5948672f46e33.png)
 
     导出 Java 文档选项
 
-3.  By default, the entire source code will be selected. Verify and change your selections.
+3.  默认情况下，将选择整个源代码。 验证并更改您的选择。
 
     ![Java Doc Options in Eclipse](img/05867d3a1d3f6b862f8ca90f023c248c.png)
 
@@ -185,4 +185,5 @@ Java 代码中的实现注释仅供人们阅读。 Java 注释是编译器未编
 阅读更多：
 
 [Oracle 针对 Javadoc 的建议](http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html)
+
 [Javadoc 标记参考](https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#javadoctags)
\ No newline at end of file

docs/java/203.md

@@ -65,7 +65,7 @@ private static final TemporalQuery<Integer> CurrentQuarterQuery = temporal -> {
 
 ```
 
-Program output:
+程序输出：
 
 ```java
 Current Financial Quarter :: 2

docs/java/228.md

@@ -47,7 +47,7 @@ Table of contents
 
 serialVersionUID 是`Serializable`类的通用版本标识符。 反序列化使用此数字来确保已加载的类与序列化的对象完全对应。 如果找不到匹配项，则抛出 **InvalidClassException** 。
 
-1.  **始终将其包含为字段**，例如：“ private static final long serialVersionUID = 7526472295622776147L; ”，即使在课程的第一个版本中也要包含此字段，以提醒其重要性。
+1.  **始终将其包含为字段**，例如：“ private static final long serialVersionUID = 7526472295622776147L; ”，即使在类的第一个版本中也要包含此字段，以提醒其重要性。
 2.  **请勿在以后的版本中更改此字段的值，除非您有意对类进行**更改，以使其与旧的序列化对象不兼容。 如果需要，请遵循上述给定的准则。
 
 ## 4\. readObject 和 writeObject 方法

docs/java/56.md

@@ -278,7 +278,7 @@ JAR content root
 
 ## `@Deprecated`的标签更改
 
-从 Java 9 开始， [@Deprecated](http://download.java.net/java/jdk9/docs/api/java/lang/Deprecated.html) 批注将具有两个属性，即`forRemoval`和`since`。
+从 Java 9 开始， [@Deprecated](http://download.java.net/java/jdk9/docs/api/java/lang/Deprecated.html) 注解将具有两个属性，即`forRemoval`和`since`。
 
 1.  *forRemoval* –指示带注释的元素是否在将来的版本中会被删除。
 2.  从开始的 *–它返回已弃用带注释元素的版本。*

docs/java/65.md

@@ -187,7 +187,7 @@ duration = Duration.ofMinutes(10);
 
 ```
 
-`Duration`处理较小的时间单位，例如毫秒，秒，分钟和小时。 它们更适合与应用程序代码进行交互。 要与人互动，您需要使**的持续时间更长**，该课程与`Period`类一起提供。
+`Duration`处理较小的时间单位，例如毫秒，秒，分钟和小时。 它们更适合与应用程序代码进行交互。 要与人互动，您需要使**的持续时间更长**，该类与`Period`类一起提供。
 
 ```java
 Period period = Period.ofDays(6);

docs/java/70.md

@@ -60,7 +60,7 @@ multiple non-overriding abstract methods found in interface MyFirstFunctionalInt
 
 以下是功能界面中允许和不允许的事物的列表。
 
-*   如上所述， ***在任何功能接口中仅允许使用一种抽象方法*** 。 在功能接口中不允许使用第二种抽象方法。 如果删除 **@FunctionInterface** 批注，则可以添加另一个抽象方法，但是它将使该接口成为非功能性接口。
+*   如上所述， ***在任何功能接口中仅允许使用一种抽象方法*** 。 在功能接口中不允许使用第二种抽象方法。 如果删除 **@FunctionInterface** 注解，则可以添加另一个抽象方法，但是它将使该接口成为非功能性接口。
 *   即使`@FunctionalInterface`注释将被省略 ，功能接口也是 ***有效。 它仅用于通知编译器在接口内部强制使用单个[抽象方法](//howtodoinjava.com/object-oriented/exploring-interfaces-and-abstract-classes-in-java/ "Exploring interfaces and abstract classes in java")。***
 *   Conceptually, a functional interface has exactly one abstract method. Since [**default methods**](//howtodoinjava.com/java8/default-methods-in-java-8/ "Default methods in java 8") have an implementation, they are not abstract. Since default methods are not abstract you’re ***free to add default methods to your functional interface as many as you like***.