diff --git a/docs/java/19.md b/docs/java/19.md
index ce0167d749b4cbac6e6217d465f21bdb87c5bba8..30c2ceb163e13ce4fb2f0db76703b67b82ca615b 100644
--- a/docs/java/19.md
+++ b/docs/java/19.md
@@ -75,6 +75,7 @@ Teaching
 > 基于上述例子，我们可以说`PhysicsTeacher` **IS-A** `Teacher`。这意味着子类与父类具有 IS-A 关系。这是继承被称为子类和父类之间的 **IS-A 关系**
 
 **注意：**
+
 派生类继承声明为`public`或`protected`的所有成员和方法。如果超类的成员或方法声明为`private`，则派生类不能直接使用它们。私有成员只能在自己的类中访问。只能使用公共或受保护的超类获取器和设置器方法访问此类私有成员，如下例所示。
 
 ```java
diff --git a/docs/java/27.md b/docs/java/27.md
index 5536ec667087bd1778e183e45c2ac3b8a94a9ef7..4629e483e26c3bb82e68f08aad74ce4ee9fcd829 100644
--- a/docs/java/27.md
+++ b/docs/java/27.md
@@ -54,6 +54,7 @@ public class Cat extends Animal{
 ## 例 1：Java 中的多态
 
 **运行时多态示例：**
+
 Animal.java
 
 ```java
diff --git a/docs/java/28.md b/docs/java/28.md
index 62945c546bc81f070e2daa953d8b667894164a3c..25db90e475fe59ac301005b58104dab3749a03a3 100644
--- a/docs/java/28.md
+++ b/docs/java/28.md
@@ -52,6 +52,7 @@ public class Demo
 它也称为动态方法调度。动态多态是一个在运行时解析对重写方法的调用的过程，这就是为什么它被称为运行时多态。我已经在单独的教程中详细讨论了方法覆盖，请参考：[方法覆盖 Java](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/) 。
 
 **示例**
+
 在此示例中，我们有两个类 ABC 和 XYZ。 ABC 是父类，XYZ 是子类。子类覆盖父类的`myMethod()`方法。在此示例中，我们将子类对象分配给父类引用，因此为了确定将调用哪个方法，将在运行时确定对象的类型。对象的类型决定了要调用哪个版本的方法（而不是引用的类型）。
 
 > 要理解覆盖的概念，您应该具有 Java 中[继承的基本知识。](https://beginnersbook.com/2013/03/inheritance-in-java/)
diff --git a/docs/java/3.md b/docs/java/3.md
index 675c7e85687236c7b6bdc156cedbcf63e1633e1c..5b6dad5954fde433b08678b7dcec65f160154155 100644
--- a/docs/java/3.md
+++ b/docs/java/3.md
@@ -21,6 +21,7 @@ JAVA 由 Sun Microsystems Inc 于 1991 年开发，后来被 Oracle Corporation
 所以，现在我们知道 JVM 的主要功能是执行编译器生成的字节码。 **每个操作系统都有不同的 JVM，但是在执行字节码后它们产生的输出在所有操作系统**中是相同的。这就是我们将 java 称为平台无关语言的原因。
 
 **字节码**
+
 如上所述，JDK 的`javac`编译器将 java 源代码编译成字节码，以便它可以由 JVM 执行。字节码由编译器保存在`.class`文件中。
 
 **Java 开发工具包（JDK）**
diff --git a/docs/java/31.md b/docs/java/31.md
index 457018efcb71d379adbab785f68fabe7beaf4004..faa7a023e8d21a810339178936b69093350377a8 100644
--- a/docs/java/31.md
+++ b/docs/java/31.md
@@ -113,4 +113,5 @@ class Demo implements Multiply{
 ```
 
 **参考：**
+
 [抽象方法 javadoc](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
\ No newline at end of file
diff --git a/docs/java/32.md b/docs/java/32.md
index 2583ece9e3cf0978e1e8aadba6c4cac0870f8b96..5e5be93e23fb6985eda7454922415a0f320fd012 100644
--- a/docs/java/32.md
+++ b/docs/java/32.md
@@ -13,6 +13,7 @@
 如上所述，它们用于完全抽象。由于接口中的方法没有 body，因此必须先由类实现它们才能访问它们。实现接口的类必须实现该接口的所有方法。此外，java 编程语言不允许扩展多个类，但是您可以在类中实现多个接口。
 
 **语法：**
+
 通过指定关键字“interface”声明接口。例如。：
 
 ```java
diff --git a/docs/java/38.md b/docs/java/38.md
index b6f23c6a81edfd727abd20bfea1f8706f428bfff..4b94b0dcbf6c92c5c045939bc55eadcc6a6258ee 100644
--- a/docs/java/38.md
+++ b/docs/java/38.md
@@ -72,6 +72,7 @@ class Demo{
 ```
 
 **什么是空白的最终变量？**
+
 假设我们有一个 Student 类，其中有一个名为 Roll No.的字段。由于 Roll No 不应该在学生注册后更改，我们可以将其声明为类中的最终变量但我们无法初始化没有提前为所有学生滚动（否则所有学生都会有相同的卷号）。在这种情况下，我们可以声明 roll 无变量为空白 final，我们在对象创建期间初始化此值，如下所示：
 
 ```java
@@ -198,6 +199,7 @@ The type ABC cannot subclass the final class XYZ
 ```
 
 **要记住的要点：**
+
 1）[构造函数](https://beginnersbook.com/2013/03/constructors-in-java/ "Constructors in Java – A complete study!!")不能被声明为 final。
 2）本地最终变量必须在声明期间初始化。
 3）[接口](https://beginnersbook.com/2013/05/java-interface/ "Interface in java with example programs")中声明的所有变量默认为 final。
diff --git a/docs/java/44.md b/docs/java/44.md
index b96cff675bb1a08aa4edb57675890c575f0c8c9a..32a2c132ada2d3f87f9f0b8ea3a41529bcb7b418 100644
--- a/docs/java/44.md
+++ b/docs/java/44.md
@@ -55,9 +55,11 @@ MyException Occurred: This is My error Message
 ```
 
 **说明：**
+
 你可以看到，在抛出自定义异常时，我在括号中给出了一个字符串（`throw new MyException("This is My error Message");`）。这就是为什么我的自定义异常类中有[参数化构造函数](https://beginnersbook.com/2014/01/parameterized-constructor-in-java-example/)（带有 String 参数）的原因。
 
 **注意：**
+
 1.用户定义的异常必须扩展 Exception 类。
 2.使用 throw 关键字抛出异常。
 
diff --git a/docs/java/48.md b/docs/java/48.md
index 5c25144489ac8d0ab127a2e971c3300618d0dcfd..b3d50dfddb4e9a1ba8dc43c93776440b1843d3f7 100644
--- a/docs/java/48.md
+++ b/docs/java/48.md
@@ -22,6 +22,7 @@
 这里@符号表示这是一个注解，而 Override 是这个注解的名称。
 
 **我们可以在哪里使用注解？**
+
 注解可以应用于类，接口，方法和字段。例如，以下注解正在应用于该方法。
 
 ```java
diff --git a/docs/java/52.md b/docs/java/52.md
index 8d7a83d92e7ada4ae844b22b32201d8b1ccd0de2..f1bc3e452b4556225136c2d98d46f98bd57316f9 100644
--- a/docs/java/52.md
+++ b/docs/java/52.md
@@ -169,6 +169,7 @@ My thread is in running state.
 ```
 
 **示例程序 2：**
+
 观察该程序的输出并尝试了解该程序中发生的情况。如果你已经理解了每个线程方法的用法，那么你应该不会遇到任何问题，理解这个例子。
 
 ```java
diff --git a/docs/java/53.md b/docs/java/53.md
index f7f6db21e0ce05d5543c38d35ae0f610058dd89a..d57cc3398fc0c7073be4a2129c6a1e89ab7c5749 100644
--- a/docs/java/53.md
+++ b/docs/java/53.md
@@ -11,6 +11,7 @@
 让我们举个例子来更好地理解这些概念：
 
 **示例**
+
 此类实现 Serializable 接口，这意味着它可以被序列化。除了那些声明为 **transient** 的字段外，该类的所有字段都可以在转换为字节流后写入文件。在下面的示例中，我们有两个瞬态字段，这些字段不参与序列化。
 _Student.java_
 
diff --git a/docs/java/54.md b/docs/java/54.md
index f62a2d93facdf4e65e54292ba578580e9cff91c9..7a6d0aa0d711aa6b92c60d35b90984427082441a 100644
--- a/docs/java/54.md
+++ b/docs/java/54.md
@@ -20,6 +20,7 @@ Swing 是基于窗口的应用的首选 API，因为它具有平台独立性和
 按钮，文本字段，滚动条等所有元素都称为组件。在 AWT 中，我们为每个组件提供了类，如上图所示。要将屏幕上的所有内容放置到特定位置，我们必须将它们添加到容器中。容器就像一个屏幕，我们在其中放置按钮，文本字段，复选框等组件。简而言之，容器包含并控制组件的布局。容器本身是一个组件（如上面的层次结构图所示），因此我们可以在容器内添加一个容器。
 
 **容器类型：**
+
 如上所述，容器是我们添加文本字段，按钮，复选框等组件的地方.AWT 中有四种类型的容器：窗口，框架，对话框和小组。如上面的层次结构图所示，Frame 和 Dialog 是 Window 类的子类。
 
 **窗口：** Window 类的一个实例没有边框也没有标题
diff --git a/docs/java/59.md b/docs/java/59.md
index ec800bb99f45cf5897e793eae607f06ab35a9830..47788eaa83cfc7b15c93593434b61c737548bf99 100644
--- a/docs/java/59.md
+++ b/docs/java/59.md
@@ -33,6 +33,7 @@ Lambda 表达式**仅具有主体和参数列表**。
 要使用 lambda 表达式，您需要创建自己的功能接口或使用 Java 提供的预定义功能接口。只有单个抽象方法的**接口称为功能接口（或单抽象方法接口），例如：Runnable，callable，ActionListener 等。**
 
 **使用功能接口：**
+
 Pre Java 8：我们创建匿名内部类。
 Post Java 8：您可以使用 lambda 表达式而不是匿名内部类。
 
@@ -86,6 +87,7 @@ public class ButtonListenerNewWay {
 ```
 
 **注意：**
+
 1.正如您所看到的，我们使用较少的代码与 lambda 表达式。
 2.向后兼容性：您可以将 lambda 表达式与旧代码一起使用。 Lambdas 是向后兼容的，因此当您将项目迁移到 Java 8 时，可以在现有 API 中使用它们。
 
diff --git a/docs/java/62.md b/docs/java/62.md
index dab9f1e40c69d48a8f84b50a157da29a703ad736..d3987007ae6f1e83a29d0ae8fe7afd40181d4031 100644
--- a/docs/java/62.md
+++ b/docs/java/62.md
@@ -64,6 +64,7 @@ There are 3 strings with length less than 6
 ```
 
 **这些代码有什么区别？**
+
 两个示例的输出都是相同的，但是如果考虑代码的性能，这些示例之间会有很大的不同。
 **在第一个例子**中，我们迭代整个列表以找到长度小于 6 的字符串。此代码中没有并行性。
 **在第二个例子**中，`stream()`方法返回所有名称的流，`filter()`方法返回另一个长度小于 6 的名称流，`count()`方法减少了这个流到结果。所有这些操作都是并行发生的，这意味着我们能够在流的帮助下并行化代码。 **使用流并行执行操作比不使用流**的顺序执行更快。
diff --git a/docs/java/67.md b/docs/java/67.md
index 278ffea11200a2b38ab266df90bc4013eb0cdf35..4636d6205d2e9099840cc54ae5885e9bb8c04331 100644
--- a/docs/java/67.md
+++ b/docs/java/67.md
@@ -169,4 +169,5 @@ Apple,Banana,Orange,Kiwi,Grapes
 ```
 
 **参考文献：**
+
 [Java 8 - StringJoiner JavaDoc](https://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html)
\ No newline at end of file
diff --git a/docs/java/68.md b/docs/java/68.md
index de83378af4f3f0ce46ebcfda8cb44472bd3e951e..84d580e53c290f9da0727d570a29335b659951c4 100644
--- a/docs/java/68.md
+++ b/docs/java/68.md
@@ -217,4 +217,5 @@ Optional[Game of Thrones]
 ```
 
 **参考文献：**
+
 [Java 8 - `Optional`类 JavaDoc](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)
\ No newline at end of file
diff --git a/docs/java/69.md b/docs/java/69.md
index d24bd8d8faa9a6a30c930ded35e9141657164158..dcc38b6a1c16c9905aadb0c33007b05bd2c471a1 100644
--- a/docs/java/69.md
+++ b/docs/java/69.md
@@ -9,6 +9,7 @@ Java 8 在`java.util`包的`Arrays`类中引入了一个新方法`parallelSort()
 3.已合并的已排序子数组。
 
 **并行排序优于简单排序的优点：**
+
 `parallelSort()`方法使用[多线程](https://beginnersbook.com/2013/03/multithreading-in-java/)的概念，与[正常排序](https://beginnersbook.com/2014/07/how-to-sort-an-array-in-java/)相比，有很多元素时它更快。
 
 ## 示例 1：对原始数据类型进行并行排序
@@ -33,6 +34,7 @@ public class Example {
 ```
 
 **参考文献：**
+
 [Java 8 - 并行排序 JavaDoc](http://download.java.net/lambda/b84/docs/api/java/util/Arrays.html#parallelSort(int[]))
 
 ## 示例 2：通过指定开始和结束索引进行并行排序
diff --git a/docs/java/74.md b/docs/java/74.md
index 6c7ddb4d7d3bfbe396ea2706e2c9e839fba9b1e2..22fca3083e796672d7e1f3533726672b195057dc 100644
--- a/docs/java/74.md
+++ b/docs/java/74.md
@@ -69,6 +69,7 @@ static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2...)
 ```
 
 **示例：**
+
 为了演示使用`Map.of()`工厂方法，我们采用了与上面使用`unmodifiableMap()`方法相同的示例。正如您所看到的，它在 Java 9 中是多么简单。我们在一行中减少了 6 行代码。
 
 ```java
diff --git a/docs/java/75.md b/docs/java/75.md
index 404629cd05b52d2d067f8d80215e3ba28be2c5e5..54eb9f165f15df83a5166a31931e260d1723e61a 100644
--- a/docs/java/75.md
+++ b/docs/java/75.md
@@ -11,6 +11,7 @@ Java 9 在接口中引入了**私有方法**，通过私有方法共享多个默
 为了理解这一点，我们必须在 Java 8 中使用一个示例（没有私有方法），然后我们将使用 Java 9（使用私有方法）采用相同的示例。
 
 **Java 8 中的示例 - 具有重复代码的多个默认方法（公共代码）**
+
 在此示例中，我们将看到默认方法如何具有重复代码，这些代码不必要地增加代码行并使代码更少 - 可读。我们将使用私有方法再次使用相同的示例来查看私有方法如何帮助我们避免重复的代码。
 
 ```java
@@ -40,6 +41,7 @@ public class JavaExample implements MyInterfaceInJava8{
 ![Java 8 - default methods with common code](img/a53e4017479fde0404f12c1030576e6e.jpg)
 
 **Java 9 中的示例 - 使用私有方法共享公共代码的默认方法**
+
 我们采用的是上面我们看到的相同示例。这次我们将介绍一种私有方法来共享公共代码。
 
 ```java
diff --git a/docs/java/76.md b/docs/java/76.md
index 3c4406a6f72eeb37c870b67ab758ffb221d85594..84cdaeea660da02fef62954cfdc3ffe8bd6a956c 100644
--- a/docs/java/76.md
+++ b/docs/java/76.md
@@ -77,6 +77,7 @@ Compile-time error
 上面的示例抛出编译时错误，因为资源是在`Try-With-Resource`语句的范围之外声明的。
 
 **Java 7 - 外部声明的资源 - 重复资源作为变通方法**
+
 为了解决上述错误，我们不得不在 Java 7 中做一个解决方法。我们过去常常复制资源引用，如下所示：
 
 ```java