2019-11-23 11:16:14

docs/12.md

@@ -6,7 +6,7 @@
 
 Java 是一种面向对象的编程语言。 这意味着，除了基本类型之外，Java 中的所有内容都是一个对象。 但是，对象到底是什么？ 使用类和对象的概念是将状态和行为封装到单个编程单元中。 这个概念称为[封装](https://javatutorial.net/java-encapsulation-example)。 Java 对象类似于真实世界的对象。 例如，我们可以用 Java 创建一个汽车对象，该对象将具有当前速度和颜色等属性。 和行为，例如：加速和停车。
 
-## 建立课程
+## 创建类
 
 Java 类是创建对象的蓝图。 让我们创建一个代表汽车的类。
 

docs/13.md

@@ -10,7 +10,7 @@
 
 ## 什么是面向对象
 
-[Wikipedia 将 OOP](https://en.wikipedia.org/wiki/Object-oriented_programming) 定义为：“基于对象的概念的编程范例，其中可能包含字段形式的字段，通常称为 _ 属性；_ 和程序形式的代码，通常称为 _ 方法。”_
+[Wikipedia 将 OOP](https://en.wikipedia.org/wiki/Object-oriented_programming) 定义为：“基于对象的概念的编程示例，其中可能包含字段形式的字段，通常称为 _ 属性；_ 和程序形式的代码，通常称为 _ 方法。”_
 
 面向对象编程（OOP）是一种编程语言模型，它使用[对象](https://javatutorial.net/java-objects-and-classes-tutorial)和数据作为核心组件。 如果您想了解更多细节并更好地理解类和对象，请参阅本主题的详细教程。 单击此处的[首先阅读它。](https://javatutorial.net/java-objects-and-classes-tutorial)
 
@@ -26,14 +26,14 @@ OOP 背后的主要思想是用对象而不是动作或功能来表示数据和
 
 封装的目的是将变量和方法包装在一个单元中，其唯一目的是从外部类中隐藏数据。 阅读完整的 [Java 封装示例](https://javatutorial.net/java-encapsulation-example)，了解更多详细信息。
 
-## 遗产
+## 继承
 
 继承是一种 OOP 功能，它允许 Java 类从其他类派生。 阅读完整的 [Java 继承示例](https://javatutorial.net/java-inheritance-example)了解更多详细信息。
 
-## 抽象化
+## 抽象
 
 抽象是向用户隐藏实现细节的过程。 Оnly 功能将提供给用户。 阅读完整的 [Java 抽象示例](https://javatutorial.net/java-abstraction-example)了解更多详细信息。
 
-## 多态性
+## 多态
 
-Java 中的多态性允许类的子类定义其自己的独特行为，而又共享父类的某些相同功能。 阅读完整的 [Java 多态示例](https://javatutorial.net/java-polymorphism-example)，了解更多详细信息。
\ No newline at end of file
+Java 中的多态允许类的子类定义其自己的独特行为，而又共享父类的某些相同功能。 阅读完整的 [Java 多态示例](https://javatutorial.net/java-polymorphism-example)，了解更多详细信息。
\ No newline at end of file

docs/14.md

-# Java 封装范例
+# Java 封装示例
 
 > 原文： [https://javatutorial.net/java-encapsulation-example](https://javatutorial.net/java-encapsulation-example)
 
@@ -15,7 +15,7 @@
 *   将一个类的变量声明为私有。
 *   提供公共的 setter 和 getter 方法来修改和查看变量值。
 
-## Java 封装范例
+## Java 封装示例
 
 ![Java encapsulation example](img/010b4bd70790461fb1f0a0b58702a4d1.jpg)
 

docs/15.md

@@ -4,7 +4,7 @@
 
 在本教程中，我将向您展示如何创建和使用 **Java 接口**。 与往常一样，我将演示 Java 接口的实际示例。
 
-## ![](img/bd9a26ffe0204dc0807b7a7d3d1f5e3f.jpg)
+![](img/bd9a26ffe0204dc0807b7a7d3d1f5e3f.jpg)
 
 ## 什么是 Java 接口？
 
@@ -12,7 +12,7 @@
 
 Java 接口表示一组带有空主体的方法。 嗯，在接口中包含完整的方法列表不是强制性的-它们可以为 0 或更多…但是，无论方法的数量如何，它们都应该为空。
 
-## 创建一个界面
+## 创建一个接口
 
 以洗衣机为例，使用一种方法`startButtonPressed()`创建一个名为`WashingMachine`的接口
 
@@ -47,9 +47,9 @@ public class SamsungWashingMachine implements WashingMachine {
 public class SamsungWashingMachine implements WashinMachine, Serializable, Comparable<WashinMachine> { ... }
 ```
 
-## 测试你的界面
+## 测试你的接口
 
-现在让我们创建一个小程序来测试我们的界面和实现
+现在让我们创建一个小程序来测试我们的接口和实现
 
 ```java
 public class Test {
@@ -179,7 +179,7 @@ Yummy! you eat some raspberry
 
 **代码说明了**
 
-首先，我们创建接口`FoundObject`的唯一目的是表示特定类型的对象，因此我们可以将它们放在同一数组中。 我们创建`Eatable`界面以标记可以食用的对象。
+首先，我们创建接口`FoundObject`的唯一目的是表示特定类型的对象，因此我们可以将它们放在同一数组中。 我们创建`Eatable`接口以标记可以食用的对象。
 
 当我们创建三个对象（苹果，树莓和石头）时，我们将所有对象的类都声明为`implements FoundObject`，而我们可以食用的对象也实现了`Eatable`接口。
 

docs/18.md

-# Java 多态性示例
+# Java 多态示例
 
 > 原文： [https://javatutorial.net/java-polymorphism-example](https://javatutorial.net/java-polymorphism-example)
 
@@ -6,17 +6,17 @@
 
 ## 什么是多态
 
-多态性一词来自希腊语，意思是“许多形式”。 Java 中的多态性允许类的子类定义其自己的独特行为，而又共享父类的某些相同功能。 我将从继承的角度讨论多态性，在继承中，名称相同的多个方法的功能稍有不同。 此技术也称为方法覆盖。
+多态一词来自希腊语，意思是“许多形式”。 Java 中的多态允许类的子类定义其自己的独特行为，而又共享父类的某些相同功能。 我将从继承的角度讨论多态，在继承中，名称相同的多个方法的功能稍有不同。 此技术也称为方法覆盖。
 
-多态性是[面向对象编程（OOP）](https://javatutorial.net/java-oop)背后的四个主要概念之一。 OOP 问题在求职面试中很常见，因此您可能会在下次 Java 求职面试中遇到有关多态的问题。
+多态是[面向对象编程（OOP）](https://javatutorial.net/java-oop)背后的四个主要概念之一。 OOP 问题在求职面试中很常见，因此您可能会在下次 Java 求职面试中遇到有关多态的问题。
 
-## Java 多态性示例
+## Java 多态示例
 
-在此示例中，我们将创建 3 个类来演示多态性，并创建一个类来测试该概念。 我们的超类称为`Animal`。 动物类的后继者是`Dog`和`Cat`类。 这些也是动物，对不对？ 这就是多态性所在-同一对象的多种形式具有不同的行为。 为了说明这一点，我们将使用一种名为`makeSound()`的方法，并在后继类中重写此方法的输出。
+在此示例中，我们将创建 3 个类来演示多态，并创建一个类来测试该概念。 我们的超类称为`Animal`。 动物类的后继者是`Dog`和`Cat`类。 这些也是动物，对不对？ 这就是多态所在-同一对象的多种形式具有不同的行为。 为了说明这一点，我们将使用一种名为`makeSound()`的方法，并在后继类中重写此方法的输出。
 
 ![Java polymorphism example](img/ce87a86824b6014020e0d0c232e3c159.jpg)
 
-Java 多态性示例
+Java 多态示例
 
 当我们调用 makeSound（）方法时，通用动物类将输出一些抽象文本：
 
@@ -102,4 +102,4 @@ the cat meows
 
 ### 参考文献
 
-官方 Oracle [多态性示例](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
\ No newline at end of file
+官方 Oracle [多态示例](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
\ No newline at end of file

docs/19.md

-# Java 中的方法重载与方法重载
+# Java 中的方法重载与方法覆盖
 
 > 原文： [https://javatutorial.net/method-overloading-vs-method-overriding-in-java](https://javatutorial.net/method-overloading-vs-method-overriding-in-java)
 
-本文通过示例演示了 Java 中方法重载和方法重写之间的区别
+本文通过示例演示了 Java 中方法重载和方法覆盖之间的区别
 
 **方法重载**和**方法重载**都是在各种 Java 实现中高度使用的 OOP（面向对象编程）概念。 在本文中，我们已经写了关于[OPT]的 [4 个主要概念的文章。 如果您不熟悉 OOP，请先查看此文章。](https://javatutorial.net/java-oop)
 
@@ -24,9 +24,9 @@ public int calculate(String name, int data[], int offset) {
 }
 ```
 
-## 什么是方法重写？
+## 什么是方法覆盖？
 
-方法覆盖是 [Java 继承](https://javatutorial.net/java-inheritance-example) OOP 原理的一部分。 方法重写的思想是在子类中更改给定方法的实现。 换句话说，您使用方法的相同签名（名称，返回类型，参数）“替代”了父类方法的实现，但是在重写方法内部实现了不同的功能。
+方法覆盖是 [Java 继承](https://javatutorial.net/java-inheritance-example) OOP 原理的一部分。 方法覆盖的思想是在子类中更改给定方法的实现。 换句话说，您使用方法的相同签名（名称，返回类型，参数）“替代”了父类方法的实现，但是在覆盖方法内部实现了不同的功能。
 
 ![Method overriding in Java](img/116f231e7d6408fd7b1acd8561c0295a.jpg)
 
@@ -73,7 +73,7 @@ public class OverloadingExample {
 
 如您在上面的示例中看到的，基于我们使用的参数调用了另一种方法。 这是增加程序可读性的好方法。
 
-## Java 中的方法重写示例
+## Java 中的方法覆盖示例
 
 动物超类
 

docs/20.md

@@ -4,7 +4,7 @@
 
 Java 中的控制流语句允许您在满足特殊条件时运行或跳过代码块。 您将在程序中大量使用控制语句，本教程将说明如何执行此操作。
 
-## “如果”声明
+## `if`语句
 
 Java 中的``if''语句的工作原理与大多数编程语言完全相同。 借助“如果”，您可以选择在满足预定义条件时执行特定的代码块。 Java 中“ if”语句的结构如下所示：
 
@@ -79,7 +79,7 @@ A and B are equeal to 2
 A or C is equal 5
 ```
 
-## “如果不是”的陈述
+## `if-else`语句
 
 通过此语句，您可以控制满足条件的情况以及其他情况。 看下面的代码
 
@@ -130,9 +130,9 @@ public class FlowControlExample {
 }
 ```
 
-## 开关声明
+## `switch`语句
 
-在某些情况下，您可以避免在代码中使用多个 if-s 并使代码看起来更好。 为此，可以使用 switch 语句。 看下面的 java 开关示例
+在某些情况下，您可以避免在代码中使用多个 if-s 并使代码看起来更好。 为此，可以使用 switch 语句。 看下面的 java `switch`示例
 
 ```java
 public class SwitchExample {
@@ -156,6 +156,6 @@ public class SwitchExample {
 }
 ```
 
-开关有一把钥匙和一个或多个箱子。 在我们的示例中，键为 numOfAngles ，当我们将 3、4 和 5 用作 switch 语句的值时，我们处理停止点。 如果我们传递的值不同于 3、4 或 5 ，则默认执行。 另请注意，在每种情况下，中断。 如果我们不包括 break，则程序将运行到下一种情况。 例如，如果我们删除情况 3 的中断，则在上面的示例中将执行情况 3 和情况 4。
+`switch`有一把钥匙和一个或多个箱子。 在我们的示例中，键为 numOfAngles ，当我们将 3、4 和 5 用作 switch 语句的值时，我们处理停止点。 如果我们传递的值不同于 3、4 或 5 ，则默认执行。 另请注意，在每种情况下，中断。 如果我们不包括 break，则程序将运行到下一种情况。 例如，如果我们删除情况 3 的中断，则在上面的示例中将执行情况 3 和情况 4。
 
 在我的下一个教程 [Java 循环](http://javatutorial.net/java-loops "Java Loops")中，我将解释如何在 Java 中使用循环。
\ No newline at end of file

docs/23.md

@@ -27,7 +27,7 @@
 4.  操作系统设置
 5.  存在或缺少文件
 
-### 配置文件激活显式
+### 显式激活配置文件
 
 创建您的 Maven 项目（如果尚未创建），然后创建第一个简单的配置文件 test1。
 

docs/24.md

@@ -8,7 +8,7 @@
 
 ![java-featured-image](img/e0db051dedc1179e7424b6d998a6a772.jpg)
 
-## 步骤 1
+## 第 1 步
 
 在命令行中导航到您的 Maven 项目路径，然后上传一个库，这就是 maven 命令的结构：
 

docs/25.md

@@ -47,7 +47,7 @@ Java 有多种可用的测试框架，但是，在本教程中，我们将重点
 
 ![Example program to run JUnit on ](img/91c62882d3d436caa8785d0846707b8d.jpg)
 
-### 我的考试班
+### 我的测试类
 
 ![Test class example](img/0f3a5e694b2885b1685d342f2c3e7ac1.jpg)
 

docs/29.md

@@ -10,7 +10,7 @@
 
 如果您尚未安装 Maven，请点击此处的[。](https://javatutorial.net/how-to-install-maven-on-windows-linux-and-mac)
 
-## 1.使用 Eclipse 生成 WAR 文件
+## 使用 Eclipse 生成 WAR 文件
 
 步骤 1 –打开 Eclipse 并创建一个新的 Maven 项目（文件->新建->其他-> Maven 项目）![How to generate WAR file using Maven java example](img/e015b5975e479d17af96f6c852f62685.jpg)
 

docs/30.md

@@ -38,7 +38,7 @@ Java 虚拟机架构图
 
 我们已经在单独的教程中介绍了类加载器。 您可能需要查看 [Java 类加载器，以了解更多](https://javatutorial.net/java-class-loaders-explained)详细信息。
 
-#### 载入中
+#### 载入
 
 编译的类存储为.class 文件。 当我们尝试使用类时，Java [ClassLoader](https://javatutorial.net/java-class-loaders-explained) 将该类加载到内存中。 在已经运行的类中通过名称引用类时，这些类将引入 Java 环境。 一旦第一个类运行，以后将由类加载器完成加载类的尝试。 通常，通过声明并使用静态 main（）方法来完成第一类的运行。
 
@@ -48,7 +48,7 @@ Java 虚拟机架构图
 2.  **Extensions Class Loader** -它从 JDK 扩展目录（通常是 JRE 的 lib / ext 目录）加载类。
 3.  **系统类加载器**-从系统类路径加载类，可以在使用-cp 或-classpath 命令行选项调用程序时进行设置。
 
-#### 连结中
+#### 链接
 
 链接类或接口涉及验证和准备该类或接口，其直接超类，其直接超接口以及必要时其元素类型。
 
@@ -70,15 +70,15 @@ JVM 要求维护以下所有属性：
 
 运行时数据区域内有五个组件：
 
-#### 方法范围
+#### 方法区
 
 所有类级别的数据（包括静态变量）都将存储在此处。 每个 JVM 只有一个方法区域，它是共享资源。
 
-#### 堆面积
+#### 堆区
 
 所有对象及其对应的实例变量和数组都将存储在此处。 每个 JVM 还有一个堆区。 由于“方法”和“堆”区域共享多个线程的内存，因此存储的数据不是线程安全的。
 
-#### 堆叠面积
+#### 栈区
 
 对于每个线程，将创建一个单独的运行时堆栈。 对于每个方法调用，将在堆栈存储器中创建一个条目，称为堆栈帧。 所有局部变量都将在堆栈存储器中创建。 堆栈区域是线程安全的，因为它不是共享资源。 堆栈框架分为三个子实体：
 
@@ -90,7 +90,7 @@ JVM 要求维护以下所有属性：
 
 每个线程将具有单独的 PC 寄存器，以保存当前执行指令的地址，一旦执行了该指令，PC 寄存器将被下一条指令更新。
 
-#### 本机方法堆栈
+#### 本机方法栈
 
 本机方法堆栈保存本机方法信息。 对于每个线程，将创建一个单独的本机方法堆栈。
 
@@ -98,7 +98,7 @@ JVM 要求维护以下所有属性：
 
 分配给运行时数据区的字节码将由执行引擎执行。 执行引擎读取字节码并逐段执行。
 
-#### 口译员
+#### 解释器
 
 解释器解释字节码的速度较快，但执行速度较慢。 解释器的缺点是，当多次调用一种方法时，每次都需要新的解释。
 
@@ -108,7 +108,7 @@ JIT 编译器消除了解释器的缺点。 执行引擎将使用解释器的帮
 
 #### 垃圾收集器
 
-垃圾收集器（GC）收集并删除未引用的对象。 可以通过调用“ System.gc（）”来触发垃圾回收，但是不能保证执行。 JVM 的垃圾收集收集创建的对象。
+垃圾收集器（GC）收集并删除未引用的对象。 可以通过调用“ System.gc（）”来触发垃圾收集，但是不能保证执行。 JVM 的垃圾收集收集创建的对象。
 
 #### Java 本机接口（JNI）
 

docs/31.md

-# 用示例解释 Java 内存模型
+# Java 内存模型解释示例
 
 > 原文： [https://javatutorial.net/java-memory-examples](https://javatutorial.net/java-memory-examples)
 

docs/32.md

@@ -4,13 +4,13 @@
 
 在本文中，我将教您多种捕获 Java 堆转储的方法。 对于优化内存消耗至关重要，堆转储被描述为 Java 进程的内存打印。
 
-Java [堆转储](https://www.ibm.com/support/knowledgecenter/en/SS3KLZ/com.ibm.java.diagnostics.memory.analyzer.doc/heapdump.html)是诊断与内存相关的问题的重要对象，这些问题包括`java.lang.OutOfMemoryError`，垃圾回收问题和内存泄漏（缓慢），这些都是 Java Web 开发的一部分。
+Java [堆转储](https://www.ibm.com/support/knowledgecenter/en/SS3KLZ/com.ibm.java.diagnostics.memory.analyzer.doc/heapdump.html)是诊断与内存相关的问题的重要对象，这些问题包括`java.lang.OutOfMemoryError`，垃圾收集问题和内存泄漏（缓慢），这些都是 Java Web 开发的一部分。
 
 为了清楚起见，在进行快照的瞬间，堆转储包含诸如 Java 类和堆中的对象之类的信息。
 
 可以帮助您分析堆转储的工具包括 [Heap Hero](http://heaphero.io) 和 [Eclipse MAT](https://www.eclipse.org/mat/) 。 但是，您仍然需要为工具提供在正确的时间和正确格式下捕获的堆转储。
 
-## 1\. jmap – XX：+ HEAPDUMPONOUTOFMEMORYERROR
+## 1\. `jmap –XX:+HEAPDUMPONOUTOFMEMORYERROR`
 
 值得注意的是，jmap 会将堆转储打印到特定的文件位置。 jmap 工具通常打包在 [JDK](https://javatutorial.net/install-java-8-jdk-on-ubuntu) 中。 您可以在以下文件夹中找到它：< JAVA_HOME > \ bin。
 
@@ -22,7 +22,7 @@ Java [堆转储](https://www.ibm.com/support/knowledgecenter/en/SS3KLZ/com.ibm.j
 
 **请注意，传递**“实时”选择至关重要。 如果选项“通过”，则只会将活动对象写入堆转储文件。 但是，如果您无法通过该选项，则所有对象（包括未设置为垃圾收集的对象）都将被打印到堆转储中。 这样的错误会过多且不必要地增加其堆转储的大小。 通过将您的移动开发需求与 [Java Development Company](https://www.nearshore-it.eu/java-development/) 签订合同，可以避免此类错误。
 
-## 2\. HeapDumpOnOutOfMemoryError
+## 2\. `HeapDumpOnOutOfMemoryError`
 
 当应用程序遇到 java.lang.OutOfMemoryError 时，捕获瞬时堆转储至关重要。
 
@@ -34,7 +34,7 @@ Java [堆转储](https://www.ibm.com/support/knowledgecenter/en/SS3KLZ/com.ibm.j
 
 值得注意的是，在上述情况下将捕获的头转储将打印在名为“ -XX：HeapDumpPath”的系统属性概述的位置中
 
-## 3\. jcmd
+## 3\. `jcmd`
 
 jcmd 工具用于发送命令请求以诊断 Java [JVM](https://javatutorial.net/jvm-explained) 。 同样，jcmd 工具包含在 JDK 软件包中。 您可以在名为\ bin 的文件夹中获取它。
 

docs/33.md

-# Java 垃圾回收
+# Java 垃圾收集
 
 > 原文： [https://javatutorial.net/java-garbage-collection](https://javatutorial.net/java-garbage-collection)
 
@@ -18,7 +18,7 @@
 
 从技术上讲，Java 垃圾收集处理的是跟踪 [JVM（Java 虚拟机）](https://javatutorial.net/jvm-explained)堆空间中的每个对象，并删除（删除/取消分配）未使用的对象。
 
-垃圾回收（GC）实现有 4 种类型：
+垃圾收集（GC）实现有 4 种类型：
 
 1.  串行垃圾收集器
 2.  并行垃圾收集器
@@ -39,7 +39,7 @@ GC 的此实现仅使用一个线程，并且在运行时冻结所有应用程
 
 ## **CMS 垃圾收集器**
 
-CMS 代表并发标记扫描，并同时使用多个 GC 线程来扫描堆并标记未引用的对象，这些对象随后在扫描中被删除/取消分配。 对于那些需要短时间垃圾收集暂停并能够负担与 GC 共享资源的应用程序，它是首选。 使用该 GC 实现的应用程序比不使用 GC 的应用程序要慢，但是在执行垃圾回收时它们不会完全暂停整个应用程序。
+CMS 代表并发标记扫描，并同时使用多个 GC 线程来扫描堆并标记未引用的对象，这些对象随后在扫描中被删除/取消分配。 对于那些需要短时间垃圾收集暂停并能够负担与 GC 共享资源的应用程序，它是首选。 使用该 GC 实现的应用程序比不使用 GC 的应用程序要慢，但是在执行垃圾收集时它们不会完全暂停整个应用程序。
 
 在两种情况下，垃圾收集器的这种含义进入了“世界停止”（STW）模式：
 
@@ -62,7 +62,7 @@ G1 GC 将堆划分为一组大小相等的堆区域，并标记并发的全局
 *   没有处理悬空指针的开销
 *   自动内存泄漏管理
 
-## **垃圾回收的缺点：**
+## **垃圾收集的缺点：**
 
 *   跟踪对象引用的创建/删除需要更多的 CPU 能力，并且可能会影响需要大内存的请求的性能
 *   程序员无法控制专用于释放不再需要的对象的 CPU 时间的调度

docs/34.md

@@ -16,7 +16,7 @@ Mutex 与 Semaphore 略有不同，因此 **Semaphore 允许多个线程访问
 
 ![Mutex java example thread](img/66ac23d82b34151f8831186826308565.jpg)
 
-## 建设者
+## 构造器
 
 1.  公共[信号灯](https://javatutorial.net/java-semaphore-example)（国际许可）；
 2.  公共信号量（int 许可，布尔型公平）；

docs/35.md

@@ -14,7 +14,7 @@ Acquire（）从信号量获取许可，然后 release（）将许可返回信
 
 信号量设置为一个计数值。 然后线程尝试获取许可，如果计数为 0 或小于 0，则线程将被阻塞，并且它将等待下一个许可（如果有）。 这将一直保持下去，直到 count 大于 0。如果是，则信号量将提供对线程资源的访问。 然后线程将释放许可，计数将增加 1。
 
-## 建设者
+## 构造器
 
 1.  信号量（int 许可）：使用给定数量的许可和不公平的公平设置创建一个信号量
 2.  信号量（int 许可，布尔值公平）：创建具有给定许可数量和给定公平性设置的信号量

docs/38.md

@@ -16,13 +16,13 @@
 
 上图的工作流不仅可以控制应用程序正在创建的线程数，还可以控制计划任务的执行并将传入的任务保持在队列中。
 
-## 执行者，执行者和执行者服务
+## `Executor`，`Runnable`和`ExecutorService`
 
 Java 提供了 Executor 框架，这意味着您只需要实现 Runnable 对象并将其发送给 executor 即可执行。
 
 要使用线程池，首先我们需要创建一个 ExecutorService 对象并将任务传递给它。 ThreadPoolExecutor 类设置核心和最大池大小。 然后，可运行对象将顺序执行。
 
-## 不同的执行器线程池方法
+## 不同的`Executor`线程池方法
 
 ```java
 newFixedThreadPool(int size) - creates a fixed size thread pool

docs/39.md

-# ThreadLocal Java 示例
+# Java `ThreadLocal`示例
 
 > 原文： [https://javatutorial.net/threadlocal-java-example](https://javatutorial.net/threadlocal-java-example)
 
@@ -8,7 +8,7 @@ ThreadLocal 是提供线程局部变量的类，用于实现线程安全。 存
 
 ThreadLocal 扩展了 Object 类，并提供了线程限制，它是局部变量的“一部分”。
 
-## **创建 ThreadLocal 变量**
+## **创建`ThreadLocal`变量**
 
 ```java
 ThreadLocal threadLocalExample = new ThreadLocal();
@@ -79,6 +79,6 @@ Before remove: Just a random text that will be displayed before the remove funct
 After remove: null
 ```
 
-## **细分**
+## **分解**
 
 上面的代码显示了两种使它起作用的方法：一种是通过拥有 Runnable 对象并将其传递给 Thread 实例，然后覆盖 run（）方法，或者您可以简单地创建一个 ThreadLocal 实例并为其设置值，然后 可以获取或删除它。 从上面的示例中可以看到，即使它是相同的变量（局部变量），也可以包含不同的值。 在第一种情况下，它包含值“ First”。 在第二种情况下，它包含值“ Second”。 对于其他实现，我只显示了一个线程。 但是，每个线程都是独立的–意味着，如果您要创建另一个 Thread 实例（例如 thread2），并对其进行 start（），它将独立运行，并且与其他 Thread 实例变量无关。 要进行检查，可以在静态类中创建一个 ThreadLocal 实例，然后在重写的 run（）方法中创建一个随机数，然后使用 set（）方法将其传递给当前线程。 您将看到，如果您在两个或多个不同的线程上调用它，则它们都将具有不同的值。
\ No newline at end of file

docs/49.md

@@ -41,7 +41,7 @@ JProfiler 界面概述
 
 考虑以下示例：想象您必须创建所需的对象。 但是，当您不再需要它时，请继续前进，而不是从内存中“释放”它。 幕后发生的事情是，仍然引用该对象。 当应用程序开始消耗更多资源时，它很快就会耗尽资源，并导致 OutOfMemoryError。
 
-这是[垃圾回收](https://javatutorial.net/java-garbage-collection)无法从内存中删除这些未使用的对象的时候。
+这是[垃圾收集](https://javatutorial.net/java-garbage-collection)无法从内存中删除这些未使用的对象的时候。
 
 ![Memory Leak Diagram](img/4c9b96ca2cbd880236a553e493c932f8.jpg)
 

docs/52.md

@@ -188,7 +188,7 @@ public class JFrmaeGraphics extends JPanel{
 
 ![Text example](img/8823ff42379e358a57bef425ff997b72.jpg)
 
-文字范例
+文字示例
 
 ## **绘制图像**
 
@@ -228,6 +228,6 @@ public class JFrmaeGraphics extends JPanel{
 
 ![Image example](img/1d1f97d93f416dc1ef7c6531dfd37aea.jpg)
 
-图片范例
+图片示例
 
 这是[链接](https://github.com/NeelumAyub/Tutorials/tree/master/JFrameGhraphics)，您可以下载完整的代码。
\ No newline at end of file

docs/6.md

-# Eclipse 捷径
+# Eclipse 快捷方式
 
 > 原文： [https://javatutorial.net/eclipse-shortcuts](https://javatutorial.net/eclipse-shortcuts)
 
 此列表包含 Windows，Linux 和 Mac OS 最常见的 Eclipse 快捷方式。 使用快捷方式将提高您的编码效率。 您可以将此列表用作参考，并在以后需要时再次使用。
 
-## 文件管理 Eclipse 快捷方式
+## Eclipse 文件管理快捷方式
 
 | **Windows / Linux** | **Mac** | **说明** |
 | Ctrl + N | ⌘+ N | 启动向导以创建新的类，接口，java 项目等。 |
@@ -16,7 +16,7 @@
 | Ctrl + W | ⌘+ W | 关闭当前文件 |
 | Ctrl + Shift + W | ⌘+ Shift + W | 关闭所有文件 |
 
-## 在编辑器 Eclipse 快捷方式中导航
+## 在 Eclipse 编辑器快捷方式中导航
 
 | **Windows / Linux** | **Mac** | **说明** |
 | Ctrl + Shift +向上箭头 |  | 跳至上一个方法 |
@@ -24,21 +24,21 @@
 | Ctrl + L | ⌘+ L | 转到行号 |
 | Ctrl + Q | ⌘+ Q | 转到最后编辑的位置 |
 
-## 格式化和注释 Eclipse 快捷方式
+## Eclipse 格式化和注释快捷方式
 
 | **Windows / Linux** | **Mac** | **说明** |
 | Ctrl + Shift + F | ⌘+ Shift + F 键 | 选择自动格式（调整缩进，换行等）。 如果没有选择，所有代码将自动格式化 |
 | Ctrl + / | ⌘+ / | 切换当前行或节的注释// |
 | Ctrl + Shift + / | Shift + Shift + / | 在选择/ *周围添加块注释* / |
 
-## 编辑源代码 Eclipse 快捷方式
+## Eclipse 编辑源代码快捷方式
 
 | **Windows / Linux** | **Mac** | **说明** |
 | Ctrl +空格 | Space +空格 | 打开内容辅助（允许您选择方法或字段名称） |
 | Ctrl + 1 | ⌘+ 1 | 打开“快速修复”，并提供有关解决问题的建议 |
 | Alt + / | Alt + / | 为您完成一个词。 您必须至少输入一个字母才能起作用。 您可以在同一单词上多次使用此快捷方式，直到找到所需的单词 |
 
-## 代码信息 Eclipse 快捷方式
+## Eclipse 代码信息快捷方式
 
 | **Windows / Linux** | **Mac** | **说明** |
 | Ctrl + T | ⌘+ T | 显示所选项目的类型层次结构 |

docs/7.md

@@ -69,7 +69,7 @@ java MyFirstJavaProgram
 
 执行我们的第一个 Java 程序的结果
 
-## 解释守则
+## 解释代码
 
 现在让我们回到示例的源代码并仔细查看。
 

docs/8.md

@@ -23,7 +23,7 @@ byte byteVariable = 24; // uses 8 bits of memory
 *   值范围：最小值-128 和最大值 127
 *   默认值为 0
 
-## 短
+## 短整型
 
 *   使用`short`存储很多小数字，对于`byte`来说太大了
 *   使用 16 位内存
@@ -37,20 +37,20 @@ byte byteVariable = 24; // uses 8 bits of memory
 *   值范围：最小值-2,147,483,648 和最大值 2,147,483,647
 *   默认值为 0
 
-## 长
+## 长整型
 
 *   使用`long`计算的整数对于`int`太大
 *   使用 64 位内存
 *   值范围：最小值-9,223,372,036,854,775,808 和最大值 9,223,372,036,854,775,807
 *   默认值为 0L
 
-## 浮动
+## 浮点
 
 *   使用`float`存储或计算有理数（带小数点或科学计数法的数字）。 `float`的精度为 6 个十进制数字
 *   使用 32 位内存
 *   默认值为 0.0f
 
-## 双
+## 双精度浮点
 
 *   与`float`相似，但范围更大，精度为 14 个十进制数字
 *   使用 64 位内存
@@ -62,7 +62,7 @@ byte byteVariable = 24; // uses 8 bits of memory
 *   使用 1 位内存
 *   默认值为 false
 
-## 烧焦
+## 字符
 
 *   将`char`用于 Unicode 字符代码，包括`'\\'`，`'\n'`，`'\r'`，`'\t'`，`'\''`和`'\uxxxx'`
 *   使用 16 位内存

docs/83.md

@@ -15,9 +15,9 @@ Java 中有 4 种引用类型：
 
 在这里，我们将讨论弱参考。
 
-弱引用与 Java 中的垃圾回收有关。 [垃圾回收](https://javatutorial.net/java-garbage-collection)只是从内存中自动取消分配未引用对象的方法。
+弱引用与 Java 中的垃圾收集有关。 [垃圾收集](https://javatutorial.net/java-garbage-collection)只是从内存中自动取消分配未引用对象的方法。
 
-弱引用是指不足以使对象保留在内存中的引用。 因此，弱引用可以让垃圾回收器确定对象的可及性以及所讨论的对象是否应保留在内存中。
+弱引用是指不足以使对象保留在内存中的引用。 因此，弱引用可以让垃圾收集器确定对象的可及性以及所讨论的对象是否应保留在内存中。
 
 弱引用需要显式声明，因为默认情况下，Java 将引用标记为强引用。
 
@@ -33,7 +33,7 @@ Java 中有 4 种引用类型：
 
 *   弱引用主要用于**规范化映射的实现中。** 规范化映射是指映射仅包含特定值的一个实例。
 
-*   弱引用还广泛用于 [WeakHashMap](https://javatutorial.net/java-weakhashmap-example) 类中。 这是 Map 接口的实现，其中每个键值都存储为弱引用。 键值对扩展了 WeakReference 类。 因此，垃圾回收器删除此键也会导致实体也被删除。
+*   弱引用还广泛用于 [WeakHashMap](https://javatutorial.net/java-weakhashmap-example) 类中。 这是 Map 接口的实现，其中每个键值都存储为弱引用。 键值对扩展了 WeakReference 类。 因此，垃圾收集器删除此键也会导致实体也被删除。
 
 <u>代码示例：</u>
 

docs/9.md

@@ -6,7 +6,7 @@
 
 很多时候，您将需要多次在程序中执行代码片段，直到满足某些条件为止。 这就是循环的目的。
 
-## Java“ for”循环
+## Java `for`循环
 
 借助 for 循环，您可以多次执行一系列代码行。 Java 中的“ for”循环与其他编程语言（例如 C / C ++）完全一样。 for 循环功能非常强大，但学习起来很简单。 在要迭代数据集合的所有情况下，它也主要用于搜索或排序算法。 这是“ for”循环的一个简单示例：
 
@@ -52,7 +52,7 @@ Termination 是布尔语句，它告诉循环执行多长时间。 在终止语
 
 `for(int i=0; i<5; **i++**)`
 
-## Java“ while”循环
+## Java `while`循环
 
 Java 中的另一个循环是 while 循环。