2019-08-09 15:31:18

docs/java/41.md

-# 尝试使用 Catch in Java - 异常处理
+# Java 中的`try-catch` - 异常处理
 
 > 原文： [https://beginnersbook.com/2013/04/try-catch-in-java/](https://beginnersbook.com/2013/04/try-catch-in-java/)
 
 在[上一篇教程](https://beginnersbook.com/2013/04/java-exception-handling/)中，我们讨论了什么是异常处理以及我们为什么这样做。在本教程中，我们将看到用于异常处理的 try-catch 块。
 
-## 尝试阻止
+## `try`块
 
 try 块包含可以发生异常的一组语句。 try 块后面总是跟一个 catch 块，它处理相关 try 块中发生的异常。 try 块必须后跟 catch 块或最后是 block 或两者。
 
-### try 块的语法
+### `try`块的语法
 
 ```java
 try{
@@ -18,11 +18,11 @@ try{
 
 > 在编写程序时，如果您认为程序中的某些语句可以抛出异常，请将它们包含在 try 块中并处理该异常
 
-## 抓住块
+## `catch`块
 
 catch 块是处理异常的地方，此块必须遵循 try 块。单个 try 块可以有几个与之关联的 catch 块。您可以在不同的 catch 块中捕获不同的异常。当 try 块中发生异常时，将执行处理该特定异常的相应 catch 块。例如，如果在 try 块中发生算术异常，则执行 catch 块中用于算术异常的语句。
 
-### java 中 try catch 的语法
+### java 中`try-catch`的语法
 
 ```java
 try
@@ -35,7 +35,7 @@ catch (exception(type) e(object))‏
 }
 ```
 
-## 示例：尝试 catch 块
+## 示例：`try-catch`块
 
 如果 try 块中发生异常，则执行控制将传递给相应的 catch 块。单个 try 块可以有多个与之关联的 catch 块，您应该放置 catch 块，使得通用异常处理程序 catch 块位于最后（参见下面的示例）。
 通用异常处理程序可以处理所有异常但是你应该放在最后，如果你把它放在所有 catch 块之前，那么它将显示通用消息。您始终希望为每种类型的异常提供有意义的消息，而不是通用消息。
@@ -80,7 +80,7 @@ I'm out of try-catch block in Java.
 
 ```
 
-## Java 中的多个 catch 块
+## Java 中的多个`catch`块
 
 我们在上面看到的示例是有多个 catch 块，让我们在示例的帮助下看到关于多个 catch 块的一些规则。要详细阅读，请参阅[在 java](https://beginnersbook.com/2013/05/catch-multiple-exceptions/) 中捕获多个异常。
 1.如上所述，单个 try 块可以包含任意数量的 catch 块。
@@ -100,7 +100,7 @@ catch（ArithmeticException e）是一个可以解决 ArithmeticException 的捕
 catch（NullPointerException e）是一个可以处理 NullPointerException 的 catch 块
 ] 5.你也可以抛出异常，这是一个高级主题，我在单独的教程中介绍了它：[用户定义异常](https://beginnersbook.com/2013/04/user-defined-exception-in-java/)，[抛出关键字](https://beginnersbook.com/2013/12/throws-keyword-example-in-java/)，[抛出 vs 抛出](https://beginnersbook.com/2013/04/difference-between-throw-and-throws-in-java/) ]。
 
-### 多个 catch 块的示例
+### 多个`catch`块的示例
 
 ```java
 class Example2{
@@ -133,6 +133,6 @@ Out of try-catch block...
 
 在上面的示例中，有多个 catch 块，当 try 块中发生异常时，这些 catch 块按顺序执行。这意味着如果你把最后一个 catch 块（catch（异常 e））放在第一个地方，就在 try 块之后，那么在任何异常的情况下，这个块将执行，因为它可以处理所有异常。该挡块应放在最后，以避免这种情况。
 
-## 最后阻止
+## `finally`块
 
 我在这里单独介绍了这个： [java finally 块](https://beginnersbook.com/2013/04/java-finally-block/)。现在你只需知道这个块执行是否发生异常。您应该将这些语句放在 finally 块中，必须执行是否发生异常。
\ No newline at end of file

docs/java/42.md

-# Java Finally 块 - 异常处理
+# Java `finally`块 - 异常处理
 
 > 原文： [https://beginnersbook.com/2013/04/java-finally-block/](https://beginnersbook.com/2013/04/java-finally-block/)
 
 在之前的教程中，我介绍了 [try-catch 块](https://beginnersbook.com/2013/04/try-catch-in-java/)和[嵌套的 try 块](https://beginnersbook.com/2013/04/nested-try-catch/)。在本指南中，我们将看到 finally try 与 try-catch 一起使用。
 **最后一个块**包含所有必须执行的关键语句，无论是否发生异常。无论 try 块是否发生异常，例如关闭连接，流等，此块中的语句将始终执行。
 
-## Finally 块的语法
+## `finally`块的语法
 
 ```java
 try {
@@ -19,7 +19,7 @@ finally {
 }
 ```
 
-## finally 块的简单示例
+## `finally`块的简单示例
 
 在这里你可以看到异常发生在 try 块中，它已经在 catch 块中被处理，在 finally 块被执行之后。
 
@@ -53,7 +53,7 @@ This is finally block
 Out of try-catch-finally
 ```
 
-## 关于 finally 块的几点重要
+## `finally`块的几个重点
 
 1\. finally 块必须与 try 块相关联，如果没有 try 块，则不能使用 finally 块。您应该将这些语句放在必须始终执行的块中。
 
@@ -66,7 +66,7 @@ Out of try-catch-finally
 5.即使 try 块包含诸如 return，break 或 continue 之类的控制转移语句，**中的语句最终也会阻止**执行。
 让我们看一个例子，看看当 try 块中存在 return 语句时最终是如何工作的：
 
-### finally 块和 return 语句的另一个例子
+### `finally`块和`return`语句的另一个例子
 
 你可以看到，即使我们在方法中有 return 语句，finally 块仍然会运行。
 
@@ -101,14 +101,14 @@ Finally block ran even after return statement
 要查看 finally 和 return 的更多示例，请参阅： [Java finally 块和返回语句](https://beginnersbook.com/2013/05/java-finally-return/)
 。
 
-## finally 块未执行时的情况
+## `finally`块未执行时的情况
 
 阻止在 finally 块中执行代码的情况是：
 - 线程的死亡
 - 使用系统。 exit（）方法。
 - 由于 finally 块中出现异常。
 
-## 最后和关闭（）
+## `finally`和`close()`
 
 **close（）**语句用于关闭程序中的所有打开流。在 finally 块中使用 close（）是一个很好的做法。由于即使发生异常，最终块也会执行，因此无论是否发生异常，您都可以确保所有输入和输出流都已正确关闭。
 
@@ -133,7 +133,7 @@ catch(IOException e1){
 ...
 ```
 
-## 最后阻止没有捕获
+## 没有`catch`的`finally`块
 
 可以在没有 catch 块的情况下使用 try-finally 块。这意味着 try 块可以在没有 catch 块的情况下最终使用。
 
@@ -155,7 +155,7 @@ finally {
 ...
 ```
 
-## 最后块和 System.exit（）
+## `finally`块和`System.exit()`
 
 **System.exit（）**语句的行为与 **return 语句**不同。与 return 语句不同，每当在 try 块中调用 System.exit（）时，**最后块**不会执行。这是一个代码片段，演示了相同的代码：
 
@@ -177,7 +177,7 @@ finally {
 
 在上面的例子中，如果 **System.exit（0）**被调用而没有任何异常，那么最终将不会执行。但是，如果在调用 **System.exit（0）**时发生任何异常，则将执行 finally 块。
 
-## try-catch-finally 块
+## `try-catch-finally`块
 
 *   try 语句应该与 catch 块或 finally 相关联。
 *   由于 catch 执行异常处理并最终执行清理，因此最好的方法是同时使用它们。
@@ -196,7 +196,7 @@ finally {
 }
 ```
 
-### Try catch finally 块的例子
+### `try-catch-finally`块的例子
 
 **示例 1：**以下示例演示了 try 块中没有异常时 finally 块的工作情况
 

docs/java/43.md

-# 如何使用示例在 java 中抛出异常
+# 如何在 java 中抛出异常
 
 > 原文： [https://beginnersbook.com/2013/04/throw-in-java/](https://beginnersbook.com/2013/04/throw-in-java/)
 
@@ -18,7 +18,7 @@ throw new exception_class("error message");
 throw new ArithmeticException("dividing a number by 5 is not allowed in this program");
 ```
 
-## throw 关键字的示例
+## `throw`关键字的示例
 
 假设我们有一个要求，我们只需要在年龄小于 12 且体重小于 40 的情况下注册学生，如果不满足任何条件，那么用户应该获得带有警告消息“学生”的 ArithmeticException 没有资格注册“。我们已经通过将代码放在检查学生资格的方法中来实现逻辑，如果输入的学生年龄和体重不符合标准，那么我们使用 throw 关键字抛出异常。
 

docs/java/44.md

-# 用户在 java 中定义的异常
+# java 中的用户定义的异常
 
 > 原文： [https://beginnersbook.com/2013/04/user-defined-exception-in-java/](https://beginnersbook.com/2013/04/user-defined-exception-in-java/)
 

docs/java/45.md

-# Java 异常处理示例
+# Java 异常处理
 
 > 原文： [https://beginnersbook.com/2013/04/exception-handling-examples/](https://beginnersbook.com/2013/04/exception-handling-examples/)
 
@@ -35,7 +35,7 @@ You Shouldn't divide a number by zero
 
 **说明：**在上面的例子中，我将整数除以零，因此抛出`ArithmeticException`。
 
-## 示例 2：ArrayIndexOutOfBounds 异常
+## 示例 2：`ArrayIndexOutOfBounds`异常
 
 类：`Java.lang.ArrayIndexOutOfBoundsException`
 当您尝试访问不存在的数组索引时，会发生此异常。例如，如果数组只有 5 个元素，并且我们试图显示第 7 个元素，那么它将抛出此异常。
@@ -65,7 +65,7 @@ ArrayIndexOutOfBounds
 
 在上面的示例中，数组被初始化为仅存储 10 个元素索引 0 到 9.因为我们尝试访问索引 11 的元素，所以程序抛出此异常。
 
-## 示例 3：NumberFormatException
+## 示例 3：`NumberFormatException`
 
 分类：`Java.lang.NumberFormatException`
 
@@ -94,7 +94,7 @@ class ExceptionDemo3
 Number format exception occurred
 ```
 
-## 示例 4：StringIndexOutOfBound 异常
+## 示例 4：`StringIndexOutOfBound`异常
 
 分类：`Java.lang.StringIndexOutOfBoundsException`
 
@@ -131,7 +131,7 @@ StringIndexOutOfBoundsException!!
 
 发生异常是因为 String 中没有引用的索引。
 
-## 示例 5：NullPointer 异常
+## 示例 5：`NullPointer`异常
 
 类：`Java.lang.NullPointer Exception`
 只要使用“null”对象调用成员，就会创建此类的对象。

docs/java/46.md

-# 关于注释，枚举和正则表达式的 Java 教程
\ No newline at end of file
+# Java 注解，枚举和正则表达式教程
\ No newline at end of file

docs/java/47.md

-# Java Enum 教程与示例
+# Java 枚举教程
 
 > 原文： [https://beginnersbook.com/2014/09/java-enum-examples/](https://beginnersbook.com/2014/09/java-enum-examples/)
 
 枚举是一种特殊类型的数据类型，它基本上是常量的集合（集合）。在本教程中，我们将学习如何在 Java 中使用枚举以及我们可以使用它们的可能场景。
 
-#### 这就是我们定义 Enum 的方式
+#### 这就是我们定义`Enum`的方式
 
 ```java
 public enum Directions{
@@ -25,7 +25,7 @@ Directions dir = Directions.NORTH;
 
 变量`dir`的类型为 Directions（即枚举类型）。此变量可以取可能的四个值（EAST，WEST，NORTH，SOUTH）中的任何值。在这种情况下，它设置为 NORTH。
 
-#### 在 if-else 语句中使用 Enum 类型
+#### 在`if-else`语句中使用`Enum`类型
 
 这就是我们如何在 if-else 逻辑中使用枚举变量。
 
@@ -84,7 +84,7 @@ public class EnumDemo
 Direction: North
 ```
 
-#### 在 Switch-Case 语句中使用 Enum
+#### 在`Switch-Case`语句中使用`Enum`
 
 下面是演示在 switch-case 语句中使用枚举的示例。
 
@@ -137,7 +137,7 @@ In East Direction
 In South Direction
 ```
 
-#### 如何遍历 Enum 变量
+#### 如何遍历`Enum`变量
 
 ```java
 class EnumDemo
@@ -196,7 +196,7 @@ E
 
 正如您在本示例中所看到的，我们为每个常量都有一个字段`shortCode`，以及一个方法`getDirectionCode()`，它基本上是该字段的 getter 方法。当我们定义一个像`EAST ("E")`这样的常量时，它会使用传递的参数调用枚举构造函数（参见上例中的构造函数`Directions`）。这样，传递的值被设置为相应枚举常数[EAST（“E”） **=＆gt;的字段的值。** 会调用构造函数 Directions（“E”） **=＆gt;** this.shortCode = code **=＆gt;** this.shortCode =“E” **=＆gt;** 常数 EAST 的 shortCode 字段设置为“E”]。
 
-#### 要点注意事项：
+#### 注意事项：
 
 1）在定义枚举时，应在任何字段或方法之前首先声明常量。
 2）当在 Enum 中声明了字段和方法时，枚举常量列表必须以分号（;）结尾。
\ No newline at end of file

docs/java/48.md

-# 带有示例的 Java Annotations 教程
+# Java 注解教程
 
 > 原文： [https://beginnersbook.com/2014/09/java-annotations/](https://beginnersbook.com/2014/09/java-annotations/)
 
-[Java Annotations](https://docs.oracle.com/javase/tutorial/java/annotations/index.html) 允许我们将元数据信息添加到我们的源代码中，尽管它们不是程序本身的一部分。注释从 JDK 5 添加到 java 中。注释对它们注释的代码的操作没有直接影响（即它不影响程序的执行）。
+[Java Annotations](https://docs.oracle.com/javase/tutorial/java/annotations/index.html) 允许我们将元数据信息添加到我们的源代码中，尽管它们不是程序本身的一部分。注解从 JDK 5 添加到 java 中。注解对它们注解的代码的操作没有直接影响（即它不影响程序的执行）。
 
-在本教程中，我们将介绍以下主题：注释的使用，如何应用注释，Java 中可用的预定义注释类型以及如何创建自定义注释。
+在本教程中，我们将介绍以下主题：注解的使用，如何应用注解，Java 中可用的预定义注解类型以及如何创建自定义注解。
 
-## 注释有什么用？
+## 注解有什么用？
 
-**1）编译器指令**：Java 中有三种内置注释（`@Deprecated`，`@Override`＆amp; `@SuppressWarnings`），可用于向编译器提供某些指令。例如，@ override 注释用于指示编译器注释方法是否覆盖该方法。有关这些内置注释的更多信息，请参阅本文的下一部分。
+**1）编译器指令**：Java 中有三种内置注解（`@Deprecated`，`@Override`＆amp; `@SuppressWarnings`），可用于向编译器提供某些指令。例如，@ override 注解用于指示编译器注解方法是否覆盖该方法。有关这些内置注解的更多信息，请参阅本文的下一部分。
 
-**2）编译时教程**：注释可以为编译器提供编译时指令，软件构建工具可以进一步使用它来生成代码，XML 文件等。
+**2）编译时教程**：注解可以为编译器提供编译时指令，软件构建工具可以进一步使用它来生成代码，XML 文件等。
 
-**3）运行时指令**：我们可以定义在运行时可用的注释，我们可以使用 [java 反射](https://docs.oracle.com/javase/tutorial/reflect/)访问它们，并可用于在运行时向程序发出指令。我们将在稍后的同一篇文章的帮助下讨论这个问题。
+**3）运行时指令**：我们可以定义在运行时可用的注解，我们可以使用 [java 反射](https://docs.oracle.com/javase/tutorial/reflect/)访问它们，并可用于在运行时向程序发出指令。我们将在稍后的同一篇文章的帮助下讨论这个问题。
 
-## 注释基础知识
+## 注解基础知识
 
-注释始终以符号`@`开头，后跟注释名称。符号`@`向编译器指示这是一个注释。
+注解始终以符号`@`开头，后跟注解名称。符号`@`向编译器指示这是一个注解。
 
 对于例如`@Override`
-这里@符号表示这是一个注释，而 Override 是这个注释的名称。
+这里@符号表示这是一个注解，而 Override 是这个注解的名称。
 
-**我们可以在哪里使用注释？**
-注释可以应用于类，接口，方法和字段。例如，以下注释正在应用于该方法。
+**我们可以在哪里使用注解？**
+注解可以应用于类，接口，方法和字段。例如，以下注解正在应用于该方法。
 
 ```java
 @Override
@@ -31,19 +31,19 @@ void myMethod() {
 }
 ```
 
-这个注释在这里做的正是在下一节中解释的，但简单来说它指示编译器`myMethod()`是一个覆盖超类方法（myMethod（））的重写方法。
+这个注解在这里做的正是在下一节中解释的，但简单来说它指示编译器`myMethod()`是一个覆盖超类方法（myMethod（））的重写方法。
 
-## Java 中的内置注释
+## Java 中的内置注解
 
-Java 有三个内置注释：
+Java 有三个内置注解：
 
 *   @覆盖
 *   @Deprecated
 *   @SuppressWarnings
 
-#### 1）@Override：
+#### 1）`@Override`：
 
-在覆盖子类中的方法时，我们应该使用此批注来标记该方法。这使得代码可读并避免维护问题，例如：在更改父类的方法签名时，必须更改子类中的签名（使用此批注的位置），否则编译器将抛出编译错误。如果您没有使用此注释，则很难跟踪。
+在覆盖子类中的方法时，我们应该使用此批注来标记该方法。这使得代码可读并避免维护问题，例如：在更改父类的方法签名时，必须更改子类中的签名（使用此批注的位置），否则编译器将抛出编译错误。如果您没有使用此注解，则很难跟踪。
 
 例：
 
@@ -64,11 +64,11 @@ public class MyChildClass extends MyParentClass {
 }
 ```
 
-我相信这个例子是自我解释的。要阅读有关此注释的更多信息，请参阅以下文章： [@Override 内置注释](https://beginnersbook.com/2014/07/override-annotation-in-java/ "@Override annotation in Java")。
+我相信这个例子是自我解释的。要阅读有关此注解的更多信息，请参阅以下文章： [@Override 内置注解](https://beginnersbook.com/2014/07/override-annotation-in-java/ "@Override annotation in Java")。
 
-#### 2）@Deprecated
+#### 2）`@Deprecated`
 
-@Deprecated 注释表示已弃用标记的元素（类，方法或字段），不应再使用。只要程序使用已经使用@Deprecated 注释标记的方法，类或字段，编译器就会生成警告。不推荐使用元素时，也应使用 Javadoc @deprecated 标记对其进行记录，如以下示例所示。记下@Deprecated 和@deprecated 的大小写差异。 @deprecated 用于文档目的。
+@Deprecated 注解表示已弃用标记的元素（类，方法或字段），不应再使用。只要程序使用已经使用@Deprecated 注解标记的方法，类或字段，编译器就会生成警告。不推荐使用元素时，也应使用 Javadoc @deprecated 标记对其进行记录，如以下示例所示。记下@Deprecated 和@deprecated 的大小写差异。 @deprecated 用于文档目的。
 
 Example:
 
@@ -83,11 +83,11 @@ public void anyMethodHere(){
 }
 ```
 
-现在，只要任何程序使用此方法，编译器就会生成警告。要阅读有关此注释的更多信息，请参阅以下文章： [Java - @Deprecated annotation](https://beginnersbook.com/2014/07/deprecated-annotation-in-java/ "@Deprecated annotation in java") 。
+现在，只要任何程序使用此方法，编译器就会生成警告。要阅读有关此注解的更多信息，请参阅以下文章： [Java - @Deprecated annotation](https://beginnersbook.com/2014/07/deprecated-annotation-in-java/ "@Deprecated annotation in java") 。
 
-#### 3）@SuppressWarnings
+#### 3）`@SuppressWarnings`
 
-此批注指示编译器忽略特定警告。例如，在下面的代码中，我调用了一个不推荐使用的方法（假设方法 deprecatedMethod（）标有@Deprecated 注释），因此编译器应该生成警告，但是我使用@@ SuppressWarnings 注释来抑制弃用警告。
+此批注指示编译器忽略特定警告。例如，在下面的代码中，我调用了一个不推荐使用的方法（假设方法 deprecatedMethod（）标有@Deprecated 注解），因此编译器应该生成警告，但是我使用@@ SuppressWarnings 注解来抑制弃用警告。
 
 ```java
 @SuppressWarnings("deprecation")
@@ -96,11 +96,11 @@ public void anyMethodHere(){
 }
 ```
 
-## 创建自定义注释
+## 创建自定义注解
 
-*   注释是使用@interface 创建的，后跟注释名称，如下例所示。
-*   注释也可以包含元素。他们看起来像方法。例如，在下面的代码中，我们有四个元素。我们不应该为这些元素提供实现。
-*   所有注释都扩展了 java.lang.annotation.Annotation 接口。注释不能包含任何 extends 子句。
+*   注解是使用@interface 创建的，后跟注解名称，如下例所示。
+*   注解也可以包含元素。他们看起来像方法。例如，在下面的代码中，我们有四个元素。我们不应该为这些元素提供实现。
+*   所有注解都扩展了 java.lang.annotation.Annotation 接口。注解不能包含任何 extends 子句。
 
 ```java
 import java.lang.annotation.Documented;
@@ -122,7 +122,7 @@ public @interface MyCustomAnnotation{
 }
 ```
 
-注意：使用注释时，可以跳过在创建注释时设置了默认值的所有元素。例如，如果我将上述注释应用于类，那么我会这样做：
+注意：使用注解时，可以跳过在创建注解时设置了默认值的所有元素。例如，如果我将上述注解应用于类，那么我会这样做：
 
 ```java
 @MyCustomAnnotation(
@@ -134,10 +134,10 @@ public class MyClass {
 }
 ```
 
-如您所见，我们没有给`studentAge`和`stuStream`元素赋予任何值，因为设置这些元素的值是可选的（默认值已经在注释定义中设置，但是如果您希望可以分配新的使用注释时的值与我们对其他元素的处理方式相同）。但是，我们必须在使用注释时提供其他元素的值（没有设置默认值的元素）。
+如您所见，我们没有给`studentAge`和`stuStream`元素赋予任何值，因为设置这些元素的值是可选的（默认值已经在注解定义中设置，但是如果您希望可以分配新的使用注解时的值与我们对其他元素的处理方式相同）。但是，我们必须在使用注解时提供其他元素的值（没有设置默认值的元素）。
 
-**注意**：我们也可以在注释中包含数组元素。这就是我们如何使用它们：
-注释定义：
+**注意**：我们也可以在注解中包含数组元素。这就是我们如何使用它们：
+注解定义：
 
 ```java
 @interface MyCustomAnnotation {
@@ -158,11 +158,11 @@ public class MyClass {
 }
 ```
 
-再次回到主题：在自定义注释示例中，我们使用了这四个注释：`@Documented`，`@Target`，`@Inherited`＆amp; `@Retention`。让我们详细讨论它们。
+再次回到主题：在自定义注解示例中，我们使用了这四个注解：`@Documented`，`@Target`，`@Inherited`＆amp; `@Retention`。让我们详细讨论它们。
 
-#### @Documented
+#### `@Documented`
 
-@Documented 注释表明使用此注释的元素应由 JavaDoc 记录。例如：
+@Documented 注解表明使用此注解的元素应由 JavaDoc 记录。例如：
 
 ```java
 java.lang.annotation.Documented
@@ -179,11 +179,11 @@ public class MyClass {
 }
 ```
 
-在为类`MyClass`生成 javadoc 时，注释`@MyCustomAnnotation`将包含在其中。
+在为类`MyClass`生成 javadoc 时，注解`@MyCustomAnnotation`将包含在其中。
 
-#### @目标
+#### `@Target`
 
-它指定了我们可以使用注释的位置。例如：在下面的代码中，我们将目标类型定义为 METHOD，这意味着下面的注释只能用于方法。
+它指定了我们可以使用注解的位置。例如：在下面的代码中，我们将目标类型定义为 METHOD，这意味着下面的注解只能用于方法。
 
 ```java
 import java.lang.annotation.ElementType;
@@ -205,8 +205,8 @@ public class MyClass {
 }
 ```
 
-**注意**：1）如果您没有定义任何目标类型，则意味着可以将注释应用于任何元素。
-2）除了 ElementType.METHOD 之外，注释可以具有以下可能的 Target 值。
+**注意**：1）如果您没有定义任何目标类型，则意味着可以将注解应用于任何元素。
+2）除了 ElementType.METHOD 之外，注解可以具有以下可能的 Target 值。
 ElementType.METHOD
 ElementType.PACKAGE
 ElementType.PARAMETER
@@ -216,9 +216,9 @@ ElementType.CONSTRUCTOR
 ElementType.LOCAL_VARIABLE
 ElementType.FIELD
 
-#### @遗传
+#### `@Inherited`
 
-@Inherited 注释表示类中使用的自定义注释应该由其所有子类继承。例如：
+@Inherited 注解表示类中使用的自定义注解应该由其所有子类继承。例如：
 
 ```java
 java.lang.annotation.Inherited
@@ -242,11 +242,11 @@ public class MyChildClass extends MyParentClass {
 }
 ```
 
-这里的类`MyParentClass`正在使用注释`@MyCustomAnnotation`，该注释用@inherited 注释标记。这意味着子类`MyChildClass`继承了`@MyCustomAnnotation`。
+这里的类`MyParentClass`正在使用注解`@MyCustomAnnotation`，该注解用@inherited 注解标记。这意味着子类`MyChildClass`继承了`@MyCustomAnnotation`。
 
-#### @保留
+#### `@Retention`
 
-它指示要保留带注释类型的注释的时间长度。
+它指示要保留带注解类型的注解的时间长度。
 
 ```java
 import java.lang.annotation.Retention;
@@ -259,8 +259,8 @@ import java.lang.annotation.RetentionPolicy;
 ```
 
 这里我们使用了 RetentionPolicy.RUNTIME。还有另外两种选择。让我们看看他们的意思：
-`RetentionPolicy.RUNTIME`：注释应该在运行时可用，以便通过 java 反射进行检查。
-`RetentionPolicy.CLASS`：注释将在.class 文件中，但在运行时不可用。
-`RetentionPolicy.SOURCE`：注释将在程序的源代码中提供，它既不在.class 文件中，也不在运行时可用。
+`RetentionPolicy.RUNTIME`：注解应该在运行时可用，以便通过 java 反射进行检查。
+`RetentionPolicy.CLASS`：注解将在.class 文件中，但在运行时不可用。
+`RetentionPolicy.SOURCE`：注解将在程序的源代码中提供，它既不在.class 文件中，也不在运行时可用。
 
 这就是“Java Annotation”这个主题的全部内容。如果您有任何疑问，请随时在下面留言。
\ No newline at end of file

docs/java/49.md

-# Java 正则表达式（java 正则表达式）教程与示例
+# Java 正则表达式教程
 
 > 原文： [https://beginnersbook.com/2014/08/java-regex-tutorial/](https://beginnersbook.com/2014/08/java-regex-tutorial/)
 
@@ -35,9 +35,9 @@ The text contains 'book'? true
 1）java.util.regex.Pattern - 用于定义模式
 2）java.util.regex.Matcher - 用于使用模式对文本执行匹配操作
 
-## java.util.regex.Pattern 类：
+## `java.util.regex.Pattern`类：
 
-#### 1）Pattern.matches（）
+#### 1）`Pattern.matches()`
 
 我们已经在上面的例子中看到过这种方法的用法，我们在给定的文本中搜索了字符串“book”。这是使用 Regex 在文本中搜索 String 的最简单和最简单的方法之一。
 
@@ -52,7 +52,7 @@ System.out.println("The text contains 'tutorial'? " + isMatch);
 
 **限制**：通过这种方式，我们可以搜索文本中单个出现的模式。要匹配多次出现，您应该使用 Pattern.compile（）方法（在下一节中讨论）。
 
-#### 2）Pattern.compile（）
+#### 2）`Pattern.compile()`
 
 在上面的例子中，我们在文本中搜索了一个字符串“tutorial”，这是一个区分大小写的搜索，但是如果你想进行 CASE INSENSITIVE 搜索或者想要多次搜索，那么你可能需要先使用 Pattern 编译模式.compile（）在用文本搜索之前。这就是这种方法可以用于这种情况的方法。
 
@@ -66,7 +66,7 @@ Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
 
 **现在**：我们已经获得了一个 Pattern 实例，但是如何匹配呢？为此，我们需要一个 Matcher 实例，我们可以使用 Pattern.matcher（）方法。让我们讨论一下。
 
-#### 3）Pattern.matcher（）方法
+#### 3）`Pattern.matcher()`方法
 
 在上一节中，我们学习了如何使用 compile（）方法获取 Pattern 实例。在这里，我们将学习如何使用 matcher（）方法从 Pattern 实例获取 Matcher 实例。
 
@@ -85,7 +85,7 @@ Output:
 Is it a Match?true
 ```
 
-#### 4）Pattern.split（）
+#### 4）`Pattern.split()`
 
 要根据分隔符将文本拆分为多个字符串（这里使用**正则表达式**指定分隔符），我们可以使用 Pattern.split（）方法。这是如何做到的。
 
@@ -117,11 +117,11 @@ Number of split strings: 4
 
 第二个拆分 String 在输出中为 null。
 
-## java.util.regex.Matcher 类
+## `java.util.regex.Matcher`类
 
 我们已经讨论过上面的 Matcher 类了。让我们回忆一下：
 
-#### 创建 Matcher 实例
+#### 创建`Matcher`实例
 
 ```java
 String content = "Some text";
@@ -146,7 +146,7 @@ boolean isMatch = matcher.matches();
 
 **start（）和 end（）**：这两种方法通常与 find（）方法一起使用。它们用于获取使用 find（）方法找到的匹配项的开始和结束索引。
 
-#### 让我们举个例子来找出使用 Matcher 方法的多次出现：
+#### 让我们举个例子使用`Matcher`方法来找出多次出现：
 
 ```java
 package beginnersbook.com;
@@ -178,12 +178,12 @@ Found at: 17 - 19
 
 现在我们熟悉 Pattern 和 Matcher 类以及将正则表达式与文本匹配的过程。让我们看一下我们定义正则表达式的各种选项：
 
-#### 1）字符串文字
+#### 1）字符串字面值
 
 假设您只想在文本中搜索特定字符串，例如“abc”然后我们可以简单地编写这样的代码：这里的文本和正则表达式都是相同的。
 `Pattern.matches("abc", "abc")`
 
-#### 2）角色类
+#### 2）字符类
 
 字符类将输入文本中的单个字符与字符类中的多个允许字符进行匹配。例如[Cc] haitanya 将匹配所有出现的字符串“chaitanya”与小写或大写 C“。更多例子：
 `Pattern.matches("[pqr]", "abcd");`它会给出错误，因为文中没有 p，q 或 r

docs/java/50.md

-# 杂项核心 Java 教程
\ No newline at end of file
+# 其它核心 Java 教程
\ No newline at end of file

docs/java/51.md

-# Java - String Class 及其方法用示例解释
+# Java - `String`类及其方法
 
 > 原文： [https://beginnersbook.com/2013/12/java-strings/](https://beginnersbook.com/2013/12/java-strings/)
 
@@ -9,7 +9,7 @@
 有两种方法可以在 Java 中创建 String
 
 1.  字符串字面量
-2.  使用新关键字
+2.  使用`new`关键字
 
 ### 字符串字面量
 
@@ -24,9 +24,9 @@ String str2 = "Welcome";
 
 **但是**如果对象已经存在于内存中它不会创建新的 Object 而是将同一个旧对象分配给新实例，这意味着即使我们上面有两个字符串实例（str1 和 str2）编译器仅在字符串对象上创建（具有值“欢迎”）并将其分配给两个实例。例如，有 10 个字符串实例具有相同的值，这意味着在内存中只有一个对象具有该值，并且所有 10 个字符串实例将指向同一个对象。
 
-如果我们想要两个具有相同字符串的不同对象，该怎么办？为此，我们需要使用**新关键字**创建字符串。
+如果我们想要两个具有相同字符串的不同对象，该怎么办？为此，我们需要使用**`new`关键字**创建字符串。
 
-### 使用新关键字
+### 使用`new`关键字
 
 正如我们在上面看到的那样，当我们尝试将相同的字符串对象分配给两个不同的文字时，编译器只创建了一个对象并使两个文字都指向同一个对象。为了克服这种方法，我们可以创建这样的字符串：
 

docs/java/52.md

-# 用例子中的 java 多线程
+# java 多线程
 
 > 原文： [https://beginnersbook.com/2013/03/multithreading-in-java/](https://beginnersbook.com/2013/03/multithreading-in-java/)
 
@@ -48,7 +48,7 @@ TERMINATED - 已退出的线程处于此状态。
 *   `sleep()`：暂停线程一段时间
 *   `start()`：通过调用 run（）方法启动一个线程
 
-### 方法 1：通过扩展 Thread 类创建线程
+### 方法 1：通过扩展`Thread`类创建线程
 
 **例 1：**
 
@@ -145,7 +145,7 @@ mythread run is over
 Main thread run is over
 ```
 
-### 方法 2：通过实现 Runnable 接口创建线程
+### 方法 2：通过实现`Runnable`接口创建线程
 
 **一个简单的例子**
 
@@ -254,7 +254,7 @@ Main thread run is over
 *   要设置线程的优先级`setPriority()`方法，这是类`Thread`类的方法。
 *   我们可以使用`MIN_PRIORITY`，`NORM_PRIORITY`或`MAX_PRIORITY`代替以整数定义优先级。
 
-## 方法：isAlive（）和 join（）
+## 方法：`isAlive()`和`join()`
 
 *   在所有实际情况中，主线程应该最后完成其他从主线程产生的其他线程也将完成。
 *   要知道线程是否已完成，我们可以在线程上调用`isAlive()`，如果线程未完成则返回 true。

docs/java/54.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2015/06/java-awt-tutorial/](https://beginnersbook.com/2015/06/java-awt-tutorial/)
 
-**AWT** 代表**抽象窗口工具包**。它是一个依赖于平台的 API，用于为 Java 程序创建图形用户接口（GUI）。
+**AWT** 代表**抽象窗口工具包**。它是一个依赖于平台的 API，用于为 Java 程序创建图形用户界面（GUI）。
 
 **为什么 AWT 与平台有关？** Java AWT 调用本机平台（操作系统）子程序，用于创建文本框，复选框，按钮等组件。例如，具有按钮的 AWT GUI 在诸如 Windows，Mac OS 和 Windows 等平台之间具有不同的外观和感觉。 Unix，这是因为这些平台的原生按钮具有不同的外观和感觉，AWT 直接调用创建按钮的原生子程序。简单来说，基于 AWT 的应用程序在 Windows 上运行时看起来就像一个 Windows 应用程序，但在 Mac OS 上运行时，相同的应用程序看起来就像是 Mac 应用程序。
 
@@ -33,7 +33,7 @@ Swing 是基于窗口的应用程序的首选 API，因为它具有平台独立
 2）通过创建 Frame 类的实例
 让我们看一下每个示例。
 
-## AWT 示例 1：通过扩展 Frame 类来创建 Frame
+## AWT 示例 1：通过扩展`Frame`类来创建`Frame`
 
 ```java
 import java.awt.*;
@@ -76,7 +76,7 @@ public class SimpleExample extends Frame{
 **输出：**
 ![AWT example 1](img/dbe1983d5f8cfad00d7b698197936246.jpg)
 
-## AWT 示例 2：通过创建 Frame 类的实例来创建 Frame
+## AWT 示例 2：通过创建`Frame`类的实例来创建`Frame`
 
 ```java
 import java.awt.*;

docs/java/55.md

@@ -2,12 +2,12 @@
 
 > 原文： [https://beginnersbook.com/2015/07/java-swing-tutorial/](https://beginnersbook.com/2015/07/java-swing-tutorial/)
 
-Swing 是 Java Foundation 类（JFC）的一部分，JFC 的其他部分是 java2D 和 Abstract window 工具包（AWT）。 AWT，Swing＆amp; Java 2D 用于在 java 中构建图形用户接口（GUI）。在本教程中，我们将主要讨论用于在 AWT 顶部构建 GUI 的 Swing API，与 AWT 相比，它更轻量级。
+Swing 是 Java Foundation 类（JFC）的一部分，JFC 的其他部分是 java2D 和 Abstract window 工具包（AWT）。 AWT，Swing＆amp; Java 2D 用于在 java 中构建图形用户界面（GUI）。在本教程中，我们将主要讨论用于在 AWT 顶部构建 GUI 的 Swing API，与 AWT 相比，它更轻量级。
 
 ## 一个简单的例子
 
 在下面的示例中，我们将使用您在本教程中到目前为止尚未学习的几个 swing 组件。我们将在即将到来的摇摆教程中详细讨论每一个和所有内容。
-下面的 swing 程序会创建一个登录接口。
+下面的 swing 程序会创建一个登录界面。
 
 ```java
 import javax.swing.JButton;

docs/java/56.md

-# Java Autoboxing 和 Unboxing 以及示例
+# Java 自动装箱和拆箱
 
 > 原文： [https://beginnersbook.com/2014/09/java-autoboxing-and-unboxing-with-examples/](https://beginnersbook.com/2014/09/java-autoboxing-and-unboxing-with-examples/)
 
 Java 1.5 引入了一种特殊功能，即将原始类型自动转换为相应的 Wrapper 类，反之亦然。
 
-**Autoboxing** ：将原始类型自动转换为相应包装类的对象称为 autoboxing。例如 - 将 int 转换为 Integer，将 long 转换为 Long，将 double 转换为 Double 等。
+**自动装箱** ：将原始类型自动转换为相应包装类的对象称为 autoboxing。例如 - 将 int 转换为 Integer，将 long 转换为 Long，将 double 转换为 Double 等。
 
 **拆箱**：这只是自动装箱的逆过程。自动将包装类的对象转换为其对应的基元类型称为拆箱。例如 - 将 Integer 转换为 int，Long 转换为 long，将 Double 转换为 double 等。
 
@@ -20,7 +20,7 @@ short	        Short
 double	        Double
 ```
 
-## 什么时候自动装箱和拆箱发生在 Java 中
+## Java 中什么时候发生自动装箱和拆箱
 
 #### 自动装箱
 

docs/java/57.md

@@ -55,7 +55,7 @@ public class JavaExample{
 
 如您所见，原始[数据类型](https://beginnersbook.com/2017/08/data-types-in-java/)和对象具有相同的值。您可以使用 obj 代替 num，无论您需要将 num 的值作为对象传递。
 
-## 包装类示例 2：将包装类对象转换为基元
+## 包装类示例 2：将包装类对象转换为基本对象
 
 ```java
 public class JavaExample{  

docs/java/59.md

-# Java Lambda 表达式教程与示例
+# Java Lambda 表达式教程
 
 > 原文： [https://beginnersbook.com/2017/10/java-lambda-expressions-tutorial-with-examples/](https://beginnersbook.com/2017/10/java-lambda-expressions-tutorial-with-examples/)
 
@@ -166,7 +166,7 @@ Output:
 Result: Hello World
 ```
 
-## 示例 4：使用 foreach 循环迭代集合
+## 示例 4：使用`foreach`循环迭代集合
 
 ```java
 import java.util.*;  

docs/java/60.md

-# Java 8 中的方法参考
+# Java 8 中的方法引用
 
 > 原文： [https://beginnersbook.com/2017/10/method-references-in-java-8/](https://beginnersbook.com/2017/10/method-references-in-java-8/)
 
-在上一个教程中，我们在 Java 8 中学习了 [lambda 表达式。这里我们将讨论 java 8 的另一个新特性，**方法参考**。方法引用是用于调用方法的 lambda 表达式的简写表示法。例如：
+在上一个教程中，我们在 Java 8 中学习了 [lambda 表达式。这里我们将讨论 java 8 的另一个新特性，**方法引用**。方法引用是用于调用方法的 lambda 表达式的简写表示法。例如：
 如果你的 lambda 表达式是这样的：](https://beginnersbook.com/2017/10/java-lambda-expressions-tutorial-with-examples/)
 
 ```java
@@ -17,14 +17,14 @@ System.out::println
 
 ::运算符用于方法引用，以将类或对象与方法名称分开（我们将在示例的帮助下学习）。
 
-## 四种方法参考
+## 四种方法引用
 
 1.对象的实例方法的方法引用 - object :: instanceMethod
 2.对类的静态方法的方法引用 - 类:: staticMethod
 3.对任意对象的实例方法的方法引用特定类型的类 - Class :: instanceMethod
 4.对构造函数的方法引用 - Class :: new
 
-## 1.方法引用对象的实例方法
+## 1.方法引用：对象的实例方法
 
 ```java
 @FunctionalInterface 
@@ -51,7 +51,7 @@ public class Example {
 Instance Method
 ```
 
-## 2.方法引用类的静态方法
+## 2.方法引用：类的静态方法
 
 ```java
 import java.util.function.BiFunction;  
@@ -75,7 +75,7 @@ Output:
 Product of given number is: 55
 ```
 
-## 3.方法引用特定类型的任意对象的实例方法
+## 3.方法引用：特定类型的任意对象的实例方法
 
 ```java
 import java.util.Arrays;