2020-05-22 14:11:07

docs/java/103.md

@@ -87,7 +87,7 @@ Private Constructor
 2.  构造器定义中不能有任何返回类型。
 3.  构造器中不能有任何 return 语句。
 4.  构造器可以由不同的参数重载。
-5.  如果要使用`super()`，即超级类构造器，则它必须是构造器中的第一条语句。
+5.  如果要使用`super()`，即超类构造器，则它必须是构造器中的第一条语句。
 
 ## 构造器链接
 

docs/java/113.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/oops/multiple-inheritance-in-java/](https://howtodoinjava.com/oops/multiple-inheritance-in-java/)
 
-正如我们早已了解到的那样，Java 中不直接支持**多重继承**，而直到 Java 7 才支持。 [Java 8](https://howtodoinjava.com/java-8-tutorial/) 可以通过不带有[**钻石问题**](https://howtodoinjava.com/oops/java-inheritance/)的[默认方法](https://howtodoinjava.com/java8/default-methods-in-java-8/)实现**多继承**的概念。
+正如我们早已了解到的那样，Java 中不直接支持**多重继承**，而直到 Java 7 才支持。 [Java 8](https://howtodoinjava.com/java-8-tutorial/) 可以通过不带有[**菱形问题**](https://howtodoinjava.com/oops/java-inheritance/)的[默认方法](https://howtodoinjava.com/java8/default-methods-in-java-8/)实现**多继承**的概念。
 
 让我们看看如何？
 

docs/java/213.md

@@ -53,7 +53,7 @@ catch(Exception e) {
 
 ```
 
-#### 1.3 终于封锁
+#### 1.3 `finally`块
 
 可选的 finally 块使我们有机会在每次 try-catch 块完成时运行我们要执行的代码-有错误或无错误。
 
@@ -312,6 +312,6 @@ catch (IOException e)
 
 ```
 
-<blockqute>阅读更多信息： [Java 7 资源尝试版](https://howtodoinjava.com/java7/try-with-resources/)</blockqute>
+<blockqute>阅读更多信息： [Java 7 `try-with-resource`版](https://howtodoinjava.com/java7/try-with-resources/)</blockqute>
 
 学习愉快！
\ No newline at end of file

docs/java/222.md

@@ -131,7 +131,7 @@ public class GenericsExamples
 
 ```
 
-我们可以在篮子内添加苹果，甚至是亚洲苹果，但不能在篮子中添加 Fruit（苹果的超级类型）。 为什么？
+我们可以在篮子内添加苹果，甚至是亚洲苹果，但不能在篮子中添加 Fruit（苹果的超类型）。 为什么？
 
 原因是购物篮是**对 Apple** 的超类商品列表的引用。 同样，**我们不知道它是**是哪个超类型，但是我们知道可以将 Apple 及其任何子类型（它们是 Fruit 的子类型）添加为没有问题（您可以随时在超类的集合中添加一个子类）。 因此，现在我们可以在购物篮中添加任何类型的 Apple。
 

docs/java/228.md

@@ -39,7 +39,7 @@ Table of contents
 3.  **删除类** – 将流中的类层次结构与当前类的层次结构进行比较可以检测到某个类已被删除。 在这种情况下，从该流中读取与该类相对应的字段和对象。 [原始字段](https://howtodoinjava.com/java/basics/primitive-data-types-in-java/)被丢弃，但是创建了由已删除类引用的对象，因为可以在流中稍后引用它们。 当流被垃圾回收或重置时，它们将被垃圾回收。
 4.  **添加 writeObject / readObject 方法** – 如果读取流的版本具有这些方法，则通常希望 readObject 读取通过默认序列化写入流中的所需数据。 在读取任何可选数据之前，应先调用 defaultReadObject。 通常，writeObject 方法将调用 defaultWriteObject 写入所需的数据，然后再写入可选数据。
 5.  **删除 writeObject / readObject 方法** – 如果读取流的类没有这些方法，则默认情况下将序列化读取所需数据，而可选数据将被丢弃。
-6.  **添加 java.io.Serializable** – 这等同于添加类型。 该类的流中将没有任何值，因此其字段将被初始化为默认值。 对子类化不可序列化类的支持要求该类的超级类型具有 no-arg 构造器，并且该类本身将被初始化为默认值。 如果 no-arg 构造器不可用，则抛出`InvalidClassException`。
+6.  **添加 java.io.Serializable** – 这等同于添加类型。 该类的流中将没有任何值，因此其字段将被初始化为默认值。 对子类化不可序列化类的支持要求该类的超类型具有 no-arg 构造器，并且该类本身将被初始化为默认值。 如果 no-arg 构造器不可用，则抛出`InvalidClassException`。
 7.  **更改对字段的访问** – 公共，打包，保护和私有的[访问修饰符](https://howtodoinjava.com/oops/java-access-modifiers/)对序列化为字段分配值的能力没有影响。
 8.  **将字段从静态更改为非静态，或将瞬态更改为非瞬态** – 当依赖默认序列化来计算可序列化字段时，此更改等效于将字段添加到类中。 新字段将被写入流，但是较早的类将忽略该值，因为序列化不会为[静态](https://howtodoinjava.com/java/basics/java-static-keyword/)或[瞬态](https://howtodoinjava.com/java/basics/transient-keyword-in-java-with-real-time-example/)字段分配值。
 

docs/java/233.md

@@ -48,7 +48,7 @@ public static void main(java.lang.String[]);
 
 上面的字节码看起来很真实，不是吗？ 在第一行中，我们将把“局部变量表”中的值压入堆栈。 在这种情况下，我们实际上只是将隐式引用推到“ this”，因此它并不是最令人兴奋的说明。 第二条指令是主要内容。 实际上，它**调用了最高级类的构造器，在上述情况下，它是 Object.java** 。 一旦调用了最高级类的构造器（即本例中的对象），其余的代码就会执行用代码编写的特定指令。
 
-符合以上概念，即最高级的构造器，我们在反序列化中也有类似的概念。 在反序列化过程中，要求实例的所有**父类均应可序列化； 如果层次结构中的任何超类都不可序列化，则它必须具有默认构造器**。 现在有道理了。 因此，在反序列化时，将首先搜索超级类，直到找到任何不可序列化的类。 如果所有超类都可以序列化，那么 JVM 最终会到达 Object 类本身，并首先创建 Object 类的实例。 如果在搜索超类之间，发现任何无法序列化的类，则将使用其默认构造器在内存中分配实例。
+符合以上概念，即最高级的构造器，我们在反序列化中也有类似的概念。 在反序列化过程中，要求实例的所有**父类均应可序列化； 如果层次结构中的任何超类都不可序列化，则它必须具有默认构造器**。 现在有道理了。 因此，在反序列化时，将首先搜索超类，直到找到任何不可序列化的类。 如果所有超类都可以序列化，那么 JVM 最终会到达 Object 类本身，并首先创建 Object 类的实例。 如果在搜索超类之间，发现任何无法序列化的类，则将使用其默认构造器在内存中分配实例。
 
 If any super class of instance to be de-serialized in non-serializable and also does not have a default constructor then the ‘**NotSerializableException**‘ is thrown by JVM.
 

docs/java/91.md

@@ -36,11 +36,11 @@ public class ElvisOperatorTest {
 }
 ```
 
-## [使用 try-with-resources 的自动资源管理](//howtodoinjava.com/java-7/automatic-resource-management-with-try-with-resources-in-java-7/ "Automatic resource management with try-with-resources in java 7")
+## 使用`try-with-resources`的自动资源管理
 
-在 Java 7 之前，我们必须使用 finally 块来清理资源。 最后，块不是强制性的，但是清理资源是为了防止系统损坏。 使用 Java 7，无需显式的资源清理。 它是自动完成的。 在 try-with-resources 块（try（…）{…}）中初始化资源时，将完成自动资源清除。
+在 Java 7 之前，我们必须使用`finally`块来清理资源。 `finally`块不是强制性的，但是清理资源是为了防止系统损坏。 使用 Java 7，无需显式的资源清理。 它是自动完成的。 在`try-with-resources`块（`try(…){…}`）中初始化资源时，将完成自动资源清除。
 
-由于新接口`AutoCloseable`而进行清理。 try 块完成后，JVM 将立即调用其 close 方法。 您不应在代码中调用 **close（）**方法。 这应该自动称为 JVM。 手动调用它可能会导致意外结果。
+由于新接口`AutoCloseable`而进行清理。 `try`块完成后，JVM 将立即调用其 `close`方法。 您不应在代码中调用`close()`方法。 这应该自动称为 JVM。 手动调用它可能会导致意外结果。
 
 ```java
 public class ResourceManagementInJava7
@@ -64,7 +64,7 @@ public class ResourceManagementInJava7
 
 ```
 
-## [NIO 2.0](//howtodoinjava.com/category/java-7-features/nio/ "nio 2")
+## NIO 2.0
 
 Java SE 7 引入了`java.nio.file`软件包及其相关软件包`java.nio.file.attribute`，为文件 I/O 和访问默认文件系统提供了全面的支持。 路径类是一个很大的补充，它允许您以统一的方式表示操作系统中的任何路径。 新的 API 是对旧 API 的补充，并提供了一些有用的方法检查，删除，复制和移动文件。 您也可以像在 Linux 中那样创建符号链接和硬链接。 JDK 7 新文件 API 还能够使用通配符/正则表达式搜索文件。 您还将获得支持以查看目录中的更改。
 
@@ -74,9 +74,9 @@ Java SE 7 引入了`java.nio.file`软件包及其相关软件包`java.nio.file.a
 
 Java 7 在异常处理方面也带来了一些不错的增强。 这些可以大致分为两个功能：
 
-## [受抑制的异常](//howtodoinjava.com/java-7/suppressed-exceptions-in-java-7/ "Suppressed exceptions in java 7")
+## 受抑制的异常
 
-顾名思义，抑制的异常是在代码中引发的异常，但是以某种方式被忽略。 如果您还记得 try-catch-finally 块的执行顺序以及它们如何返回任何值或异常，则您会记得，在 try 块中也抛出异常的情况下，抑制了 finally 块中引发的异常。 在 Java 7 之前的版本中，通过记录日志了解了这些异常（如果已实现），但是一旦最终阻止结束，您就无法控制这些异常类型。 使用 Java 7 中的新功能，您还可以控制这些受抑制的异常。
+顾名思义，抑制的异常是在代码中引发的异常，但是以某种方式被忽略。 如果您还记得`try-catch-finally`块的执行顺序以及它们如何返回任何值或异常，则您会记得，在`try`块中也抛出异常的情况下，抑制了`finally`块中引发的异常。 在 Java 7 之前的版本中，通过记录日志了解了这些异常（如果已实现），但是一旦`finally`块结束，您就无法控制这些异常类型。 使用 Java 7 中的新功能，您还可以控制这些受抑制的异常。
 
 用法示例如下：
 
@@ -152,9 +152,9 @@ Exception encountered: java.lang.NullPointerException: Remember me. I am your wo
 
 阅读有关链接文章的更多信息。
 
-## [在 catch 块](//howtodoinjava.com/java-7/improved-exception-handling-in-java-7/ "Improved exception handling in Java 7")中捕获多个异常
+## 在`catch`块中捕获多个异常
 
-在此功能中，现在您可以在单个 catch 块中捕获多个异常。 在 Java 7 之前，您只能捕获一个。 要指定期望的例外列表，请使用竖线（|）。
+在此功能中，现在您可以在单个`catch`块中捕获多个异常。 在 Java 7 之前，您只能捕获一个。 要指定期望的例外列表，请使用竖线（`|`）。
 
 让我们来看一个例子。
 
@@ -173,13 +173,13 @@ catch(NullPointerException | IndexOutOfBoundsException ex)
 
 ```
 
-Remember: If a catch block handles more than one exception type, then the catch parameter is implicitly final. In this example, the catch parameter ex is final and therefore you cannot assign any values to it within the catch block.
+请记住：如果`catch`块处理多个异常类型，则`catch`参数隐式为`final`。 在此示例中，`catch`参数`ex`是最终的，因此您不能在`catch`块中为其分配任何值。
 
-## [数字格式增强功能](//howtodoinjava.com/java-7/improved-formatted-numbers-in-java-7/ "Improved formatted numbers in java 7")
+## 数字格式增强功能
 
-如果必须读取数字“ 1000000”，那么在第一个站点中读取该数字有多方便。 不多吧？ 我们习惯于以 10,00,000 格式读取数字。 好消息是 Java 已经开始支持以这种格式写数字。 好吧，不完全是这样，而是匹配的格式。
+如果必须读取数字“1000000”，那么在第一个站点中读取该数字有多方便。 不多吧？ 我们习惯于以`10,00,000`格式读取数字。 好消息是 Java 已经开始支持以这种格式写数字。 好吧，不完全是这样，而是匹配的格式。
 
-现在，您可以像上面这样写上面的数字：10_00_000。 足够好了，不是吗？
+现在，您可以像上面这样写上面的数字：`10_00_000`。 足够好了，不是吗？
 
 ```java
 /**
@@ -201,9 +201,9 @@ float improvedDouble = 10_00_000;
 
 ```
 
-## [switch 语句](//howtodoinjava.com/java-7/string-class-is-supported-in-switch-statement-in-java-7/ "String class is supported in switch statement in java 7")中的字符串类支持
+## `switch`语句中的字符串类支持
 
-如果您还记得 java 7 之前的 switch 语句，则它仅支持 int 和`enum`类型。 现在，随着 Java 7 的发布，还添加了对 String 类的支持。 让我们来看一个例子。
+如果您还记得 java 7 之前的`switch`语句，则它仅支持`int`和`enum`类型。 现在，随着 Java 7 的发布，还添加了对`String`类的支持。 让我们来看一个例子。
 
 ```java
 switch (token)
@@ -226,9 +226,9 @@ switch (token)
 
 ```
 
-## 前缀为“ 0b”的二进制字面值
+## 前缀为`0b`的二进制字面值
 
-在 JDK 7 中，您可以为整数类型（字节，短型，整型和长型）以前缀“ 0b”（或“ 0B”）以二进制形式表示字面值值。 在 JDK 7 之前，您只能使用八进制值（前缀为“ 0”）或十六进制值（前缀为“ 0x”或“ 0X”）。 例如
+在 JDK 7 中，您可以为整数类型（字节，短型，整型和长型）以前缀`0b`（或`0B`）以二进制形式表示字面值。 在 JDK 7 之前，您只能使用八进制值（前缀为`0`）或十六进制值（前缀为`0x`或`0X`）。 例如：
 
 ```java
 int sameVarOne = 0b01010000101;
@@ -239,9 +239,9 @@ int sameVarTwo = 0B01_010_000_101;
 
 ```
 
-## [ForkJoin 框架](//howtodoinjava.com/java-7/forkjoin-framework-tutorial-forkjoinpool-example/ "Fork/Join Framework Tutorial: ForkJoinPool Example")
+## ForkJoin 框架
 
-在 Java 程序中有效使用并行内核一直是一个挑战。 很少有本地框架可以将工作分配到多个核心，然后将它们加入以返回结果集。 Java 7 已将此功能作为 Fork and Join 框架合并。
+在 Java 程序中有效使用并行内核一直是一个挑战。 很少有本地框架可以将工作分配到多个核心，然后将它们加入以返回结果集。 Java 7 已将此功能作为 Fork 和 Join 框架合并。
 
 基本上，Fork-Join 将手头的任务分解为多个小任务，直到该小任务足够简单，可以将其解决而无需进一步拆分。 这就像分而治之的算法。 在此框架中要注意的一个重要概念是，理想情况下，没有工作线程处于空闲状态。 他们实现了一种工作窃取算法，即闲置的工人从忙碌的工人那里窃取了工作。
 
@@ -260,17 +260,17 @@ Result solve(Problem problem) {
 }
 ```
 
-## [使用 WatchService](//howtodoinjava.com/java-7/auto-reload-of-configuration-when-any-change-happen/ "Auto reload of configuration when any change happen") 自动重新加载
+## 使用`WatchService`自动重新加载
 
 每个应用程序都有一些配置，预期配置文件中的每次更改都会刷新该配置。 解决该问题的过去方法包括拥有一个线程，该线程根据配置文件的“最新更新时间戳”定期轮询文件更改。
 
-现在使用 Java 7，情况已经改变。 Java 7 引入了一项出色的功能：`WatchService`。 `WatchService`是 JDK 的内部服务，监视注册对象的更改。 这些注册的对象必定是`Watchable`接口的实例。 向 WatchService 注册可监视实例时，我们需要指定我们感兴趣的更改事件的类型。
+现在使用 Java 7，情况已经改变。 Java 7 引入了一项出色的功能：`WatchService`。 `WatchService`是 JDK 的内部服务，监视注册对象的更改。 这些注册的对象必定是`Watchable`接口的实例。 向`WatchService`注册可监视实例时，我们需要指定我们感兴趣的更改事件的类型。
 
 链接的文章中提供了`WatchService`的示例用法。
 
 ## G1 垃圾收集器
 
-JDK 7 引入了一个称为 G1 Garbage Collection 的新垃圾收集器，它是垃圾的缩写形式。 G1 垃圾收集器在垃圾最多的地方执行清理。 为此，它将 Java 堆内存划分为多个区域，而不是 Java 7 版本之前的 3 个区域（新旧空间）。 G1 完全可以预测，并且可以为内存密集型应用程序提供更高的吞吐量。
+JDK 7 引入了一个称为 G1 的新垃圾收集器，它是垃圾的缩写形式。 G1 垃圾收集器在垃圾最多的地方执行清理。 为此，它将 Java 堆内存划分为多个区域，而不是 Java 7 版本之前的 3 个区域（新旧空间）。 G1 完全可以预测，并且可以为内存密集型应用程序提供更高的吞吐量。
 
 这就是此快速摘要的全部内容。 您可以在此链接中找到功能的完整列表。
 

docs/java/92.md

@@ -4,7 +4,7 @@
 
 在 [Java 7](https://howtodoinjava.com/java7/java-7-changes-features-and-enhancements/) 之前，在使用[泛型](https://howtodoinjava.com/java/generics/complete-java-generics-tutorial/)时，我们必须为变量类型及其实际类型提供类型参数。 现在，此新的 Java 7 功能已使它有所缓解。 声明右侧的空白 **Java 菱形运算符**可以正常工作。
 
-菱形算子用两个角度`'< >'`表示。
+菱形运算符用两个角度`'< >'`表示。
 
 ## 1\. 在泛型之前 – 原始类型声明
 
@@ -30,11 +30,11 @@ Map<String, Integer> params = new HashMap<String, Integer>();
 
 您需要修复代码才能通过编译器。
 
-## 3\. 钻石算子
+## 3\. 菱形运算符
 
 参数化类型可以解决问题，但由于双方重复使用相同的类型信息，因此看起来很繁琐。 如果我们可以在一侧提供类型信息，而另一侧可以检测并应用类型信息，则可以减少语法。
 
-**Java** 中的 Diamond 运算符执行完全相同的操作。 也称为 **Elvis 运算符**。 在下面查看**菱形运算符语法**。
+**Java** 中的菱形运算符执行完全相同的操作。 也称为 **Elvis 运算符**。 在下面查看**菱形运算符语法**。
 
 ```java
 Map<String, Integer> params = new HashMap<>();
@@ -51,8 +51,8 @@ Map<String, Integer> params = new HashMap<>();
 ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized
 ```
 
-快乐的学习！
+学习快乐！
 
 阅读更多：
 
-维基中的 [Diamond 运算符](https://en.wikipedia.org/wiki/Diamond_operator)
\ No newline at end of file
+维基中的[菱形运算符](https://en.wikipedia.org/wiki/Diamond_operator)
\ No newline at end of file

docs/java/93.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://howtodoinjava.com/java7/strings-in-switch-statement/](https://howtodoinjava.com/java7/strings-in-switch-statement/)
 
-**Switch 语句**也早于 Java 7，但它仅支持`int`和`enum`类型。 在 Java 7 发布之后，Switch 语句也支持 [**字符串**](https://howtodoinjava.com/java-string/) 类。
+**`Switch`语句**也早于 Java 7，但它仅支持`int`和`enum`类型。 在 Java 7 发布之后，`Switch`语句也支持[**字符串**](https://howtodoinjava.com/java-string/)类。
 
 ## 1\. 带字符串的 Java `switch case`
 
@@ -61,11 +61,11 @@ No token was identified
 
 ## 2\. Java `switch case`处理多个条件
 
-有时，我们想对 switch 语句中的**多个案例**执行某些操作。 在这种情况下，我们可以在单独的情况下写入每个值，并且只有在所有情况都写完之后，才写下应用程序逻辑。
+有时，我们想对`switch`语句中的多个`case`执行某些操作。 在这种情况下，我们可以在单独的情况下写入每个值，并且只有在所有情况都写完之后，才写下应用程序逻辑。
 
 例如，在给定程序中，所有奇数令牌将由第一个切换条件处理，偶数令牌将由第二个切换条件处理。
 
-具有多个条件的**`switch case`的 Java 示例。**
+具有多个条件的`switch case`的 Java 示例。
 
 ```java
 public class StringSupportedInSwitch {
@@ -110,6 +110,6 @@ Even token identified
 
 ```
 
-在此示例中，我们学习了将 **Java switch 语句与字符串**结合使用。 [Java 7 中引入了此功能。](https://howtodoinjava.com/java7/java-7-changes-features-and-enhancements/)
+在此示例中，我们学习了将 **Java `switch`语句与字符串**结合使用。 [Java 7 中引入了此功能。](https://howtodoinjava.com/java7/java-7-changes-features-and-enhancements/)
 
 学习愉快！
\ No newline at end of file

docs/java/94.md

-# Java 7 中的 try-with-resources
+# Java 7 中的`try-with-resources`
 
 > 原文： [https://howtodoinjava.com/java7/try-with-resources/](https://howtodoinjava.com/java7/try-with-resources/)
 
-[**Java 7**](//howtodoinjava.com/category/java-7/ "java 7 features") 为懒惰的 Java 开发人员带来了一些非常好的功能。 **资源尝试**是这样的功能之一，它可以减少代码行，并使代码更健壮。 在本教程中，我将讨论有关此功能的内容。
+[**Java 7**](//howtodoinjava.com/category/java-7/ "java 7 features") 为懒惰的 Java 开发人员带来了一些非常好的功能。`try-with-resource`是这样的功能之一，它可以减少代码行，并使代码更健壮。 在本教程中，我将讨论有关此功能的内容。
 
 ![java 7 features](img/e9fe6328c61ba53c0ce97bd60ab88afd.png "java 7 features")
 
@@ -56,13 +56,13 @@ public class ResourceManagementBeforeJava7
 
 这些类型的代码在具有大量 IO 操作的应用程序代码库中非常常见。
 
-try 和 catch 块中的代码本质上很重要，并且具有一些特定于应用程序的逻辑。 但是，终于封锁了吗？ **在大多​​数情况下，最后只是复制粘贴了**块，目的是通过关闭它们来避免损坏资源。
+`try`和`catch`块中的代码本质上很重要，并且具有一些特定于应用程序的逻辑。 但是，`finally`块呢？ 在大多​​数情况下，最后只是复制粘贴了`finally`块，目的是通过关闭它们来避免损坏资源。
 
-当您有 3-4 个这样的资源要在单个 final 块中关闭时，这些 final 块**看起来更难看。 当我们知道时，您是否认为这些 final 块不必要地存在，我们必须以任何方式关闭资源而没有任何例外情况？**
+当您有 3-4 个这样的资源要在单个`finally`块中关闭时，这些`finally`块看起来更难看。 当我们知道时，您是否认为这些`finally`块不必要地存在，我们必须以任何方式关闭资源而没有任何例外情况？
 
-Java 7 通过 try-with-resources 功能解决了这个问题。
+Java 7 通过`try-with-resources`功能解决了这个问题。
 
-## 使用 try-with-resources 的新方法（语法示例）
+## 使用`try-with-resources`的新方法（语法示例）
 
 现在看看在 Java 7 中打开和关闭资源的新方法。
 
@@ -90,14 +90,14 @@ public class ResourceManagementInJava7
 
 有两件事需要密切注意：
 
-1.  文件资源（BufferedReader）以特殊方式在 try 块中打开（在小括号内）。
-2.  终于块完全消失了。
+1.  文件资源（`BufferedReader`）以特殊方式在`try`块中打开（在小括号内）。
+2.  `finally`块完全消失了。
 
 最后但并非最不重要的一点是，代码看起来很漂亮且易于阅读。 很好，对吗？ 但是实际上是如何工作的？
 
 ## 实际上如何运作？
 
-在 Java 7 中，我们有一个新的超级接口 [**java.lang.AutoCloseable**](https://docs.oracle.com/javase/7/docs/api/java/lang/AutoCloseable.html "AutoCloseable") 。 此接口有一种方法：
+在 Java 7 中，我们有一个新的超接口[**`java.lang.AutoCloseable`**](https://docs.oracle.com/javase/7/docs/api/java/lang/AutoCloseable.html "AutoCloseable")。 此接口有一种方法：
 
 ```java
 void close() throws Exception;
@@ -106,9 +106,9 @@ void close() throws Exception;
 
 Java 文档建议将此接口**实现在不再需要它时必须关闭的任何资源上**。
 
-当我们在特殊的 try-with-resource 块中打开任何此类 AutoCloseable 资源时，在 try 块完成后， **JVM 会对在“ try（）”块**中初始化的所有资源调用此 close（）方法。
+当我们在特殊的`try-with-resource`块中打开任何此类`AutoCloseable`资源时，在`try`块完成后， **JVM 会对在`try()`块**中初始化的所有资源调用此`close()`方法。
 
-例如，BufferedReader 已实现 close（）方法文件如下：
+例如，`BufferedReader`已实现`close()`方法文件如下：
 
 ```java
 public void close() throws IOException {
@@ -171,17 +171,17 @@ CustomResource closed automatically
 
 ```
 
-控制台中的输出清楚地证明，try 块完成后，资源将自动关闭。
+控制台中的输出清楚地证明，`try`块完成后，资源将自动关闭。
 
 ## 最后注意事项
 
-这就是 Java 7 中使用 try-with-resources 进行自动资源管理的全部内容。让我们逐点记下重点：
+这就是 Java 7 中使用`try-with-resources`进行自动资源管理的全部内容。让我们逐点记下重点：
 
-*   在 Java 7 之前，我们必须使用 finally 块来清理资源。 最后，块不是强制性的，但是清理资源是为了防止系统损坏。
+*   在 Java 7 之前，我们必须使用`finally`块来清理资源。 `finally`块不是强制性的，但是清理资源是为了防止系统损坏。
 *   使用 Java 7，无需显式的资源清理。 它是自动完成的。
-*   在 try-with-resources 块（try（…）{…}）中初始化资源时完成自动资源清理。
-*   由于新接口“自动关闭”而发生清除。 try 块完成后，JVM 将立即调用其 close 方法。
-*   如果要在自定义资源中使用此功能，则必须实现 AutoCloseable 接口。 否则程序将无法编译。
-*   您不应在代码中调用 close（）方法。 这应该自动称为 JVM。 手动调用它可能会导致意外结果。
+*   在`try-with-resources`块（`try(…){…}`）中初始化资源时完成自动资源清理。
+*   由于新接口`AutoCloseable`而发生清除。 `try`块完成后，JVM 将立即调用其`close`方法。
+*   如果要在自定义资源中使用此功能，则必须实现`AutoCloseable`接口。 否则程序将无法编译。
+*   您不应在代码中调用`close()`方法。 这应该自动称为 JVM。 手动调用它可能会导致意外结果。
 
 **祝您学习愉快！**
\ No newline at end of file

docs/java/95.md

@@ -4,13 +4,13 @@
 
 [Java 7](https://howtodoinjava.com/java7/java-7-changes-features-and-enhancements/) 通过允许**下划线数字**，以非常令人愉快的方式改进了数字字面值格式。 它使读取数字变得容易，并且当我们在应用程序日志中编写数字字面值时，它们看起来不错。
 
-例如，如果我们必须读取数字“ **1000000** ”，那么它乍看之下有多方便。 不多吧？
+例如，如果我们必须读取数字“**1000000**”，那么它乍看之下有多方便。 不多吧？
 
-我们有一种阅读 **10,00,000** 格式的数字的习惯。 好消息是 Java 已经开始支持以这种格式写数字。 好吧，不完全是这样，而是匹配的格式。
+我们有一种阅读`10,00,000`格式的数字的习惯。 好消息是 Java 已经开始支持以这种格式写数字。 好吧，不完全是这样，而是匹配的格式。
 
 ## 1\. 数字字面值下划线 – 示例
 
-在 Java 7 发布之后，现在我们可以像上面这样写上面的数字： **10_00_000** 。 足够好了，不是！
+在 Java 7 发布之后，现在我们可以像上面这样写上面的数字：`10_00_000`。 足够好了，不是！
 
 下面给出了带有下划线的新格式数字的 Java 程序。
 
@@ -46,10 +46,10 @@ public class ImprovedNumbersInJava7
 
 ## 2\. 数字字面值下划线 – 注释
 
-1.  下划线只能放在数字之间。 我们不能在小数点“'”旁边加上下划线。
-2.  允许连续的下划线。 “ 10___00”是有效数字。
-3.  不允许在数字的最后加上下划线。 “ 1000_”不是有效数字。 它将产生编译时错误。
-4.  在 Java 中，允许在变量名称之前加**下划线。 当您在数字开头加上下划线时，请当心。 它是一个变量，而不是数字。**
+1.  下划线只能放在数字之间。 我们不能在小数点“`.`”旁边加上下划线。
+2.  允许连续的下划线。 `10___00`是有效数字。
+3.  不允许在数字的最后加上下划线。`1000_`不是有效数字。 它将产生编译时错误。
+4.  在 Java 中，允许在变量名称之前加下划线。 当您在数字开头加上下划线时，请当心。 它是一个变量，而不是数字。
 
 学习愉快！