2020-07-01 12:10:53

docs/java/192.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.programiz.com/java-programming/examples/string-date](https://www.programiz.com/java-programming/examples/string-date)
 
-#### 在此程序中，您将学习使用格式化程序在 Java 中将字符串转换为日期。
+#### 在此程序中，您将学习使用格式化器在 Java 中将字符串转换为日期。
 
 ## 示例 1：使用预定义的格式器将字符串转换为日期
 
@@ -28,9 +28,9 @@ public class TimeString {
 2017-07-25
 ```
 
-在上述程序中，我们使用了预定义的格式化程序 ISO_DATE，该格式化程序采用日期字符串为 2017-07-25 或 2017-07-25 + 05：45'的格式。
+在上述程序中，我们使用了预定义的格式化器 ISO_DATE，该格式化器采用日期字符串为 2017-07-25 或 2017-07-25 + 05：45'的格式。
 
-LocalDate 的 parse（）函数使用给定的格式化程序解析给定的字符串。 您也可以在上面的示例中删除 ISO_DATE 格式化程序，并将 parse（）方法替换为：
+LocalDate 的 parse（）函数使用给定的格式化器解析给定的字符串。 您也可以在上面的示例中删除 ISO_DATE 格式化器，并将 parse（）方法替换为：
 
 ```java
 LocalDate date = LocalDate.parse(string, DateTimeFormatter);
@@ -38,7 +38,7 @@ LocalDate date = LocalDate.parse(string, DateTimeFormatter);
 
 * * *
 
-## 示例 2：使用模式格式化程序将字符串转换为日期
+## 示例 2：使用模式格式化器将字符串转换为日期
 
 ```java
 import java.time.LocalDate;
@@ -64,6 +64,6 @@ When you run the program, the output will be:
 2017-07-25
 ```
 
-在上述程序中，我们的日期格式为`MMMM d, yyyy`。 因此，我们创建了给定模式的`格式化程序`。 如果您有兴趣，请检查所有 [DateTimeFormatter 模式](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html "DateTimeFormatter patterns")。
+在上述程序中，我们的日期格式为`MMMM d, yyyy`。 因此，我们创建了给定模式的`格式化器`。 如果您有兴趣，请检查所有 [DateTimeFormatter 模式](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html "DateTimeFormatter patterns")。
 
 现在，我们可以使用`LocalDate.parse()`函数解析日期并获取`LocalDate`对象。
\ No newline at end of file

docs/java/198.md

@@ -58,7 +58,7 @@ Current Date and Time is: 2017-08-02 11:29:57.401
 
 在上面的程序中，我们使用`DateTimeFormatter`对象定义了`Year-Month-Day Hours:Minutes:Seconds.Milliseconds`格式的模式。
 
-然后，我们使用了`LocalDateTime`的`format()`方法来使用给定的`格式化程序`。 这使我们获得格式化的字符串输出。
+然后，我们使用了`LocalDateTime`的`format()`方法来使用给定的`格式化器`。 这使我们获得格式化的字符串输出。
 
 * * *
 

docs/java/50.md

@@ -57,7 +57,7 @@
 
 ### 1\. RuntimeException
 
-**运行时异常**由于编程错误而发生。 它们也称为**未检查的异常**。
+**运行时异常**由于编程错误而发生。 它们也称为**非受检的异常**。
 
 这些异常不在编译时检查，而是在运行时检查。 一些常见的运行时异常是：
 
@@ -76,9 +76,9 @@
 
 ### 2\. IOException
 
-`IOException`也称为**检查的异常**。 它们由编译器在编译时检查，并提示程序员处理这些异常。
+`IOException`也称为**受检的异常**。 它们由编译器在编译时检查，并提示程序员处理这些异常。
 
-受检查的异常的一些示例是：
+受受检的异常的一些示例是：
 
 *   尝试打开不存在的文件会导致`FileNotFoundException`
 *   尝试读取文件末尾

docs/java/51.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.programiz.com/java-programming/exception-handling](https://www.programiz.com/java-programming/exception-handling)
 
-#### 在本教程中，您将借助示例学习使用 Java 处理异常。 为了处理异常，我们将使用 try ... catch ... finally 块。
+#### 在本教程中，您将借助示例学习使用 Java 处理异常。 为了处理异常，我们将使用`try...catch...finally` 块。
 
 在上一教程中，我们了解了异常。 异常是程序执行期间发生的意外事件。
 
@@ -28,7 +28,7 @@ try {
 
 * * *
 
-## Java try ... catch 块
+## Java `try...catch`块
 
 可能产生异常的代码位于`try`块中。
 
@@ -36,7 +36,7 @@ try {
 
 `catch`块不能单独使用，并且必须始终在`try`块之前。
 
-### 示例 1：try ... catch 块
+### 示例 1：`try...catch`块
 
 ```java
 class Main {
@@ -61,21 +61,21 @@ ArithmeticException => / by zero
 
 在这个例子中
 
-*   我们在 try 块中将数字除以 0。 这产生了`ArithmeticException`。
+*   我们在`try`块中将数字除以 0。 这产生了`ArithmeticException`。
 *   发生异常时，程序将跳过`try`块中的其余代码。
-*   在这里，我们创建了一个 catch 块来处理`ArithmeticException`。 因此，将执行`catch`块中的语句。
+*   在这里，我们创建了一个`catch`块来处理`ArithmeticException`。 因此，将执行`catch`块中的语句。
 
 如果`try`块中的所有语句均未生成异常，则将跳过`catch`块。
 
 * * *
 
-## 多个捕获块
+## 多个`catch`块
 
 对于每个`try`块，可以有零个或多个`catch`块。
 
 每个`catch`块的参数类型指示可以处理的异常类型。 多个`catch`块使我们能够以不同方式处理每个异常。
 
-### 示例 2：多个捕获块
+### 示例 2：多个`catch`块
 
 ```java
 class ListOfNumbers {
@@ -119,7 +119,7 @@ IndexOutOfBoundsException => Index 10 out of bounds for length 10
 
 * * *
 
-## Java 终于阻止了
+## Java `finally`块
 
 对于每个`try`块，只能有一个`finally`块。
 
@@ -143,7 +143,7 @@ try {
 
 * * *
 
-### 示例 3：最终阻止
+### 示例 3：`finally`块
 
 ```java
 class Main {
@@ -181,7 +181,7 @@ Finally block is always executed
 
 * * *
 
-### 示例 4：尝试，捕获并最终阻止
+### 示例 4：`try-catch-finally`
 
 让我们举一个例子，我们尝试使用`FileWriter`创建一个新文件，然后使用`PrintWriter`向其中写入数据。
 
@@ -277,7 +277,7 @@ Value at: 9 = 9
 
 * * *
 
-### try ... catch 的工作...最后详细
+### `try...catch...finally`的详细原理
 
 让我们尝试在上述示例的帮助下详细了解异常处理的流程。
 
@@ -320,15 +320,15 @@ try {
 } 
 ```
 
-要了解更多信息，请访问 [Java，捕获多个异常](/java-programming/multiple-exceptions)。
+要了解更多信息，请访问 [Java 捕获多个异常](/java-programming/multiple-exceptions)。
 
 * * *
 
-### try-with-resources 语句
+### `try-with-resources`语句
 
-try-with-resources 语句是一种 try 语句，具有一个或多个资源声明。
+`try-with-resources`语句是一种`try`语句，具有一个或多个资源声明。
 
-Its syntax is:
+它的语法是：
 
 ```java
 try (resource declaration) {
@@ -338,7 +338,7 @@ try (resource declaration) {
 } 
 ```
 
-资源是在程序结束时要关闭的对象。 必须在 try 语句中声明和初始化它。
+资源是在程序结束时要关闭的对象。 必须在`try`语句中声明和初始化它。
 
 让我们举个例子。
 
@@ -348,6 +348,6 @@ try (PrintWriter out = new PrintWriter(new FileWriter(“OutputFile.txt”)) {
 } 
 ```
 
-try-with-resources 语句也称为**自动资源管理**。 该语句在语句末尾自动关闭所有资源。
+`try-with-resources`语句也称为**自动资源管理**。 该语句在语句末尾自动关闭所有资源。
 
-要了解更多信息，请访问 [Java try-with-resources 语句](/java-programming/try-with-resources "Java try-with-resources")。
\ No newline at end of file
+要了解更多信息，请访问 [Java `try-with-resources`语句](/java-programming/try-with-resources "Java try-with-resources")。
\ No newline at end of file

docs/java/52.md

-# Java 抛出
+# Java `throw`
 
 > 原文： [https://www.programiz.com/java-programming/throw-throws](https://www.programiz.com/java-programming/throw-throws)
 
-#### 在本教程中，我们将在示例的帮助下学习使用 throw 和 throws 关键字进行异常处理。
+#### 在本教程中，我们将在示例的帮助下学习使用`throw`和`throws`关键字进行异常处理。
 
 在 Java 中，异常可以分为两种类型：
 
-*   **未检查的异常**：它们不是在编译时检查的，而是在运行时检查的。例如：`ArithmeticException`，`NullPointerException`，`ArrayIndexOutOfBoundsException`，`Error`类下的异常等。
-*   **检查的异常**：在编译时检查它们。 例如`IOException`，`InterruptedException`等。
+*   **非受检的异常**：它们不是在编译时检查的，而是在运行时检查的。例如：`ArithmeticException`，`NullPointerException`，`ArrayIndexOutOfBoundsException`，`Error`类下的异常等。
+*   **受检的异常**：在编译时检查它们。 例如`IOException`，`InterruptedException`等。
 
-请参阅 [Java 异常](https://www.programiz.com/java-programming/exceptions)，以详细了解已检查和未检查的异常。
+请参阅 [Java 异常](https://www.programiz.com/java-programming/exceptions)，以详细了解已检查和非受检的异常。
 
-通常，我们不需要处理未经检查的异常。 这是因为由于编程错误而发生了未经检查的异常。 并且，纠正它们而不是处理它们是一个好习惯。
+通常，我们不需要处理非受检的异常。 这是因为由于编程错误而发生了非受检的异常。 并且，纠正它们而不是处理它们是一个好习惯。
 
-现在，本教程将重点介绍如何使用`throw`和`throws`处理检查的异常。
+现在，本教程将重点介绍如何使用`throw`和`throws`处理受检的异常。
 
 * * *
 
-## Java 抛出关键字
+## Java `throws`关键字
 
 我们在方法声明中使用`throws`关键字来声明其中可能发生的异常的类型。
 
@@ -33,7 +33,7 @@ accessModifier returnType methodName() throws ExceptionType1, ExceptionType2 …
 
 * * *
 
-### 示例 1：Java 抛出关键字
+### 示例 1：Java `throws`关键字
 
 ```java
 import java.io.*;
@@ -101,11 +101,11 @@ class Main {
 
 在这里，`findFile()`方法指定它可以在其`throws`子句中抛出`NullPointerException`，`IOException`和`InvalidClassException`。
 
-请注意，我们尚未处理`NullPointerException`。 这是因为它是未经检查的异常。 不必在`throws`子句中指定它并进行处理。
+请注意，我们尚未处理`NullPointerException`。 这是因为它是非受检的异常。 不必在`throws`子句中指定它并进行处理。
 
 * * *
 
-### 抛出关键字 Vs。 尝试...抓住...最后
+### `throws`关键字 Vs `try-catch-finally`
 
 可能有几种方法可能导致异常。 为每种方法编写`try...catch`将会很繁琐，并且代码变得冗长且可读性较差。
 
@@ -113,13 +113,13 @@ class Main {
 
 * * *
 
-## Java throw 关键字
+## Java `throw`关键字
 
 `throw`关键字用于显式引发单个异常。
 
 引发异常时，程序执行流程从`try`块转移到`catch`块。 我们在方法中使用`throw`关键字。
 
-Its syntax is:
+它的语法是：
 
 ```java
 throw throwableObject;
@@ -129,7 +129,7 @@ throw throwableObject;
 
 * * *
 
-### 示例 2：Java throw 关键字
+### 示例 2：Java `throw`关键字
 
 ```java
 class Main {
@@ -154,11 +154,11 @@ exit status 1
 
 在此示例中，我们明确抛出了`ArithmeticException.`
 
-**注意**： `ArithmeticException`是未经检查的异常。 通常没有必要处理未经检查的异常。
+**注意**： `ArithmeticException`是非受检的异常。 通常没有必要处理非受检的异常。
 
 * * *
 
-### 示例 3：引发检查异常
+### 示例 3：引发受检异常
 
 ```java
 import java.io.*;
@@ -186,7 +186,7 @@ File not found
 
 `findFile()`方法会向我们传递给其构造器的消息引发`IOException`。
 
-注意，由于它是一个检查的异常，因此必须在`throws`子句中指定它。
+注意，由于它是一个受检的异常，因此必须在`throws`子句中指定它。
 
 调用此`findFile()`方法的方法需要处理此异常，或者自己使用`throws`关键字指定该异常。
 

docs/java/53.md

@@ -8,7 +8,7 @@
 
 让我们举个例子。
 
-### 示例 1：多个捕获块
+### 示例 1：多个`catch`块
 
 ```java
 class Main {
@@ -42,7 +42,7 @@ class Main {
 
 * * *
 
-## 在 catch 块中处理多个异常
+## 在`catch`块中处理多个异常
 
 在 Java SE 7 和更高版本中，我们现在可以在单个`catch`块中捕获多种类型的异常。
 
@@ -58,7 +58,7 @@ try {
 } 
 ```
 
-### 示例 2：多捕获块
+### 示例 2：多`catch`块
 
 ```java
 class Main {
@@ -83,7 +83,7 @@ class Main {
 
 编译此程序时生成的字节代码将比具有多个`catch`块的程序小，因为没有代码冗余。
 
-**注意**：如果`catch`块处理多个异常，则 catch 参数隐式为`final`。 这意味着我们不能分配任何值来捕获参数。
+**注意**：如果`catch`块处理多个异常，则`catch`参数隐式为`final`。 这意味着我们不能分配任何值来捕获参数。
 
 * * *
 

docs/java/54.md

-# Java 试用资源
+# Java `try-with-resources`
 
 > 原文： [https://www.programiz.com/java-programming/try-with-resources](https://www.programiz.com/java-programming/try-with-resources)
 
-#### 在本教程中，我们将学习 try-with-resources 语句以自动关闭资源。
+#### 在本教程中，我们将学习`try-with-resources`语句以自动关闭资源。
 
 `try-with-resources`语句在语句末尾自动关闭所有资源。 资源是程序结束时要关闭的对象。
 
@@ -21,13 +21,13 @@ try (resource declaration) {
 1.  在`try`子句中声明和实例化资源。
 2.  指定并处理关闭资源时可能引发的所有异常。
 
-**注意**： try-with-resources 语句关闭实现 [AutoCloseable 接口](https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html)的所有资源。
+**注意**： `try-with-resources`语句关闭实现[`AutoCloseable`接口](https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html)的所有资源。
 
 * * *
 
 让我们以实现`try-with-resources`语句的示例为例。
 
-### 示例 1：try-with-resources
+### 示例 1：`try-with-resources`
 
 ```java
 import java.io.*;
@@ -46,13 +46,13 @@ class Main {
 } 
 ```
 
-**如果未找到 test.txt 文件，则输出。**
+**如果未找到`test.txt`文件，则输出。**
 
 ```java
 IOException in try-with-resources block =>test.txt (No such file or directory) 
 ```
 
-**如果找到 test.txt 文件，则输出。**
+**如果找到`test.txt`文件，则输出。**
 
 ```java
 Entering try-with-resources block
@@ -63,7 +63,7 @@ Line =>test line
 
 在`try-with-resources`语句中声明并实例化`BufferedReader`可以确保无论`try`语句正常完成还是引发异常，都关闭其实例。
 
-如果发生异常，则可以使用异常处理块或 [throws 关键字](https://www.programiz.com/java-programming/throw-throws)进行处理。
+如果发生异常，则可以使用异常处理块或[`throws`关键字](https://www.programiz.com/java-programming/throw-throws)进行处理。
 
 * * *
 
@@ -98,15 +98,15 @@ catch(IOException e) {
 
 ## 使用尝试资源的优势
 
-这是使用 try-with-resources 的优点：
+这是使用`try-with-resources`的优点：
 
-### 1.最终阻止不需要关闭资源
+### 1.`finally`块不需要关闭资源
 
 在 Java 7 引入此功能之前，我们必须使用`finally`块来确保关闭资源以避免资源泄漏。
 
-这是一个类似于**示例 1** 的程序。 但是，在此程序中，我们使用了 finally 块来关闭资源。
+这是一个类似于**示例 1** 的程序。 但是，在此程序中，我们使用了`finally`块来关闭资源。
 
-### 示例 2：使用 finally 块关闭资源
+### 示例 2：使用`finally`块关闭资源
 
 ```java
 import java.io.*;
@@ -159,7 +159,7 @@ Entering finally block
 
 我们可以用分号`;`分隔`try-with-resources`语句中的多个资源
 
-### 示例 3：尝试使用多种资源
+### 示例 3：`try-with-resources`和多种资源
 
 ```java
 import java.io.*;
@@ -182,7 +182,7 @@ class Main {
 
 * * *
 
-## Java 9 尝试资源增强
+## Java 9 `try-with-resources`增强
 
 在 Java 7 中，`try-with-resources`语句受到限制。 该资源需要在其块内本地声明。
 

docs/java/55.md

@@ -23,7 +23,7 @@ Java 注解是程序源代码的元数据（有关数据的数据）。
 
 覆盖方法时，并非必须使用`@Override`。 但是，如果使用它，则在覆盖该方法时，如果出现错误（例如错误的参数类型），则编译器将给出错误。
 
-### 示例 1：@Override 注释示例
+### 示例 1：`@Override`注释示例
 
 ```java
 class Animal {
@@ -85,7 +85,7 @@ I am a dog.
 
 单个元素注释仅包含一个元素。
 
-Its syntax is:
+它的语法是：
 
 ```java
 @AnnotationName(elementName = "elementValue")
@@ -112,7 +112,7 @@ Its syntax is:
 
 这些注释包含多个用逗号分隔的元素。
 
-Its syntax is:
+它的语法是：
 
 ```java
 @AnnotationName(element1 = "value1", element2 = "value2")
@@ -129,7 +129,7 @@ Its syntax is:
 
 如上所述，Java 注释可以放在类，方法，接口，字段和其他程序元素声明的上方。
 
-### 示例 2：@SuppressWarnings 注释示例
+### 示例 2：`@SuppressWarnings`注释示例
 
 ```java
 import java.util.*;
@@ -270,4 +270,4 @@ public String readMethod() throws @Localized IOException
 
 *   **编译器指令**-注释可用于向编译器提供指令，检测错误或禁止警告。 内置注释`@Deprecated`，`@Override`和`@SuppressWarnings`用于这些目的。
 *   **编译时指令**-这些注解提供的编译时指令可帮助软件构建工具生成代码，XML 文件等。
-*   **运行时指令**-可以定义一些注释以在运行时向程序提供指令。 这些注解是使用 Java Reflection 访问的。
\ No newline at end of file
+*   **运行时指令**-可以定义一些注释以在运行时向程序提供指令。 这些注解是使用 Java 反射访问的。
\ No newline at end of file

docs/java/56.md

@@ -56,7 +56,7 @@ accessModifier returnType deprecatedMethodName() { ... }
 accessModifier returnType deprecatedMethodName() { ... } 
 ```
 
-### 示例 1：@Deprecated 注释示例
+### 示例 1：`@Deprecated`注释示例
 
 ```java
 class Main {
@@ -89,7 +89,7 @@ Deprecated method
 
 覆盖方法时，并非必须使用`@Override`。 但是，如果使用它，则在覆盖该方法时，如果出现错误（例如错误的参数类型），则编译器将给出错误。
 
-### 示例 2：@Override 注释示例
+### 示例 2：`@Override`注释示例
 
 ```java
 class Animal {
@@ -173,7 +173,7 @@ For example,
 @SuppressWarnings("someundefinedwarning") 
 ```
 
-### 示例 3：@SuppressWarnings 注释示例
+### 示例 3：`@SuppressWarnings`注释示例
 
 ```java
 class Main {
@@ -200,15 +200,15 @@ Deprecated method
 
 * * *
 
-### 4\. @SafeVarargs
+### 4\. `@SafeVarargs`
 
-`@SafeVarargs`注解断言，带注释的方法或构造器不会对其 varargs（可变数量的参数）执行不安全的操作。
+`@SafeVarargs`注解断言，带注释的方法或构造器不会对其可变参数（可变数量的参数）执行不安全的操作。
 
 我们只能在不能被覆盖的方法或构造器上使用此注释。 这是因为覆盖它们的方法可能执行不安全的操作。
 
-在 Java 9 之前，我们只能在 final 或 static 方法上使用此注解，因为它们不能被覆盖。 现在，我们也可以将此注释用于私有方法。
+在 Java 9 之前，我们只能在`final`或`static`方法上使用此注解，因为它们不能被覆盖。 现在，我们也可以将此注释用于私有方法。
 
-### 示例 4：@SafeVarargs 注释示例
+### 示例 4：`@SafeVarargs`注释示例
 
 ```java
 import java.util.*;
@@ -262,7 +262,7 @@ Note: Main.java uses unchecked or unsafe operations.
 
 ```
 
-我们得到相同的输出，但没有任何警告。 当使用此注解时，未经检查的警告也会被删除。
+我们得到相同的输出，但没有任何警告。 当使用此注解时，非受检的警告也会被删除。
 
 * * *
 
@@ -270,7 +270,7 @@ Note: Main.java uses unchecked or unsafe operations.
 
 Java 8 首先引入了此`@FunctionalInterface`注解。 该注释指示使用它的类型声明是一个功能接口。 一个功能接口只能有一个抽象方法。
 
-### 示例 5：@FunctionalInterface 注释示例
+### 示例 5：`@FunctionalInterface`注释示例
 
 ```java
 @FunctionalInterface
@@ -318,7 +318,7 @@ public interface MyFuncInterface{
 
 也可以创建我们自己的自定义注释。
 
-Its syntax is:
+它的语法是：
 
 ```java
 [Access Specifier] @interface<AnnotationName> {         
@@ -370,7 +370,7 @@ Test method 1
 
 `@Retention`注解指定注释可以使用的级别。
 
-Its syntax is:
+它的语法是：
 
 ```java
 @Retention(RetentionPolicy) 
@@ -378,9 +378,9 @@ Its syntax is:
 
 保留策略有 3 种类型：
 
-*   **RetentionPolicy.SOURCE** -注释仅在源级别可用，并且被编译器忽略。
-*   **RetentionPolicy.CLASS** -注释在编译时可供编译器使用，但被 Java 虚拟机（JVM）忽略。
-*   **RetentionPolicy.RUNTIME** -注释可用于 JVM。
+*   **`RetentionPolicy.SOURCE`** - 注释仅在源级别可用，并且被编译器忽略。
+*   **`RetentionPolicy.CLASS`** - 注释在编译时可供编译器使用，但被 Java 虚拟机（JVM）忽略。
+*   **`RetentionPolicy.RUNTIME`** - 注释可用于 JVM。
 
 For example,
 
@@ -408,7 +408,7 @@ public @interface MyCustomAnnotation{ ... }
 
 我们可以使用`@Target`注解将注释限制为应用于特定目标。
 
-Its syntax is:
+它的语法是：
 
 ```java
 @Target(ElementType) 
@@ -443,7 +443,7 @@ public @interface MyCustomAnnotation{ ... }
 
 默认情况下，注释类型不能从超类继承。 但是，如果需要将注释从超类继承到子类，则可以使用`@Inherited`注解。
 
-Its syntax is:
+它的语法是：
 
 ```java
 @Inherited 

docs/java/57.md

-# Java 记录
+# Java 日志
 
 > 原文： [https://www.programiz.com/java-programming/logging](https://www.programiz.com/java-programming/logging)
 
@@ -156,15 +156,15 @@ Handler[] handlers = logger.getHandlers();
 
 * * *
 
-### 4.格式化程序
+### 4.格式化器
 
-处理程序还可以使用**格式化程序**将 **LogRecord** 对象格式化为字符串，然后再将其导出到外部系统。
+处理程序还可以使用**格式化器**将`LogRecord`对象格式化为字符串，然后再将其导出到外部系统。
 
-Java SE 具有两个内置的**格式化程序**：
+Java SE 具有两个内置的**格式化器**：
 
-| 格式化程序 | Use |
-| `SimpleFormatter` | 将 **LogRecord** 格式化为字符串 |
-| `XMLFormatter` | 将 **LogRecord** 格式转换为 XML 格式 |
+| 格式化器 | Use |
+| `SimpleFormatter` | 将`LogRecord`格式化为字符串 |
+| `XMLFormatter` | 将`LogRecord`格式转换为 XML 格式 |
 
 我们可以使用以下代码来格式化处理程序：
 
@@ -194,7 +194,7 @@ LogManager manager = new LogManager();
 
 ## 记录的优点
 
-这是使用 Java 登录的一些优点。
+这是使用 Java 日志的一些优点。
 
 *   帮助监控程序的流程
 *   帮助捕获可能发生的任何错误

docs/java/58.md

@@ -14,7 +14,7 @@ Java 断言通过测试代码来检测错误，我们认为这是正确的。
 assert condition;
 ```
 
-在这里，`condition`是一个布尔表达式，我们假定在程序执行时为 true。
+在这里，`condition`是一个布尔表达式，我们假定在程序执行时为`true`。
 
 * * *
 
@@ -119,7 +119,7 @@ java -ea
 
 **在类名**中启用断言
 
-为了对程序 Main 的所有类启用断言，
+为了对程序`Main`的所有类启用断言，
 
 ```java
 java -ea Main
@@ -143,7 +143,7 @@ java -ea:com.animal... Main
 
 **启用未命名包中的断言**
 
-要在当前工作目录中的未命名包中启用断言（当我们不使用 package 语句时）。
+要在当前工作目录中的未命名包中启用断言（当我们不使用`package`语句时）。
 
 ```java
 java -ea:... Main
@@ -224,7 +224,7 @@ void unreachableCodeMethod() {
 } 
 ```
 
-让我们再举一个不带默认大小写的 switch 语句示例。
+让我们再举一个不带默认大小写的`switch`语句示例。
 
 ```java
 switch (dayOfWeek) {
@@ -252,7 +252,7 @@ switch (dayOfWeek) {
 } 
 ```
 
-上面的 switch 语句指示星期几只能是上述 7 个值之一。 没有默认情况意味着程序员认为这些情况之一将始终被执行。
+上面的`switch`语句指示星期几只能是上述 7 个值之一。 没有默认情况意味着程序员认为这些情况之一将始终被执行。
 
 但是，在某些假设实际上是错误的情况下，可能尚未考虑某些情况。
 
@@ -320,7 +320,7 @@ ArrayList<String> weekends= new ArrayList<>(Arrays.asList("Sunday", "Saturday" )
 assert weekdays.removeAll(weekends); 
 ```
 
-在这里，我们试图从工作日的 ArrayList `中删除元素`Saturday`和`Sunday`。`
+在这里，我们试图从工作日的`ArrayList`中删除元素`Saturday`和`Sunday`。
 
 如果启用了断言，则程序可以正常运行。 但是，如果禁用了断言，则不会删除列表中的元素。 这可能会导致程序失败。