2020-05-19 11:25:42

docs/java/110.md

@@ -48,9 +48,9 @@ abstract class TestAbstractClass
 
 接口是大多数 Java API 的另一个基本构建块。 您将其命名为 集合，I / O 或 SWT，您可以在任何地方看到它们的运行情况。
 
-> 接口定义合同，实现类需要遵守这些合同。
+> 接口定义契约，实现类需要遵守这些契约。
 
-这些合同本质上是未实现的方法。 Java 已经有一个未实现方法的关键字，即 *abstract* 。 Java 提供了任何类都可以实现任何接口的规定，因此接口中声明的所有方法只需公开。
+这些契约本质上是未实现的方法。 Java 已经有一个未实现方法的关键字，即 *abstract* 。 Java 提供了任何类都可以实现任何接口的规定，因此接口中声明的所有方法只需公开。
 
 #### 2.1 接口语法
 
@@ -125,7 +125,7 @@ JDK 设计人员通过制作`HttpServlet`抽象类来解决此问题。 它具
 
 #### 4.2 合约专用介面
 
-现在，让我们看看接口的用法。 **接口仅提供合同，实现类的责任是实现提供给它的每个合同。**
+现在，让我们看看接口的用法。 **接口仅提供契约，实现类的责任是实现提供给它的每个契约。**
 
 如果您只想**定义类**的特征，并且要强制所有实现实体实现这些特征，则该接口是最合适的。
 

docs/java/111.md

@@ -73,7 +73,7 @@ public class Main
 
 ## 2\. 实现关键字
 
-接口是在 Java 中强制执行合同的方法。 它们强制实现类提供某种行为。 要实现接口，类必须使用**实现关键字**。
+接口是在 Java 中强制执行契约的方法。 它们强制实现类提供某种行为。 要实现接口，类必须使用**实现关键字**。
 
 在 Java 中，我们可以实现多个接口。 在这种情况下，类必须实现所有接口的所有方法。 （或将其声明为[抽象](https://howtodoinjava.com/java/basics/abstract-keyword/)）。
 

docs/java/125.md

@@ -8,7 +8,7 @@
 
 需要 Java 虚拟机在其各个线程之间实现**可抢占，基于优先级的调度程序**。 这意味着为 Java 程序中的每个线程分配了一定的优先级，该优先级在明确定义的范围内。 开发人员可以更改此*优先级。 Java 虚拟机永远不会更改线程的优先级，即使该线程已经运行了一段时间。*
 
-优先级值很重要，因为 Java 虚拟机和底层操作系统之间的约定是 ***操作系统通常必须选择以最高优先级*** 运行 Java 线程。 这就是说 Java 实现基于优先级的 [**调度程序**](https://en.wikipedia.org/wiki/Fixed-priority_pre-emptive_scheduling "preemptive scheduling") 时的意思。 此调度程序以抢先方式实现，这意味着，当有一个优先级较低的线程正在运行时，当出现优先级较高的线程时，该线程中断（ ***会抢占*** ）。 但是，与操作系统的合同不是绝对的，这意味着操作系统有时可以选择运行优先级较低的线程。 [我讨厌有关多线程的问题。
+优先级值很重要，因为 Java 虚拟机和底层操作系统之间的约定是 ***操作系统通常必须选择以最高优先级*** 运行 Java 线程。 这就是说 Java 实现基于优先级的 [**调度程序**](https://en.wikipedia.org/wiki/Fixed-priority_pre-emptive_scheduling "preemptive scheduling") 时的意思。 此调度程序以抢先方式实现，这意味着，当有一个优先级较低的线程正在运行时，当出现优先级较高的线程时，该线程中断（ ***会抢占*** ）。 但是，与操作系统的契约不是绝对的，这意味着操作系统有时可以选择运行优先级较低的线程。 [我讨厌有关多线程的问题。
 
 > 还要注意， **java 并没有要求对其线程进行时间分段**，但大多数操作系统都这样做。 这里的术语经常会有一些混乱：抢占经常与时间片混淆。 实际上，**抢占仅意味着运行优先级更高的线程而不是优先级较低的线程**，但是当线程具有相同优先级时，它们不会相互抢占。 它们通常受时间限制，但这不是 Java 的要求。
 

docs/java/139.md

@@ -222,7 +222,7 @@ HashMap 类中的方法列表及其简短描述。
 *   [Java 中 HashMap 和 Hashtable 之间的区别](https://howtodoinjava.com/java/collections/difference-between-hashmap-and-a-hashtable/)
 *   [Java 按键对地图进行排序（升序和降序）](https://howtodoinjava.com/sort/java-sort-map-by-key/)
 *   [Java 按值对地图进行排序（升序和降序）](https://howtodoinjava.com/sort/java-sort-map-by-values/)
-*   [Java hashCode（）和 equals（）-合同，规则和最佳做法](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/)
+*   [Java hashCode（）和 equals（）-契约，规则和最佳做法](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/)
 *   [HashMap 和 ConcurrentHashMap 面试问题](https://howtodoinjava.com/interview-questions/hashmap-concurrenthashmap-interview-questions/)
 *   [Java ConcurrentHashMap 最佳实践](https://howtodoinjava.com/java/multi-threading/best-practices-for-using-concurrenthashmap/)
 *   [将 JSON 转换为 Map 并映射为 JSON](https://howtodoinjava.com/jackson/jackson-json-to-from-hashmap/)

docs/java/208.md

@@ -250,7 +250,7 @@ Direction.EAST.printDirection();  //You are moving in east. You will face sun in
 
 ```
 
-您可以为以这种方式创建的所有枚举强制执行合同。 它可以用作创建枚举的**模板。**
+您可以为以这种方式创建的所有枚举强制执行契约。 它可以用作创建枚举的**模板。**
 
 例如，如果我们希望`Direction`的每个枚举类型都应能够在需要时打印带有自定义消息的路线名称。 这可以通过在`Direction`中定义`abstract`方法来完成，每个枚举都必须重写该方法。 将来，将在更多方向上添加（真的吗？），那么我们还必须添加自定义消息。
 

docs/java/228.md

@@ -22,7 +22,7 @@ Table of contents
 
 对类的不兼容更改是指不能保持互操作性的那些更改。 下面给出了在演化类时可能发生的不兼容更改（考虑默认序列化或[反序列化](https://howtodoinjava.com/java/serialization/how-deserialization-process-happen-in-java/)）：
 
-1.  **删除字段** –如果在类中删除了字段，则写入的流将不包含其值。 当较早的类读取流时，该字段的值将设置为默认值，因为流中没有可用的值。 但是，此默认值可能会不利地损害早期版本履行其合同的能力。
+1.  **删除字段** –如果在类中删除了字段，则写入的流将不包含其值。 当较早的类读取流时，该字段的值将设置为默认值，因为流中没有可用的值。 但是，此默认值可能会不利地损害早期版本履行其契约的能力。
 2.  **将类上移或下移** –不允许这样做，因为流中的数据显示顺序错误。
 3.  **将非静态字段更改为静态或将非瞬态字段更改为瞬态** –当依赖默认序列化时，此更改等效于从类中删除字段。 该版本的类不会将该数据写入流，因此该类的早期版本将无法读取该数据。 与删除字段时一样，早期版本的字段将被初始化为默认值，这可能导致类以意外方式失败。
 4.  **更改原始字段的声明类型** –该类的每个版本都使用其声明类型写入数据。 尝试读取该字段的早期版本的类将失败，因为流中的数据类型与该字段的类型不匹配。

docs/java/23.md

@@ -17,13 +17,13 @@ Table of Contents
 
 ## 1\. 静态变量
 
-要声明静态变量，请在变量声明中使用`static`关键字。 静态变量语法为：
+要语句静态变量，请在变量语句中使用`static`关键字。 静态变量语法为：
 
 ```java
 ACCESS_MODIFER static DATA_TYPE VARNAME;
 ```
 
-例如，以这种方式声明`Integer`类型的公共静态变量。
+例如，以这种方式语句`Integer`类型的公共静态变量。
 
 ```java
 public static Integer staticVar;
@@ -74,7 +74,7 @@ null
 
 ## 2\. 静态方法
 
-要声明静态方法，请在方法声明中使用`static`关键字。 静态方法语法为：
+要语句静态方法，请在方法语句中使用`static`关键字。 静态方法语法为：
 
 ```java
 ACCESS_MODIFER static RETURN_TYPE METHOD_NAME;
@@ -131,11 +131,11 @@ Output:
 
 ```
 
-## 3\. 静态导入声明
+## 3\. 静态导入语句
 
-普通的导入声明从包中导入类，因此可以在不引用包的情况下使用它们。 同样，**静态导入**声明*从类*导入静态成员，并允许在没有类引用的情况下使用它们。
+普通的导入语句从包中导入类，因此可以在不引用包的情况下使用它们。 同样，**静态导入**语句*从类*导入静态成员，并允许在没有类引用的情况下使用它们。
 
-静态导入语句也有两种形式：**单静态导入**和**静态按需导入**。 单静态导入声明从类型中导入一个静态成员。 静态按需导入声明将导入类型的所有静态成员。
+静态导入语句也有两种形式：**单静态导入**和**静态按需导入**。 单静态导入语句从类型中导入一个静态成员。 静态按需导入语句将导入类型的所有静态成员。
 
 ```java
 //Single-static-import declaration:
@@ -295,7 +295,7 @@ Output:
 2.  静态成员（变量和方法）只能在静态方法和静态块内访问。
 3.  非静态成员不能在静态方法，块和内部类中访问。
 4.  一个类可以有多个静态块，并且将按照它们在类定义中出现的顺序执行它们。
-5.  一个类只有在外部类内部声明为内部类时才能是静态的。
+5.  一个类只有在外部类内部语句为内部类时才能是静态的。
 6.  静态导入可用于从类中导入所有静态成员。 可以在没有任何类引用的情况下引用这些成员。
 
 学习愉快！

docs/java/230.md

@@ -107,7 +107,7 @@ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundExcept
 
 ## 完整的例子
 
-现在，让我们编写代码进行序列化并读回字节，以验证 JVM 是否遵守合同。
+现在，让我们编写代码进行序列化并读回字节，以验证 JVM 是否遵守契约。
 
 ```java
 public class ExternalizableExample 

docs/java/24.md

-# Java 中的静态导入声明
+# Java 中的静态导入语句
 
 > 原文： [https://howtodoinjava.com/java/basics/static-import-declarations-in-java/](https://howtodoinjava.com/java/basics/static-import-declarations-in-java/)
 
-普通的导入声明从包中导入类，因此可以在不引用包的情况下使用它们。 同样，静态导入声明从类中导入静态成员，并允许在不使用类引用的情况下使用它们。
+普通的导入语句从包中导入类，因此可以在不引用包的情况下使用它们。 同样，静态导入语句从类中导入静态成员，并允许在不使用类引用的情况下使用它们。
 
-静态导入声明也有两种形式：单静态导入和按需静态导入。 单静态导入声明从类型中导入一个静态成员。 静态按需导入声明将导入类型的所有静态成员。 静态导入声明的一般语法如下：
+静态导入语句也有两种形式：单静态导入和按需静态导入。 单静态导入语句从类型中导入一个静态成员。 静态按需导入语句将导入类型的所有静态成员。 静态导入语句的一般语法如下：
 
 ```java
 //Single-static-import declaration:
@@ -19,14 +19,14 @@ import static <<package name>>.<<type name>>.*;
 
 ## 静态导入示例
 
-例如，您记得使用`System.out.println()`方法在标准输出中打印消息。 `System`是 **java.lang** 包中的类，具有一个名为`out`的静态变量。 当您使用`System.out`时，您是在`System`类之外引用该静态变量。 您可以使用静态导入声明从`System`类中导入`out`静态变量，如下所示：
+例如，您记得使用`System.out.println()`方法在标准输出中打印消息。 `System`是 **java.lang** 包中的类，具有一个名为`out`的静态变量。 当您使用`System.out`时，您是在`System`类之外引用该静态变量。 您可以使用静态导入语句从`System`类中导入`out`静态变量，如下所示：
 
 ```java
 import static java.lang.System.out;
 
 ```
 
-您的代码现在可以在程序中使用之外的名称**来表示`System.out`。 编译器将使用静态导入声明将名称`out`解析为`System.out`。**
+您的代码现在可以在程序中使用之外的名称**来表示`System.out`。 编译器将使用静态导入语句将名称`out`解析为`System.out`。**
 
 ```java
 public class StaticImportTest {
@@ -39,11 +39,11 @@ public class StaticImportTest {
 
 ## 静态导入规则
 
-以下是有关静态导入声明的一些重要规则。
+以下是有关静态导入语句的一些重要规则。
 
-1）如果导入了两个具有相同简单名称的静态成员，一个使用单静态导入声明，另一个使用静态按需导入声明，则使用单静态导入声明导入的成员优先。
+1）如果导入了两个具有相同简单名称的静态成员，一个使用单静态导入语句，另一个使用静态按需导入语句，则使用单静态导入语句导入的成员优先。
 
-假设有两个类别，`package1.Class1`和`package2.Class2`。 这两个类都有一个称为`methodA`的静态方法。 以下代码将使用`package1.Class1.methodA()`方法，因为它是使用单静态导入声明导入的：
+假设有两个类别，`package1.Class1`和`package2.Class2`。 这两个类都有一个称为`methodA`的静态方法。 以下代码将使用`package1.Class1.methodA()`方法，因为它是使用单静态导入语句导入的：
 
 ```java
 import static package1.Class1.methodA; // Imports Class1.methodA() method
@@ -57,7 +57,7 @@ public class Test {
 
 ```
 
-2）不允许使用 single-static-import 声明导入具有相同简单名称的两个静态成员。 以下静态导入声明会产生错误，因为它们都使用相同的简单名称`methodA`导入静态成员：
+2）不允许使用 single-static-import 语句导入具有相同简单名称的两个静态成员。 以下静态导入语句会产生错误，因为它们都使用相同的简单名称`methodA`导入静态成员：
 
 ```java
 import static package1.Class1.methodA;
@@ -65,7 +65,7 @@ import static package1.Class2.methodA; // An error
 
 ```
 
-3）如果使用单静态导入声明导入静态成员，并且在同一类中存在具有相同名称的静态成员，则使用该类中的静态成员。
+3）如果使用单静态导入语句导入静态成员，并且在同一类中存在具有相同名称的静态成员，则使用该类中的静态成员。
 
 ```java
 // A.java

docs/java/25.md

-# Java hashCode（）和 equals（）–合同，规则和最佳实践
+# Java `hashCode()`和`equals()` – 契约，规则和最佳实践
 
 > 原文： [https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/](https://howtodoinjava.com/java/basics/java-hashcode-equals-methods/)
 
@@ -17,13 +17,13 @@ Table of Contents:
 6) Special Attention When Using in ORM
 ```
 
-## 1\. hashCode（）和 equals（）方法的用法
+## 1\. `hashCode()`和`equals()`方法的用法
 
 1.  `equals(Object otherObject)` –顾名思义，该方法用于简单地验证两个对象的相等性。 默认实现是简单地检查两个对象的对象引用以验证它们的相等性。 *默认情况下，当且仅当两个对象存储在相同的内存地址中时，两个对象才相等。*
 2.  ``hashcode()`` –在运行时为对象返回唯一的整数值。 默认情况下，整数值主要来自堆中对象的内存地址（但并非总是强制性的）。
     当此对象需要存储在某些 [HashTable](https://en.wikipedia.org/wiki/Hash_table "Hashtable") 之类的数据结构中时，此哈希码用于确定存储桶位置。
 
-#### 1.1 hashCode（）和 equals（）之间的协定
+#### 1.1 `hashCode()`和`equals()`之间的协定
 
 通常，无论何时重写`equals()`方法，都必须重写`hashCode()`方法，以维护`hashCode()`方法的常规协定，该协定规定**相等的对象必须具有相等的哈希码**。
 
@@ -33,7 +33,7 @@ Table of Contents:
 *   如果*不是*，则根据 [`equals(java.lang.Object)`](https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals-java.lang.Object-) 方法如果两个对象不相等，则在两个对象中的每一个上调用`hashCode`方法必须产生不同的整数结果。
     但是，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。
 
-## 2\. 覆盖 hashCode（）和 equals（）的默认行为
+## 2\. 覆盖`hashCode()`和`equals()`的默认行为
 
 一切正常，直到您没有在类中覆盖这些方法中的任何一个。 但是，有时应用程序需要更改某些对象的默认行为。 让我们理解**为什么我们需要重写 equals 和哈希码**方法。
 
@@ -72,7 +72,7 @@ public class EqualsTest {
 
 没有猜中奖。 上述方法将打印`"false"`。 但是，在知道两个对象代表同一位员工之后，这真的正确吗？ 在实时应用程序中，这应该返回`true`。
 
-#### 2.2 我们应该只覆盖 equals（）方法吗？
+#### 2.2 我们应该只覆盖`equals()`方法吗？
 
 为了实现正确的应用程序行为，我们需要重写`equals()`方法，如下所示：
 
@@ -129,7 +129,7 @@ public class EqualsTest
 
 上面的类在第二个打印语句中打印两个对象。 如果两个员工对象都相等，则在仅存储唯一对象的`Set`中，在所有两个对象都引用同一员工之后，`HashSet`中必须只有一个实例。 我们缺少什么？
 
-#### 2.3 还重写 hashCode（）方法
+#### 2.3 还重写`hashCode()`方法
 
 我们缺少第二种重要方法`hashCode()`。 如 Java 文档所述，如果您覆盖`equals()`方法，则 ***必须*** 覆盖`hashCode()`方法。 因此，让我们在`Employee`类中添加另一个方法。
 
@@ -146,7 +146,7 @@ public int hashCode()
 
 在`Employee`类中添加上述方法后，第二条语句仅开始打印第二条语句中的单个对象，并且**从而验证`e1`和`e2`** 的真实相等性。
 
-## 3\. EqualsBuilder 和 HashCodeBuilder 实用程序类
+## 3\. `EqualsBuilder`和`HashCodeBuilder`实用程序类
 
 [Apache Commons](https://commons.apache.org/proper/commons-lang/) 提供了两个出色的实用程序类[，HashCodeBuilder](https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/HashCodeBuilder.html) 和 [EqualsBuilder](https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/EqualsBuilder.html) ，用于生成哈希码和 equals 方法。 以下是其用法：
 
@@ -189,7 +189,7 @@ public class Employee
 }
 ```
 
-## 4\. 使用 Eclipse 生成 hashCode（）和 equals（）
+## 4\. 使用 Eclipse 生成`hashCode()`和`equals()`
 
 如果您使用任何代码编辑器，那么大多数编辑器也能够为您生成一些良好的结构。 例如， **Eclipse IDE** 可以为您生成`hashCode()`和`equals()`的非常好的实现。
 
@@ -199,7 +199,7 @@ public class Employee
 
 在 Eclipse 中生成 hashCode（）和 equals（）
 
-## 5\. Java hashCode（）和 equals（）最佳实践
+## 5\. Java `hashCode()`和`equals()`最佳实践
 
 1.  始终使用对象的相同属性来生成`hashCode()`和`equals()`。 在本例中，我们使用了`id`雇员。
 2.  `equals()`必须与*一致*（如果未修改对象，则它必须保持返回相同的值）。

docs/java/26.md

-# Java 和 this 之间的区别
+# Java `this`和`super`之间的区别
 
 > 原文： [https://howtodoinjava.com/java/basics/this-vs-super/](https://howtodoinjava.com/java/basics/this-vs-super/)
 
 `this`和**超级**在 Java 中是保留的[关键字](https://howtodoinjava.com/java-keywords/)。 `this`引用一个类的**当前实例**，而`super`引用该类的**父类**，其中使用了`super`关键字。
 
-## 1\. Java 这个关键字
+## 1\. Java `this`关键字
 
 `this`关键字自动保留对类的当前实例的引用。 在我们要将方法从父类继承到子类，并要专门从子类调用方法的情况下，这非常有用。
 
 我们也可以使用此关键字来访问类中的[静态](https://howtodoinjava.com/java/basics/java-static-keyword/)字段，但是建议的方法是使用类引用来访问静态字段，例如 **MyClass.STATIC_FIELD** 。
 
-## 2\. Java 超级关键字
+## 2\. Java `super`关键字
 
 与`this`关键字相似，`super`在 Java 中也是保留关键字。 它始终保存对任何给定类的父类的引用。
 
 使用`super`关键字，我们可以访问任何子类中父类的字段和方法。
 
-## 3\. Java this 和 super 关键字示例
+## 3\. Java `this`和`super`关键字示例
 
 在此示例中，我们有两个类`ParentClass`和`ChildClass`，其中 **ChildClass 扩展 ParentClass** 。 我在父类中创建了一个方法`showMyName()`，并重写了它的子类。
 
@@ -72,6 +72,6 @@ In ParentClass
 
 ```
 
-在此 Java 教程中，我们学习了**这是什么，以及超级关键字**。 我们还学习了在 Java 应用程序中使用这两个关键字。
+在此 Java 教程中，我们学习了**这是什么，以及`super`关键字**。 我们还学习了在 Java 应用程序中使用这两个关键字。
 
 学习愉快！
\ No newline at end of file

docs/java/27.md

@@ -53,7 +53,7 @@ RAM 的每个进程限制也大大提高了-在 64 位 Windows 上，**而不是
 
 **2）**较长的垃圾收集暂停。 建立更多的堆意味着 GC 在清除未使用的对象时还有更多工作要做。 在现实生活中，这意味着在构建大于 12-16GB 的堆时，您必须格外小心。 如果不进行微调和测量，则很容易在几分钟内引入完整的 GC 暂停，这可能会导致显示停止。
 
-## 使用 32 位 Java 编译器生成的.class 文件可以在 64 位 Java 上使用吗？
+## 使用 32 位 Java 编译器生成的`.class`文件可以在 64 位 Java 上使用吗？
 
 **绝对是。 Java 字节码独立于 32 位或 64 位系统。** 这就是为什么编译的 Java 代码应在“ ***任何*** ”系统上可执行的原因。 请记住，因为虚拟机是打包在捆绑包中的一些本机文件，所以它只是为特殊的系统架构而编译的，而本机文件从不独立于平台。
 

docs/java/28.md

-# java.exe 和 javaw.exe 之间的区别
+# `java.exe`和`javaw.exe`之间的区别
 
 > 原文： [https://howtodoinjava.com/java/basics/difference-between-java-exe-and-javaw-exe/](https://howtodoinjava.com/java/basics/difference-between-java-exe-and-javaw-exe/)
 
 **“ java.exe”和“ javaw.exe”** 都是 Windows 平台上的 Java 可执行文件。 这些文件几乎是 Java Application Launcher 实用程序的相同版本。 两种版本的启动器都采用相同的参数和选项。 启动器通过“ java”或“ javaw”调用，后跟启动器选项，类或 Java 归档（JAR）文件名和应用程序参数。
 
-## javaw.exe
+## `javaw.exe`
 
 应用程序启动器的`non-console version`通常用于通过图形用户界面（GUI）启动 Java 应用程序。 这些应用程序具有带有菜单，按钮和其他交互元素的窗口。 本质上，当您不希望出现命令提示符窗口以进行进一步输入或显示输出时，请使用 javaw.exe。
 
 > 但是，如果由于某种原因启动 Java 应用程序失败，则 javaw.exe 启动器将显示一个对话框，其中包含错误信息。
 
-## java.exe
+## `java.exe`
 
 java.exe 与 javaw.exe 非常相似。 启动器的`console version`用于具有基于文本的界面或输出文本的应用程序。 使用“ java”启动的任何应用程序都将导致命令行等待应用程序响应，直到关闭为止。
 

docs/java/29.md

@@ -6,7 +6,7 @@
 
 为了演示该示例，我使用了为我的其他教程创建的 java 文件，该教程与 java 7 中的 [**自动资源管理有关。**](//howtodoinjava.com/java-7/automatic-resource-management-with-try-with-resources-in-java-7/ "Automatic resource management with try-with-resources in java 7")
 
-## **步骤 1）使用命令 javac（可选）编译文件 ResourceManagementInJava7.java**
+## 步骤 1）使用命令`javac`（可选）编译文件`ResourceManagementInJava7.java`
 
 这是可选的，因为您可能已经具有.class 文件。
 
@@ -16,7 +16,7 @@ prompt > javac C:tempjavatestResourceManagementInJava7.java
 
 这将生成.class 文件 ResourceManagementInJava7.class。
 
-## **步骤 2）执行 javap 命令并将输出重定向到.bc 文件**
+## 步骤 2）执行`javap`命令并将输出重定向到`.bc`文件
 
 ```java
 C:>javap -c C:tempjavatestResourceManagementInJava7.class > C:tempjavatestbytecode.bc

docs/java/30.md

-# Java 中的 Little-Endian 和 Big-Endian
+# Java 中的小端和大端
 
 > 原文： [https://howtodoinjava.com/java/basics/little-endian-and-big-endian-in-java/](https://howtodoinjava.com/java/basics/little-endian-and-big-endian-in-java/)