2019-08-01 17:04:59

docs/java/10.md

-# 使用示例在 Java 中切换 Case 语句
+# Java 中的`switch-case`语句及示例
 
 > 原文： [https://beginnersbook.com/2017/08/java-switch-case/](https://beginnersbook.com/2017/08/java-switch-case/)
 
@@ -23,7 +23,7 @@ switch (variable or an integer expression)
 
 > Switch Case 语句主要用于 [break 语句](https://beginnersbook.com/2017/08/java-break-statement/)，即使它是可选的。我们将首先看到一个没有 break 语句的例子，然后我们将讨论 switch case 和 break
 
-## 一个简单的开关案例
+## 一个简单的`switch`案例
 
 ```java
 public class SwitchCaseExample1 {
@@ -51,14 +51,14 @@ public class SwitchCaseExample1 {
 Default: Value is: 2
 ```
 
-**说明：**在开关中我给出了一个表达式，你也可以给变量。我给了 num + 2，其中 num 值是 2，并且在添加之后表达式得到 4.由于没有用值 4 定义的情况，所以执行了默认情况。这就是为什么我们应该在 switch case 中使用 default，这样如果没有匹配条件的 catch，则执行默认块。
+**说明：**在`switch`中我给出了一个表达式，你也可以给变量。我给了 num + 2，其中 num 值是 2，并且在添加之后表达式得到 4.由于没有用值 4 定义的情况，所以执行了默认情况。这就是为什么我们应该在 switch case 中使用 default，这样如果没有匹配条件的 catch，则执行默认块。
 
-## 开关案例流程图
+## `switch`案例流程图
 
-首先，评估在开关括号中提供的变量，值或表达式，然后根据结果，执行与结果匹配的相应案例块。
+首先，评估在`switch`括号中提供的变量，值或表达式，然后根据结果，执行与结果匹配的相应案例块。
 ![switch case flow diagram](img/4f4a0032c3c6f26d1bc5a76c8a08546f.jpg)
 
-## Switch Case 中的 Break 语句
+## `switch-case`中的`break`语句
 
 在 switch case 中，break 语句是可选的，但几乎每次处理 switch case 时都会使用它。在我们讨论 break 语句之前，让我们看看下面的例子，我没有使用 break 语句：
 
@@ -95,7 +95,7 @@ Default
 
 ```
 
-> 在上面的程序中，我们已经将整数值 2 传递给了开关，所以控制切换到了案例 2，但是在案例 2 之后我们没有使用 break 语句导致流程传递到后续案例直到结束。这个问题的解决方案是 break 语句
+> 在上面的程序中，我们已经将整数值 2 传递给了`switch`，所以控制切换到了案例 2，但是在案例 2 之后我们没有使用 break 语句导致流程传递到后续案例直到结束。这个问题的解决方案是 break 语句
 
 当您希望程序流从交换机主体中出来时，使用 Break 语句。每当在交换机主体中遇到 break 语句时，执行流程将直接从交换机中出来，忽略其余的情况
 
@@ -138,13 +138,13 @@ Case2
 现在您可以看到只有案例 2 已被执行，其余案例被忽略。
 
 **为什么我默认后不使用 break 语句？**
-控件本身会在默认情况下从开关中出来，所以我没有使用它，但是如果您仍然想在默认情况下使用中断，那么您可以使用它，这样做没有坏处。
+控件本身会在默认情况下从`switch`中出来，所以我没有使用它，但是如果您仍然想在默认情况下使用中断，那么您可以使用它，这样做没有坏处。
 
-## 有关 Switch Case 的几点意见
+## 有关`switch-case`的几点意见
 
 1）案例并不总是需要订购 1,2,3 等。它可以在 case 关键字后面包含任何整数值。此外，案例不需要始终按升序排列，您可以根据要求以任何顺序指定它们。
 
-2）您也可以在开关盒中使用字符。例如 -
+2）您也可以在`switch`盒中使用字符。例如 -
 
 ```java
 public class SwitchCaseExample2 {
@@ -175,21 +175,21 @@ public class SwitchCaseExample2 {
 3）switch 内部给出的表达式应该是一个常量值，否则它将无效。
 例如：
 
-**开关的有效表达式：**
+**`switch`的有效表达式：**
 
 ```java
 switch(1+2+23)
 switch(1*2+3%4)
 ```
 
-**无效的开关表达式：**
+**无效的`switch`表达式：**
 
 ```java
 switch(ab+cd)
 switch(a+b+c)
 ```
 
-4）允许嵌套 switch 语句，这意味着你可以在另一个开关内部使用 switch 语句。但是应该避免使用嵌套的 switch 语句，因为它会使程序更复杂，更不易读。
+4）允许嵌套 switch 语句，这意味着你可以在另一个`switch`内部使用 switch 语句。但是应该避免使用嵌套的 switch 语句，因为它会使程序更复杂，更不易读。
 
 看看这些相关的 [java 程序](https://beginnersbook.com/2017/09/java-examples/)：
 

docs/java/11.md

-# 对于 Java 中的循环示例
+# Java 中的`for`循环及示例
 
 > 原文： [https://beginnersbook.com/2015/03/for-loop-in-java-with-example/](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/)
 
 循环用于重复执行一组语句，直到满足特定条件。在 Java 中，我们有三种类型的基本循环：for，while 和 do-while。在本教程中，我们将学习如何在 Java 中使用“ **for loop** ”。
 
-#### for 循环的语法：
+#### `for`循环的语法：
 
 ```java
 for(initialization; condition ; increment/decrement)
@@ -13,7 +13,7 @@ for(initialization; condition ; increment/decrement)
 }
 ```
 
-## for 循环的执行流程
+## `for`循环的执行流程
 
 当程序执行时，解释器总是跟踪将要执行的语句。我们将其称为控制流程或程序的执行流程。
 ![for loop Java](img/9572bc7b0cc6c51468311908d38ba1b8.jpg)
@@ -26,7 +26,7 @@ for(initialization; condition ; increment/decrement)
 
 **第四步**：第三步后，控制跳转到第二步，重新评估条件。
 
-## Simple For 循环的示例
+## 简单的`for`循环的示例
 
 ```java
 class ForLoopExample {
@@ -57,7 +57,7 @@ int i = 1 是初始化表达式
 i＆gt; 1 是条件（布尔表达式）
 i-递减运算
 
-## 循环无限
+## 无限循环
 
 布尔表达式和递增/递减操作协调的重要性：
 
@@ -82,7 +82,7 @@ for ( ; ; ) {
 }
 ```
 
-## For 循环示例迭代数组：
+## `for`循环迭代数组的示例：
 
 这里我们使用 for 循环迭代并显示数组元素。
 
@@ -107,7 +107,7 @@ class ForLoopExample3 {
 9
 ```
 
-### 增强 For 循环
+### 增强`for`循环
 
 当您想要迭代数组/集合时，增强的 for 循环很有用，它易于编写和理解。
 

docs/java/12.md

-# 而在 Java 中循环带有示例
+# Java 中的`while`循环及示例
 
 > 原文： [https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/](https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/)
 
 在上一个教程中，我们讨论了 [for loop](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/) 。在本教程中，我们将讨论 while 循环。如前一个教程中所讨论的，循环用于重复执行一组语句，直到满足特定条件。
 
-#### while 循环的语法
+#### `while`循环的语法
 
 ```java
 while(condition)
@@ -13,7 +13,7 @@ while(condition)
 }
 ```
 
-## Loop 如何工作？
+## `while`循环如何工作？
 
 在 while 循环中，首先计算条件，如果它返回 true，则 while 循环中的语句执行。当 condition 返回 false 时，控件退出循环并跳转到 while 循环后的下一个语句。
 
@@ -21,7 +21,7 @@ while(condition)
 
 ![while loop java](img/e233c4340995c702d756930ee013d394.jpg)
 
-## 简单的 while 循环示例
+## 简单的`while`循环示例
 
 ```java
 class WhileLoopExample {
@@ -74,7 +74,7 @@ while (true){
 }
 ```
 
-## 示例：使用 while 循环迭代数组
+## 示例：使用`while`循环迭代数组
 
 这里我们使用 while 循环迭代并显示数组元素。
 

docs/java/13.md

-# Java 中的 do-while 循环示例
+# Java 中的`do-while`循环示例
 
 > 原文： [https://beginnersbook.com/2015/03/do-while-loop-in-java-with-example/](https://beginnersbook.com/2015/03/do-while-loop-in-java-with-example/)
 
 在上一个教程中，我们讨论了 [while 循环](https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/)。在本教程中，我们将讨论 java 中的 do-while 循环。 do-while 循环类似于 while 循环，但是它们之间存在差异：在 while 循环中，在执行循环体之前评估条件，但是在执行循环体之后评估 do-while 循环条件。
 
-#### do-while 循环的语法：
+#### `do-while`循环的语法：
 
 ```java
 do
@@ -13,12 +13,12 @@ do
 } while(condition);
 ```
 
-## do-while 循环如何工作？
+## `do-while`循环如何工作？
 
 首先，循环内的语句执行，然后条件得到评估，如果条件返回 true，则控件转移到“do”，否则它会在 do-while 之后跳转到下一个语句。
 ![do while loop java](img/3fd8ac235801eb43ca20982568585a06.jpg)
 
-## do-while 循环示例
+## `do-while`循环示例
 
 ```java
 class DoWhileLoopExample {
@@ -46,7 +46,7 @@ class DoWhileLoopExample {
 2
 ```
 
-## 示例：使用 do-while 循环迭代数组
+## 示例：使用`do-while`循环迭代数组
 
 这里我们有一个整数数组，我们正在迭代数组并使用 do-while 循环显示每个元素。
 

docs/java/14.md

-# 用 Java 继续使用 Java 语句
+# Java `continue`语句
 
 > 原文： [https://beginnersbook.com/2017/08/java-continue-statement/](https://beginnersbook.com/2017/08/java-continue-statement/)
 
@@ -11,7 +11,7 @@
 continue;
 ```
 
-## 示例：在 for 循环中继续语句
+## 示例：`for`循环中的`continue`语句
 
 ```java
 public class ContinueExample {
@@ -38,11 +38,11 @@ public class ContinueExample {
 
 > 您可能已经注意到，输出中缺少值 4，为什么？因为当[变量](https://beginnersbook.com/2017/08/variables-in-java/) j 的值为 4 时，程序遇到 **continue 语句**，这使得它在[的开头跳转到](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/)以进行下一次迭代，跳过当前迭代的语句（这就是当 j 的值为 4 时`println`没有执行的原因）。
 
-## 继续声明的流程图
+## `continue`声明的流程图
 
 ![Continue Statement](img/0eb6023039f4c9bea7a24ed0d9e861d5.jpg)
 
-## 示例：在 While 循环中使用 continue
+## 示例：在`while`循环中使用`continue`
 
 你可以在这看到同样的事情。对于`counter`值，我们将此循环从 10 迭代到 0，当计数器值为 7 时，循环跳过 print 语句并开始 [while 循环](https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/)的下一次迭代。
 
@@ -72,7 +72,7 @@ public class ContinueExample2 {
 10 9 8 6 5 4 3 2 1 0
 ```
 
-## 在 do-While 循环中继续的示例
+## `do-while`循环中`continue`的示例
 
 ```java
 public class ContinueExample3 {

docs/java/15.md

-# 用 Java 中的 break 语句示例
+# Java 中的`break`语句示例
 
 > 原文： [https://beginnersbook.com/2017/08/java-break-statement/](https://beginnersbook.com/2017/08/java-break-statement/)
 
@@ -17,7 +17,7 @@ b）它也用于[开关盒](https://beginnersbook.com/2017/08/java-switch-case/)
 break;
 ```
 
-## 示例 - 在 while 循环中使用 break
+## 示例 - 在`while`循环中使用`break`
 
 在下面的例子中，我们有一个 [while 循环](https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/)从 o 运行到 100 但由于我们有一个 break 语句只在循环值达到 2 时发生，循环终止并且控制传递给下一个循环体后的程序语句。
 
@@ -48,7 +48,7 @@ Value of variable is: 2
 Out of while-loop
 ```
 
-## 示例 - 在 for 循环中使用 break
+## 示例 - 在`for`循环中使用`break`
 
 你可以在这看到同样的事情。一旦`var`值达到 99，循环的[就会终止。](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/)
 
@@ -79,7 +79,7 @@ Out of for-loop
 
 ```
 
-## 示例 - 在 switch-case 中使用 break 语句
+## 示例 - 在`switch-case`中使用`break`语句
 
 ```java
 public class BreakExample3 {

docs/java/16.md

-# Java OOPs 教程
\ No newline at end of file
+# Java OOP 教程
\ No newline at end of file

docs/java/17.md

@@ -74,7 +74,7 @@ BeginnersBook.com
 
 > 虽然你可能会看到有些人声称默认和 no-arg 构造函数是相同的，但实际上它们不是，即使你在类`Demo`中编写 **public Demo（）{}** 它也无法调用默认构造函数，因为你已经编写了它的代码。
 
-#### 示例：no-arg 构造函数
+#### 示例：无参构造函数
 
 ```java
 class Demo
@@ -205,7 +205,7 @@ class Example3
 当构造函数调用同一个类的另一个构造函数时，这称为构造函数链接。在这里阅读更多相关信息 [](https://beginnersbook.com/2013/12/java-constructor-chaining-with-example/) 。
 ![constructor chaining](img/7f9a77a31e5fa581806a4a7f64cf6e1f.jpg)
 
-## 超（）
+## `super()`
 
 每当调用子类构造函数时，它都会隐式调用父类的构造函数。您还可以说编译器在子类构造函数的开头插入`super();`语句。
 
@@ -241,7 +241,7 @@ MyChildClass Constructor
 
 有关详细信息，请参阅示例的[构造函数重载。](https://beginnersbook.com/2013/05/constructor-overloading/)
 
-## Java Copy 构造函数
+## Java 复制构造函数
 
 复制构造函数用于将一个对象的值复制到另一个对象。
 

docs/java/18.md

@@ -112,7 +112,7 @@ Value of mystr: Block2
 *   静态变量也称为类变量。
 *   与**非静态变量**不同，这些变量可以直接在静态和非静态方法中访问。
 
-### 示例 1：可以在 Static 方法中直接访问静态变量
+### 示例 1：可以在静态方法中直接访问静态变量
 
 这里我们有一个静态方法`disp()`和两个静态变量`var1`和`var2`。这两个变量都可以在静态方法中直接访问。
 
@@ -201,7 +201,7 @@ ob2 STring:I'm Object2
 static return_type method_name();
 ```
 
-### 示例 1：静态方法 main 是访问没有对象的静态变量
+### 示例 1：静态方法`main`访问没有对象的静态变量
 
 ```java
 class JavaExample{

docs/java/20.md

-# Java 中的继承类型：Single，Multiple，Multilevel＆amp;混合动力
+# Java 中的继承类型：单一，多重，多级和混合
 
 > 原文： [https://beginnersbook.com/2013/05/java-inheritance-types/](https://beginnersbook.com/2013/05/java-inheritance-types/)
 
@@ -91,7 +91,7 @@ Class Z extends Y
 
 [![Hierarchical-Inheritance](img/2ae4dede153926dd4726b6b0cdd3ca10.jpg)](https://beginnersbook.com/wp-content/uploads/2013/05/Hierarchical-Inheritance.png)
 
-### 5）杂交遗传
+### 5）混合继承
 
 简单来说，你可以说混合遗传是**单**和**多** **遗传的组合。** 典型的流程图如下所示。可以在 java 中实现混合继承，就像多继承一样！使用接口。是的，你听到了。通过使用**接口**，您可以在 Java 中拥有多个以及**混合继承**。
 

docs/java/21.md

-# OOPs 概念 - 什么是 java 中的聚合？
+# OOP 概念 - 什么是 java 中的聚合？
 
 > 原文： [https://beginnersbook.com/2013/05/aggregation/](https://beginnersbook.com/2013/05/aggregation/)
 

docs/java/22.md

-# OOPs 概念 - java 中的协会是什么？
+# OOP 概念 - java 中的关联是什么？
 
 > 原文： [https://beginnersbook.com/2013/05/association/](https://beginnersbook.com/2013/05/association/)
 

docs/java/23.md

-# java 中的超级关键字示例
+# java 中的`super`关键字示例
 
 > 原文： [https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/](https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/)
 
 super 关键字指的是直接父类的对象。在学习 super 关键字之前，您必须具备 Java 中[继承的知识，以便您能够理解本指南中给出的示例。](https://beginnersbook.com/2013/03/inheritance-in-java/)
 
-## 使用超级关键字
+## 使用`super`关键字
 
 1）当父类和子类都具有相同名称的成员时访问父类的数据成员
 2）显式调用父类
@@ -12,7 +12,7 @@ super 关键字指的是直接父类的对象。在学习 super 关键字之前
 
 **现在让我们借助示例**详细讨论它们：
 
-### 1）如何使用 super 关键字访问父类的变量
+### 1）如何使用`super`关键字访问父类的变量
 
 当子类中的变量已存在于父类中时，为了访问父类的变量，您需要使用 super 关键字。
 
@@ -79,7 +79,7 @@ class Subclass extends Superclass
 100
 正如您通过使用 super.num 所看到的，我们访问了父类的 num 变量。
 
-### 2）使用 super 关键字来调用父类的构造函数
+### 2）使用`super`关键字来调用父类的构造函数
 
 当我们创建子类的对象时，new 关键字调用子类的[构造函数](https://beginnersbook.com/2013/03/constructors-in-java/ "Constructors in Java – A complete study!!")，它隐式调用父类的构造函数。因此，当我们创建子类的对象时执行的顺序是：首先执行父类构造函数，然后执行子类构造函数。这是因为编译器本身添加了 super（）（这会调用父类的无参数构造函数）作为子类构造函数中的第一个语句。
 
@@ -140,7 +140,7 @@ Hello!
 
 ```
 
-#### 参数化的 super（）调用来调用父类的参数化构造函数
+#### 参数化的`super()`调用来调用父类的参数化构造函数
 
 我们可以在子类的构造函数中显式调用 super（），但它没有任何意义，因为它会是多余的。这就像明确地做一些其他方式隐含的事情。
 但是当我们在父类中有一个带有参数的构造函数时，我们可以使用参数化的超类，如`super(100);`从子类的构造函数中调用父类的[参数化构造函数](https://beginnersbook.com/2014/01/parameterized-constructor-in-java-example/)。
@@ -193,7 +193,7 @@ Hello
 1）super（）（或参数化的 super 必须是构造函数中的第一个语句，否则你将得到编译错误：“构造函数调用必须是构造函数中的第一个语句”
 2）当我们在构造函数中明确地放置 super 时，java 编译器没有调用父类的默认 no-arg 构造函数。
 
-### 3）如何在方法覆盖的情况下使用 super 关键字
+### 3）如何在方法覆盖的情况下使用`super`关键字
 
 当子类声明父类中已存在的相同方法时，这称为[方法覆盖](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/)。我们将在本系列的下一个教程中学习方法覆盖。现在您只需要记住这一点：当子类重写父类的方法时，从子类对象调用该方法总是调用该方法的子类版本。但是通过使用这样的 super 关键字：super.method_name 可以调用父类的方法（被覆盖的方法）。在方法覆盖的情况下，使用这些术语：重写方法：父类的方法重写方法：子类的方法让我们举一个例子来理解这个概念：
 
@@ -231,7 +231,7 @@ Child class method
 Parent class method
 ```
 
-#### 如果子类没有覆盖任何方法怎么办：不需要超级
+#### 如果子类没有覆盖任何方法怎么办：不需要`super`
 
 当子类没有覆盖父类方法时，我们不需要使用 super 关键字来调用父类方法。这是因为在这种情况下我们只有每个方法的一个版本，子类可以访问父类方法，所以我们可以直接调用父类的方法而不使用 super。
 

docs/java/24.md

-# 使用示例在 Java 中重载方法
+# Java 中的方法重载示例
 
 > 原文： [https://beginnersbook.com/2013/05/method-overloading/](https://beginnersbook.com/2013/05/method-overloading/)
 
@@ -124,7 +124,7 @@ a
 5
 ```
 
-### 示例 3：重载 - 参数的数据类型序列
+### 示例 3：重载 - 参数的数据类型顺序
 
 这里方法`disp()`根据参数的数据类型序列重载 - 这两种方法在参数列表中都有不同的数据类型序列。第一种方法是将参数列表作为（char，int），第二种方法是使用（int，char）。由于序列不同，该方法可以过载而没有任何问题。
 

docs/java/25.md

-# 用示例覆盖 java 中的方法
+# java 中的方法覆盖示例
 
 > 原文： [https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/)
 
@@ -159,7 +159,7 @@ problem: The method xyz() is undefined for the type ABC
 5.  重写方法的绑定在运行时发生，称为[动态绑定](https://beginnersbook.com/2013/04/java-static-dynamic-binding/)。
 6.  如果一个类正在扩展[抽象类](https://beginnersbook.com/2013/05/java-abstract-class-method/)或实现[接口](https://beginnersbook.com/2013/05/java-interface/)，那么它必须覆盖所有抽象方法，除非该类本身是一个抽象类。
 
-## 方法覆盖中的超级关键字
+## 方法覆盖中的`super`关键字
 
 [超级关键字](https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/)用于调用父类方法/构造函数。 `super.myMethod()`调用基类的 myMethod（）方法，而`super()`调用基类的[构造函数](https://beginnersbook.com/2013/03/constructors-in-java/)。让我们看一下使用 super in 方法 Overriding。
 我们知道我们覆盖子类中的方法，然后使用子类对象调用该方法调用重写方法。通过使用 super，我们可以调用重写方法，如下例所示：

docs/java/26.md

@@ -62,7 +62,7 @@ Sum of five numbers: 110
 
 这里我们有 4 个版本的相同方法`add`。我们在这里重载方法`add()`。
 
-### 压倒一切的例子
+### 覆盖示例
 
 ```java
 package beginnersbook.com;

docs/java/27.md

-# Java 中的多态性与示例
+# Java 中的多态与示例
 
 > 原文： [https://beginnersbook.com/2013/03/polymorphism-in-java/](https://beginnersbook.com/2013/03/polymorphism-in-java/)
 
-多态性是 [OOP](https://beginnersbook.com/2013/04/oops-concepts/) 特征之一，它允许我们以不同的方式执行单个动作。例如，假设我们有一个`Animal`类，它有一个方法`sound()`。由于这是一个泛型类，所以我们不能给它一个实现，如：Roar，Meow，Oink 等。我们不得不给出一个通用的消息。
+多态是 [OOP](https://beginnersbook.com/2013/04/oops-concepts/) 特征之一，它允许我们以不同的方式执行单个动作。例如，假设我们有一个`Animal`类，它有一个方法`sound()`。由于这是一个泛型类，所以我们不能给它一个实现，如：Roar，Meow，Oink 等。我们不得不给出一个通用的消息。
 
 ```java
 public class Animal{
@@ -37,12 +37,12 @@ public class Cat extends Animal{
 }
 ```
 
-正如您所看到的那样，尽管我们对所有子类`sound()`都有共同的操作，但是有不同的方法来执行相同的操作。这是多态性的完美示例（允许我们以不同方式执行单个操作的功能）。仅调用泛型 sound（）方法没有任何意义，因为每个 Animal 都有不同的声音。因此，我们可以说该方法执行的操作基于对象的类型。
+正如您所看到的那样，尽管我们对所有子类`sound()`都有共同的操作，但是有不同的方法来执行相同的操作。这是多态的完美示例（允许我们以不同方式执行单个操作的功能）。仅调用泛型 sound（）方法没有任何意义，因为每个 Animal 都有不同的声音。因此，我们可以说该方法执行的操作基于对象的类型。
 
 ## 什么是编程中的多态？
 
-多态性是一种方法根据它所作用的对象做不同事物的能力。换句话说，多态允许您定义一个接口并具有多个实现。正如我们在上面的例子中看到的那样，我们已经定义了方法 sound（）并且在不同的 2 个子类中具有它的多个实现。
-将在运行时确定将调用哪个 sound（）方法，因此我们上面给出的示例是**运行时多态性示例**。
+多态是一种方法根据它所作用的对象做不同事物的能力。换句话说，多态允许您定义一个接口并具有多个实现。正如我们在上面的例子中看到的那样，我们已经定义了方法 sound（）并且在不同的 2 个子类中具有它的多个实现。
+将在运行时确定将调用哪个 sound（）方法，因此我们上面给出的示例是**运行时多态示例**。
 
 > 多态的类型和方法重载＆amp;覆盖在单独的教程中。你可以在这里引用它们：
 > 1\. [Java 中的方法重载](https://beginnersbook.com/2013/05/method-overloading/) - 这是编译时间（或静态多态）的一个例子
@@ -51,9 +51,9 @@ public class Cat extends Animal{
 
 让我们写下它的完整代码：
 
-## 例 1：Java 中的多态性
+## 例 1：Java 中的多态
 
-**运行时多态性示例：**
+**运行时多态示例：**
 Animal.java
 
 ```java
@@ -106,9 +106,9 @@ Output:
 Meow
 ```
 
-## 例 2：编译时间多态性
+## 例 2：编译时多态
 
-方法重载另一方面是编译时多态性示例。
+方法重载另一方面是编译时多态示例。
 
 ```java
 class Overload

docs/java/3.md

@@ -66,6 +66,6 @@ Java 被认为是一种简单的语言，因为它没有像运算符重载，[
 
 Java 支持[多线程](https://beginnersbook.com/2013/03/multithreading-in-java/ "Multithreading in java with examples")。多线程是一种 Java 功能，允许并发执行程序的两个或多个部分，以最大限度地利用 CPU。
 
-### 手提
+### 便携
 
 如上所述，在一台机器上编写的 java 代码可以在另一台机器上运行。平台无关的字节代码可以被携带到任何平台以便执行，从而使 java 代码可移植。
\ No newline at end of file

docs/java/4.md

-# Java 虚拟机（JVM），差异 JDK，JRE＆amp; JVM - 核心 Java
+# Java 虚拟机（JVM），JDK 差异，JRE 和 JVM - 核心 Java
 
 > 原文： [https://beginnersbook.com/2013/05/jvm/](https://beginnersbook.com/2013/05/jvm/)
 

docs/java/5.md

@@ -72,7 +72,7 @@ java FirstJavaProgram
 
 > 请注意，在运行程序时，不应将.java 扩展名附加到文件名。
 
-## 仔细看看 First Java Program
+## 仔细看看第一个 Java 程序
 
 现在我们已经了解了如何运行 java 程序，让我们仔细看看上面编写的程序。
 

docs/java/7.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/data-types-in-java/](https://beginnersbook.com/2017/08/data-types-in-java/)
 
-**数据类型**定义变量可以采用的值，例如，如果变量具有 int 数据类型，则它只能采用整数值。在 java 中，我们有两类数据类型：1）原始数据类型 2）非原始数据类型 - 数组和字符串是非原始数据类型，我们将在后面的教程中讨论它们。这里我们将讨论 Java 中的原始数据类型和文字。
+**数据类型**定义变量可以采用的值，例如，如果变量具有 int 数据类型，则它只能采用整数值。在 java 中，我们有两类数据类型：1）原始数据类型 2）非原始数据类型 - 数组和字符串是非原始数据类型，我们将在后面的教程中讨论它们。这里我们将讨论 Java 中的原始数据类型和字面值。
 
 Java 是一种静态类型语言。如果在编译时已知变量的数据类型，则静态类型化语言。这意味着您必须先指定变量的类型（声明变量），然后才能使用它。
 在上一篇关于 [Java 变量](https://beginnersbook.com/2017/08/variables-in-java/)的教程中，我们学会了如何声明一个变量，让我们回想一下：
@@ -52,7 +52,7 @@ class JavaExample {
 
 > 通过为变量 num 分配值 150 来尝试相同的程序，您将得到**类型不匹配**错误，因为值 150 超出了字节数据类型的范围。我上面提到的字节范围是-128 到 127。
 
-### 短：
+### 短整数：
 
 这在大小方面大于字节且小于整数。其范围是-32,768 到 32767\.
 此数据类型的默认大小：2 个字节
@@ -86,7 +86,7 @@ Output:
 
 字节数据类型不能保持值 150，但短数据类型可以因为它具有更宽的范围。
 
-## 长：
+## 长整数：
 
 当 int 不足以容纳该值时使用，它具有比 int 数据类型更宽的范围，范围从-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。
 大小：8 字节
@@ -185,9 +185,9 @@ Output:
 Z
 ```
 
-## Java 中的文字
+## Java 中的字面值
 
-文字是我们分配给程序中的变量的固定值。
+字面值是我们分配给程序中的变量的固定值。
 
 ```java
 int num=10;
@@ -199,11 +199,11 @@ int num=10;
 char ch = 'A';
 ```
 
-这里 A 是一个字面文字
+这里 A 是一个字面字面值
 
-### 整数文字
+### 整数字面值
 
-整数文字分配给数据类型`byte`，`short`，`int`和`long`的变量。
+整数字面值分配给数据类型`byte`，`short`，`int`和`long`的变量。
 
 ```java
 byte b = 100;
@@ -212,7 +212,7 @@ int num = 13313131;
 long l = 928389283L;
 ```
 
-### 浮动文字
+### 浮点字面值
 
 用于数据类型`float`和`double`。
 
@@ -223,7 +223,7 @@ float num2 = 22.4f;
 
 注意：始终使用“f”后缀浮点值，否则编译器会将其视为 double。
 
-### Char 和 String Literal
+### 字符和字符串字面值
 
 用于 char 和 String 类型。
 

docs/java/8.md

@@ -8,7 +8,7 @@
 
 1）基本算术运算符
 2）赋值运算符
-3）自动递增和自动递减运算符
+3）自增和自减运算符
 4）逻辑运算符
 5）比较（关系）运算符
 6）位运算符
@@ -62,7 +62,7 @@ num1 % num2: 0
 1.  [Java 程序添加两个数字](https://beginnersbook.com/2017/09/java-program-to-add-two-numbers/)
 2.  [Java 程序乘以两个数字](https://beginnersbook.com/2017/09/java-program-to-multiply-two-numbers/)
 
-## 2）分配操作员
+## 2）赋值运算符
 
 java 中的赋值运算符是：=，+ =， - =，* =，/ =，％=
 **num2 = num1** 将变量 num1 的值赋给变量。
@@ -119,14 +119,14 @@ public class AssignmentOperatorDemo {
 
 ```
 
-## 3）自动递增和自动递减运算符
+## 3）自增和自减运算符
 
 ++和 -
 **num ++** 相当于`num=num+1;`
 
 **num--** 相当于`num=num-1;`
 
-### 自动递增和自动递减运算符的示例
+### 自增和自减运算符的示例
 
 ```java
 public class AutoOperatorDemo {
@@ -294,7 +294,7 @@ num2 = 22; / *等于 00010110 * /
 
 **num1＆lt;＆lt; 2** 是左移位运算符，它将位移到左边，丢弃最左边的位，并将最右边的位赋值为 0.在我们的例子中，输出为 44，相当于 00101100
 
-> 注意：在下面的示例中，我们在此移位运算符的右侧提供 2，这是位向左移动两个位置的原因。我们可以更改此数字，并且位将按运算符右侧指定的位数移动。同样适用于右侧操作员。
+> 注意：在下面的示例中，我们在此移位运算符的右侧提供 2，这是位向左移动两个位置的原因。我们可以更改此数字，并且位将按运算符右侧指定的位数移动。同样适用于右侧运算符。
 
 **num1＆gt;＆gt; 2** 是右移位运算符，它将位向右移动，丢弃最右位，并将最左边的位指定为 0.在我们的例子中，输出为 2，相当于 00000010
 

docs/java/9.md

-# 如果，Java 中的 If..else 语句带有示例
+# Java 中的`if`和`if-else`语句及示例
 
 > 原文： [https://beginnersbook.com/2017/08/if-else-statement-in-java/](https://beginnersbook.com/2017/08/if-else-statement-in-java/)
 
@@ -11,7 +11,7 @@ b）嵌套 if 语句
 c）if-else 语句
 d）if-else-if 语句
 
-## 如果声明
+## `if`声明
 
 如果语句包含条件，则后跟语句或一组语句，如下所示：
 
@@ -24,7 +24,7 @@ if(condition){
 只有在给定条件为真时才会执行语句。如果条件为 false，那么 if 语句体内的语句将被完全忽略。
 ![if statement flow diagram](img/8348367489fe93480c63d95c5eaf34ee.jpg)
 
-### if 语句的示例
+### `if`语句的示例
 
 ```java
 public class IfStatementExample {
@@ -47,7 +47,7 @@ public class IfStatementExample {
 number is less than 100
 ```
 
-## Java 中嵌套的 if 语句
+## Java 中嵌套`if`语句
 
 当在另一个 if 语句中有 if 语句时，它被称为**嵌套 if 语句**。
 嵌套的结构如下所示：
@@ -64,7 +64,7 @@ if(condition_1) {
 
 如果 condition_1 为 true，则执行 Statement1。只有条件（condition_1 和 condition_2）都为真时，Statement2 才会执行。
 
-### 嵌套 if 语句的示例
+### 嵌套`if`语句的示例
 
 ```java
 public class NestedIfExample {
@@ -89,7 +89,7 @@ number is greater than 50
 
 ```
 
-## 如果在 Java 中使用 else 语句
+## 在 Java 中使用`if-else`语句
 
 这是 if-else 语句的外观：
 
@@ -105,7 +105,7 @@ else {
 如果条件为真，则“if”内的语句将执行，如果条件为假，则“else”内的语句将执行。
 ![If else flow diagram](img/df84b9366c0b823cd802fd7d7f16e7e3.jpg)
 
-### if-else 语句的示例
+### `if-else`语句的示例
 
 ```java
 public class IfElseExample {
@@ -129,7 +129,7 @@ num is greater than or equal 50
 
 ```
 
-## if-else-if Statement
+## `if-else-if`语句
 
 当我们需要检查多个条件时使用 if-else-if 语句。在这个声明中，我们只有一个“if”和一个“else”，但是我们可以有多个“else if”。如果梯子，它也被称为**。这是它的样子：**
 
@@ -163,7 +163,7 @@ else {
 
 **注意：**这里要注意的最重要的一点是，在 if-else-if 语句中，只要满足条件，就会执行相应的语句集，忽略 rest。如果没有满足条件，则执行“else”内的语句。
 
-### if-else-if 的示例
+### `if-else-if`的示例
 
 ```java
 public class IfElseIfExample {