2019-08-09 15:14:34

docs/java/10.md

-# Java 中的`switch-case`语句及示例
+# Java 中的`switch-case`语句
 
 > 原文： [https://beginnersbook.com/2017/08/java-switch-case/](https://beginnersbook.com/2017/08/java-switch-case/)
 

docs/java/11.md

-# Java 中的`for`循环及示例
+# Java 中的`for`循环
 
 > 原文： [https://beginnersbook.com/2015/03/for-loop-in-java-with-example/](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/)
 

docs/java/12.md

-# Java 中的`while`循环及示例
+# Java 中的`while`循环
 
 > 原文： [https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/](https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/)
 

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/)
 

docs/java/15.md

-# Java 中的`break`语句示例
+# Java 中的`break`语句
 
 > 原文： [https://beginnersbook.com/2017/08/java-break-statement/](https://beginnersbook.com/2017/08/java-break-statement/)
 

docs/java/19.md

-# Java 编程中的继承与实例
+# Java 编程中的继承
 
 > 原文： [https://beginnersbook.com/2013/03/inheritance-in-java/](https://beginnersbook.com/2013/03/inheritance-in-java/)
 

docs/java/23.md

-# java 中的`super`关键字示例
+# java 中的`super`关键字
 
 > 原文： [https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/](https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/)
 

docs/java/24.md

-# Java 中的方法重载示例
+# Java 中的方法重载
 
 > 原文： [https://beginnersbook.com/2013/05/method-overloading/](https://beginnersbook.com/2013/05/method-overloading/)
 
@@ -41,10 +41,10 @@ int add(int, int)
 float add(int, int)
 ```
 
-**方法重载**是[静态多态性](https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/)的一个例子。我们将在单独的教程中讨论[多态性](https://beginnersbook.com/2013/03/polymorphism-in-java/)及其类型。
+**方法重载**是[静态多态](https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/)的一个例子。我们将在单独的教程中讨论[多态](https://beginnersbook.com/2013/03/polymorphism-in-java/)及其类型。
 
 **注意事项：**
-1.静态多态性也称为编译时绑定或早期绑定。
+1.静态多态也称为编译时绑定或早期绑定。
 2\. [静态绑定](https://beginnersbook.com/2013/04/java-static-dynamic-binding/)在编译时发生。方法重载是静态绑定的一个示例，其中方法调用与其定义的绑定在编译时发生。
 
 ## 方法重载示例

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/)
 
@@ -45,7 +45,7 @@ Boy is eating
 
 ## 方法覆盖和动态方法调度
 
-方法覆盖是[运行时多态性](https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/)的示例。当父类引用指向子类对象时，则在运行时确定对重写方法的调用，因为在方法调用期间，要执行哪个方法（父类或子类）由对象类型确定。在运行时解析对重写方法的调用的过程称为动态方法调度。让我们看一个例子来理解这个：
+方法覆盖是[运行时多态](https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/)的示例。当父类引用指向子类对象时，则在运行时确定对重写方法的调用，因为在方法调用期间，要执行哪个方法（父类或子类）由对象类型确定。在运行时解析对重写方法的调用的过程称为动态方法调度。让我们看一个例子来理解这个：
 
 ```java
 class ABC{
@@ -155,7 +155,7 @@ problem: The method xyz() is undefined for the type ABC
     ```
 
 3.  private，static 和 final 方法不能被覆盖，因为它们是类的本地方法。但是，静态方法可以在子类中重新声明，在这种情况下，子类方法的行为会有所不同，并且与父类的相同静态方法无关。
-4.  覆盖方法（子类的方法）可以抛出[未经检查的异常](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)，无论被覆盖的方法（父类的方法）是否抛出任何异常。然而，最重要的方法不应该抛出[检查的异常](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)，这些异常是新的或比被重写方法声明的异常更宽。我们将在即将到来的教程中使用示例详细讨论这个问题。
+4.  覆盖方法（子类的方法）可以抛出[非受检的异常](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)，无论被覆盖的方法（父类的方法）是否抛出任何异常。然而，最重要的方法不应该抛出[检查的异常](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)，这些异常是新的或比被重写方法声明的异常更宽。我们将在即将到来的教程中使用示例详细讨论这个问题。
 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/)，那么它必须覆盖所有抽象方法，除非该类本身是一个抽象类。
 

docs/java/27.md

-# Java 中的多态与示例
+# Java 中的多态
 
 > 原文： [https://beginnersbook.com/2013/03/polymorphism-in-java/](https://beginnersbook.com/2013/03/polymorphism-in-java/)
 

docs/java/28.md

-# java-运行时和编译时多态的多态类型
+# java 的多态类型 - 运行时和编译时多态
 
 > 原文： [https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/](https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/)
 
-在上一篇教程中，我们讨论了 Java 中的[多态性。在本指南中，我们将看到**类型的多态性**。 java 中有两种类型的多态性：
-1）**静态多态性**又称编译时多态性
-2）**动态多态性**又称运行时多态性](https://beginnersbook.com/2013/03/polymorphism-in-java/)
+在上一篇教程中，我们讨论了 Java 中的[多态。在本指南中，我们将看到**类型的多态**。 java 中有两种类型的多态：
+1）**静态多态**又称编译时多态
+2）**动态多态**又称运行时多态](https://beginnersbook.com/2013/03/polymorphism-in-java/)
 
-## 编译时间多态性（或静态多态性）
+## 编译时多态（或静态多态）
 
-在编译器时间内解析的多态性称为静态多态性。方法重载是编译时多态的一个例子。
+在编译器时间内解析的多态称为静态多态。方法重载是编译时多态的一个例子。
 **方法重载**：如果方法的参数在参数的数量，顺序和数据类型上不同，这允许我们有多个具有相同名称的方法。我们在这里已经讨论了方法重载：如果你没有阅读该指南，请参考： [Java 中的方法重载](https://beginnersbook.com/2013/05/method-overloading/)
 
-### 静态多态性的例子
+### 静态多态的例子
 
 方法重载是 java 支持静态多态的方式之一。这里我们有两个相同方法 add（）的定义，其中 add 方法将在编译时由参数列表确定。这就是为什么它也被称为编译时多态。
 
@@ -47,9 +47,9 @@ public class Demo
 
 ```
 
-## 运行时多态性（或动态多态性）
+## 运行时多态（或动态多态）
 
-它也称为动态方法调度。动态多态性是一个在运行时解析对重写方法的调用的过程，这就是为什么它被称为运行时多态。我已经在单独的教程中详细讨论了方法覆盖，请参考：[方法覆盖 Java](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/) 。
+它也称为动态方法调度。动态多态是一个在运行时解析对重写方法的调用的过程，这就是为什么它被称为运行时多态。我已经在单独的教程中详细讨论了方法覆盖，请参考：[方法覆盖 Java](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/) 。
 
 **示例**
 在此示例中，我们有两个类 ABC 和 XYZ。 ABC 是父类，XYZ 是子类。子类覆盖父类的 myMethod（）方法。在此示例中，我们将子类对象分配给父类引用，因此为了确定将调用哪个方法，将在运行时确定对象的类型。对象的类型决定了要调用哪个版本的方法（而不是引用的类型）。

docs/java/29.md

@@ -4,7 +4,7 @@
 
 方法调用与方法体的关联称为绑定。有两种类型的绑定：**静态绑定**在编译时发生，**动态绑定**在运行时发生。在我解释 java 中的静态和动态绑定之前，让我们看一些可以帮助您更好地理解这个概念的术语。
 
-## 什么是参考和对象？
+## 什么是引用和对象？
 
 ```java
 class Human{

docs/java/3.md

@@ -44,7 +44,7 @@ JRE 是 JDK 的一部分，这意味着 JDK 包含 JRE。如果在系统上安
 1.  [抽象](https://beginnersbook.com/2013/03/oops-in-java-encapsulation-inheritance-polymorphism-abstraction/ "OOPs in Java- Encapsulation, Inheritance, Polymorphism, Abstraction")
 2.  [封装](https://beginnersbook.com/2013/05/encapsulation-in-java/ "Encapsulation in Java with example")
 3.  [继承](https://beginnersbook.com/2013/05/java-inheritance-types/ "Types of inheritance in Java: Single,Multiple,Multilevel & Hybrid")
-4.  [多态性](https://beginnersbook.com/2013/03/polymorphism-in-java/ "Polymorphism in Java – Method Overloading and Overriding")
+4.  [多态](https://beginnersbook.com/2013/03/polymorphism-in-java/ "Polymorphism in Java – Method Overloading and Overriding")
 
 ### 简单
 

docs/java/30.md

@@ -116,9 +116,9 @@ Unresolved compilation problem: Cannot instantiate the type AbstractDemo
 
 注意：扩展抽象类的类必须实现它的所有抽象方法，否则你也必须声明该类抽象。
 
-## 抽象类 vs Concrete 类
+## 抽象类 vs 具体类
 
-非抽象的类称为 **Concrete 类**。在我们在本指南开头看到的上述例子中，`Animal`是一个抽象类，`Cat`，`Dog`＆amp; `Lion`是具体的课程。
+非抽象的类称为 **具体类**。在我们在本指南开头看到的上述例子中，`Animal`是一个抽象类，`Cat`，`Dog`＆amp; `Lion`是具体的课程。
 
 **要点：**
 

docs/java/31.md

-# Java 中的抽象方法示例
+# Java 中的抽象方法
 
 > 原文： [https://beginnersbook.com/2014/01/abstract-method-with-examples-in-java/](https://beginnersbook.com/2014/01/abstract-method-with-examples-in-java/)
 

docs/java/32.md

-# java 中的接口与示例程序
+# java 中的接口
 
 > 原文： [https://beginnersbook.com/2013/05/java-interface/](https://beginnersbook.com/2013/05/java-interface/)
 
@@ -106,7 +106,7 @@ public class Demo implements Inf2{
 
 在这个程序中，类`Demo`只实现接口`Inf2`，但是它必须提供接口`Inf1`的所有方法的实现，因为接口 Inf2 扩展了 Inf1。
 
-## Java 中的标记或标记界面
+## Java 中的标记或标记接口
 
 空接口称为标记或标记接口。例如，Serializable，EventListener，Remote（java.rmi.Remote）是标记接口。这些接口中没有任何字段和方法。在这里阅读更多相关信息 [](https://beginnersbook.com/2016/03/tag-or-marker-interfaces-in-java/) 。
 

docs/java/33.md

@@ -13,7 +13,7 @@
 | 3 | 抽象类可以同时具有抽象和具体方法 | 接口只能有抽象方法 |
 | 4 | 在抽象类关键字中，“abstract”是将方法声明为抽象的必需项 | 在接口关键字中，“abstract”是可选的，用于将方法声明为抽象 |
 | 五 | 抽象类可以具有受保护和公共抽象方法 | 接口只能有公共抽象方法 |
-| 6 | 抽象类可以使用任何[访问说明符](https://beginnersbook.com/2013/05/java-access-modifiers/)具有静态，最终或静态最终变量 | interface 只能有 public static final（常量）变量 |
+| 6 | 抽象类可以使用任何[访问描述符](https://beginnersbook.com/2013/05/java-access-modifiers/)具有静态，最终或静态最终变量 | interface 只能有 public static final（常量）变量 |
 
 以下示例解释了上述每个要点：
 
@@ -202,7 +202,7 @@ Output:
 display1 method
 ```
 
-### 差异 No.4：在抽象类中，关键字'abstract'是将方法声明为抽象的必需项
+### 差异 No.4：在抽象类中，关键字`abstract`是将方法声明为抽象的必需项
 
 ```java
 abstract class Example1{
@@ -296,7 +296,7 @@ class Demo{
 }
 ```
 
-### 差异 No.6：抽象类可以具有任何访问说明符的静态，最终或静态最终变量
+### 差异 No.6：抽象类可以具有任何访问描述符的静态，最终或静态最终变量
 
 ```java
 abstract class Example1{

docs/java/34.md

-# 用 Java 封装示例
+# Java 中的封装
 
 > 原文： [https://beginnersbook.com/2013/05/encapsulation-in-java/](https://beginnersbook.com/2013/05/encapsulation-in-java/)
 

docs/java/36.md

-# Java Access Modifiers - Public，Private，Protected＆amp;默认
+# Java 访问修饰符 - 公共、私有、受保护和默认
 
 > 原文： [https://beginnersbook.com/2013/05/java-access-modifiers/](https://beginnersbook.com/2013/05/java-access-modifiers/)
 
@@ -62,7 +62,7 @@ The method addTwoNumbers(int, int) from the type Addition is not visible
 at xyzpackage.Test.main(Test.java:12)
 ```
 
-## 2.私人访问修饰符
+## 2.私有访问修饰符
 
 private 修饰符的范围仅限于类。
 

docs/java/38.md

-# Java 中的最终关键字 - 最终变量，方法和类
+# Java 中的`final`关键字 - 最终变量，方法和类
 
 > 原文： [https://beginnersbook.com/2014/07/final-keyword-java-final-variable-method-class/](https://beginnersbook.com/2014/07/final-keyword-java-final-variable-method-class/)
 
@@ -172,9 +172,9 @@ class ABC extends XYZ{
 XYZ Class Method
 ```
 
-## 3）最后一堂课
+## 3）最终类
 
-我们不能延长最后一堂课。考虑以下示例：
+我们不能扩展最终类。考虑以下示例：
 
 ```java
 final class XYZ{  

docs/java/40.md

-# 使用示例在 java 中进行异常处理
+# java 中的异常处理
 
 > 原文： [https://beginnersbook.com/2013/04/java-exception-handling/](https://beginnersbook.com/2013/04/java-exception-handling/)
 
 异常处理是 java 编程最重要的特性之一，它允许我们处理异常引起的运行时错误。在本指南中，我们将学习什么是异常，它的类型，异常类以及如何使用示例处理 java 中的异常。
 
-## 什么是例外？
+## 什么是异常？
 
 异常是一个不需要的事件，它会中断程序的正常流程。当发生异常时，程序执行将终止。在这种情况下，我们会收到系统生成的错误消息。关于异常的好处是它们可以用 Java 来处理。通过处理异常，我们可以向用户提供有关问题的有意义的消息，而不是系统生成的消息，这可能是用户无法理解的。
 
@@ -43,21 +43,21 @@ ArrayIndexOutOfBoundsException - 当您尝试从其边界外访问数组的元
 
 ![Exception classes hierarchy](img/28f90627b0e8b73e86243d3c86fbc3f9.jpg)
 
-## 例外的类型
+## 异常的类型
 
 Java 中有两种类型的异常：
-1）已检查的异常
-2）未经检查的异常
+1）受检的异常
+2）非受检的异常
 
 我已在单独的教程中详细介绍了这一点： [Java](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/) 中的 Checked 和 Unchecked 异常。
 
-### 检查异常
+### 受检异常
 
-除运行时异常之外的所有异常都称为已检查异常，因为编译器在编译期间检查它们以查看程序员是否已处理它们。如果在程序中未处理/声明这些异常，则会出现编译错误。例如，SQLException，IOException，ClassNotFoundException 等。
+除运行时异常之外的所有异常都称为受检异常，因为编译器在编译期间检查它们以查看程序员是否已处理它们。如果在程序中未处理/声明这些异常，则会出现编译错误。例如，SQLException，IOException，ClassNotFoundException 等。
 
-### 未经检查的例外情况
+### 非受检的异常情况
 
-运行时异常也称为未经检查的异常。这些异常不会在编译时检查，因此编译器不会检查程序员是否已经处理过它们，但程序员有责任处理这些异常并提供安全退出。例如，ArithmeticException，NullPointerException，ArrayIndexOutOfBoundsException 等。
+运行时异常也称为非受检的异常。这些异常不会在编译时检查，因此编译器不会检查程序员是否已经处理过它们，但程序员有责任处理这些异常并提供安全退出。例如，ArithmeticException，NullPointerException，ArrayIndexOutOfBoundsException 等。
 
 > 编译器永远不会强制您捕获此类异常或强制您使用 throws 关键字在方法中声明它。
 
@@ -65,7 +65,7 @@ Java 中有两种类型的异常：
 
 1.  [Java 中的 try-catch](https://beginnersbook.com/2013/04/try-catch-in-java/)
 2.  [Nested Try Catch](https://beginnersbook.com/2013/04/nested-try-catch/)
-3.  [已检查和未检查的异常](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)
+3.  [受检和非受检的异常](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)
 4.  [最后在 Java 中阻塞](https://beginnersbook.com/2013/04/java-finally-block/)
 5.  [try-catch-finally](https://beginnersbook.com/2013/05/flow-in-try-catch-finally/)
 6.  [终于阻止＆amp;退货声明](https://beginnersbook.com/2013/05/java-finally-return/)

docs/java/43.md

@@ -54,6 +54,6 @@ at beginnersbook.com.ThrowExample.checkEligibilty(ThrowExample.java:9)
 at beginnersbook.com.ThrowExample.main(ThrowExample.java:18)
 ```
 
-在上面的例子中，我们抛出了一个未经检查的异常，同样地，我们可以抛出[未经检查的](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)和[用户定义的异常以及](https://beginnersbook.com/2013/04/user-defined-exception-in-java/)。
+在上面的例子中，我们抛出了一个非受检的异常，同样地，我们可以抛出[非受检的](https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/)和[用户定义的异常以及](https://beginnersbook.com/2013/04/user-defined-exception-in-java/)。
 
 有关 throw 关键字的更多示例，请参阅：[抛出关键字示例](https://beginnersbook.com/2013/04/throw-in-java/)。
\ No newline at end of file

docs/java/54.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2015/06/java-awt-tutorial/](https://beginnersbook.com/2015/06/java-awt-tutorial/)
 
-**AWT** 代表**抽象窗口工具包**。它是一个依赖于平台的 API，用于为 Java 程序创建图形用户界面（GUI）。
+**AWT** 代表**抽象窗口工具包**。它是一个依赖于平台的 API，用于为 Java 程序创建图形用户接口（GUI）。
 
 **为什么 AWT 与平台有关？** Java AWT 调用本机平台（操作系统）子程序，用于创建文本框，复选框，按钮等组件。例如，具有按钮的 AWT GUI 在诸如 Windows，Mac OS 和 Windows 等平台之间具有不同的外观和感觉。 Unix，这是因为这些平台的原生按钮具有不同的外观和感觉，AWT 直接调用创建按钮的原生子程序。简单来说，基于 AWT 的应用程序在 Windows 上运行时看起来就像一个 Windows 应用程序，但在 Mac OS 上运行时，相同的应用程序看起来就像是 Mac 应用程序。
 

docs/java/55.md

@@ -2,12 +2,12 @@
 
 > 原文： [https://beginnersbook.com/2015/07/java-swing-tutorial/](https://beginnersbook.com/2015/07/java-swing-tutorial/)
 
-Swing 是 Java Foundation 类（JFC）的一部分，JFC 的其他部分是 java2D 和 Abstract window 工具包（AWT）。 AWT，Swing＆amp; Java 2D 用于在 java 中构建图形用户界面（GUI）。在本教程中，我们将主要讨论用于在 AWT 顶部构建 GUI 的 Swing API，与 AWT 相比，它更轻量级。
+Swing 是 Java Foundation 类（JFC）的一部分，JFC 的其他部分是 java2D 和 Abstract window 工具包（AWT）。 AWT，Swing＆amp; Java 2D 用于在 java 中构建图形用户接口（GUI）。在本教程中，我们将主要讨论用于在 AWT 顶部构建 GUI 的 Swing API，与 AWT 相比，它更轻量级。
 
 ## 一个简单的例子
 
 在下面的示例中，我们将使用您在本教程中到目前为止尚未学习的几个 swing 组件。我们将在即将到来的摇摆教程中详细讨论每一个和所有内容。
-下面的 swing 程序会创建一个登录界面。
+下面的 swing 程序会创建一个登录接口。
 
 ```java
 import javax.swing.JButton;

docs/java/59.md

@@ -32,7 +32,7 @@ Lambda 表达式**仅具有主体和参数列表**。
 
 要使用 lambda 表达式，您需要创建自己的功能接口或使用 Java 提供的预定义功能接口。只有单个抽象方法的**接口称为功能接口（或单抽象方法接口），例如：Runnable，callable，ActionListener 等。**
 
-**使用功能界面：**
+**使用功能接口：**
 Pre Java 8：我们创建匿名内部类。
 Post Java 8：您可以使用 lambda 表达式而不是匿名内部类。
 

docs/java/61.md

@@ -4,13 +4,13 @@
 
 只有单个抽象方法的**接口称为功能接口。您可以使用 Java 提供的预定义功能接口，也可以创建自己的功能接口并使用它。您可以在这里检查预定义的功能接口：[预定义的功能接口](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)它们都只有一个抽象方法。这就是原因，它们也被称为单抽象方法接口（SAM 接口）。**
 
-要在 Java 中使用 [lambda 表达式，您需要创建自己的功能接口或使用 Java 提供的预定义功能接口。在创建自己的功能界面时，用 **@FunctionalInterface** 注释标记它，这个注释是在 Java 8 中引入的。尽管它是可选的，你应该使用它，这样如果你用这个标记的接口就会出现编译错误注释不遵循功能接口的规则。](https://beginnersbook.com/2017/10/java-lambda-expressions-tutorial-with-examples/)
+要在 Java 中使用 [lambda 表达式，您需要创建自己的功能接口或使用 Java 提供的预定义功能接口。在创建自己的功能接口时，用 **@FunctionalInterface** 注释标记它，这个注释是在 Java 8 中引入的。尽管它是可选的，你应该使用它，这样如果你用这个标记的接口就会出现编译错误注释不遵循功能接口的规则。](https://beginnersbook.com/2017/10/java-lambda-expressions-tutorial-with-examples/)
 
 ## 定义功能接口的规则是什么？
 
-功能界面应该有**只有一个**抽象方法。除了一个抽象方法，它们还可以包含任意数量的默认和静态方法。
+功能接口应该有**只有一个**抽象方法。除了一个抽象方法，它们还可以包含任意数量的默认和静态方法。
 
-## 示例 1：创建自己的功能界面
+## 示例 1：创建自己的功能接口
 
 ```java
 @FunctionalInterface

docs/java/64.md

@@ -116,7 +116,7 @@ String is: Java 8 is easy to learn
 
 通过在接口中引入默认方法，似乎[抽象类](https://beginnersbook.com/2013/05/java-abstract-class-method/)与 java 8 中的接口相同。然而，这并非完全正确，即使我们现在可以使用具体方法（带有 body 的方法）接口就像抽象类一样，这并不意味着它们是相同的。它们之间仍然存在很少的差异，其中之一是抽象类可以有构造函数，而在接口中我们不能有构造函数。
 
-接口的目的是提供完全抽象，而抽象类的目的是提供部分抽象。这仍然适用。界面就像是您班级的蓝图，通过引入默认方法，您可以简单地说我们可以在界面中添加其他功能而不会影响最终用户类。
+接口的目的是提供完全抽象，而抽象类的目的是提供部分抽象。这仍然适用。接口就像是您班级的蓝图，通过引入默认方法，您可以简单地说我们可以在接口中添加其他功能而不会影响最终用户类。
 
 ## 默认方法和多重继承
 

docs/java/9.md

-# Java 中的`if`和`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/)
 

docs/java/SUMMARY.md

@@ -23,7 +23,7 @@
     +   [使用示例在 Java 中重载方法](24.md)
     +   [用示例覆盖 java 中的方法](25.md)
     +   [java 中方法重载和覆盖之间的区别](26.md)
-    +   [Java 中的多态性与示例](27.md)
+    +   [Java 中的多态与示例](27.md)
     +   [java-运行时和编译时多态的多态类型](28.md)
     +   [java 中的静态和动态绑定](29.md)
     +   [Java 中的抽象类与示例](30.md)