2020-06-23 11:07:32

docs/173.md

@@ -12,7 +12,7 @@
 
 *   封装形式
 *   数据抽象
-*   遗产
+*   继承
 *   多态性
 
 如果我想模拟现实生活，我会说 OO 就像一家餐馆。 您可以有两种类型：一种可以在柜台上找到食物，也可以用食物自助服务。 另一个是您进餐的地方，它是由专业服务准备并带给您的。
@@ -45,7 +45,7 @@
 
 但是，Python 知道用于只读字段的解决方案，这些字段是通过所谓的“ getter”方法即时计算的。 当然，对于读写字段，Python 也使我们也可以使用“ setter”方法。 我们将在后面看到这两个示例。
 
-### 遗产
+### 继承
 
 继承是 OOP 的一项关键功能，其中一个类基于另一类的模板/实现（从该类继承）。 这是一种代码重用的基本方法，您可以将子类之间的通用功能和信息封装到一个基类中。
 

docs/31.md

@@ -16,22 +16,22 @@ Java 中的每个 Exception 都是 Exception 类的子类型，而 Exception 类
 
 ## 已检查与未检查异常
 
-### 检查异常
+### 受检异常
 
-1.  ***检查的异常*** 是 Exception 的子类，但 RuntimeException 及其子类除外。
-2.  Checked Exception 强制程序员处理可能引发的异常。
-3.  当方法中发生检查的异常时，该方法必须捕获异常并采取适当的措施，或者将异常传递给其调用方。
+1.  ***受检异常***是`Exception`的子类，但`RuntimeException`及其子类除外。
+2.  受检异常强制程序员处理可能引发的异常。
+3.  当方法中发生受检异常时，该方法必须捕获异常并采取适当的措施，或者将异常传递给其调用方。
 
 #### 例
 
 IO 异常。
 
-### 未经检查的异常
+### 非受检异常
 
-1.  ***未检查的异常*** 是 *RuntimeException* 及其任何*子类*。
-2.  编译器不会强制程序员捕获未经检查的异常或在 throws 子句中声明它。
+1.  ***非受检异常*** 是 *RuntimeException* 及其任何*子类*。
+2.  编译器不会强制程序员捕获非受检异常或在 throws 子句中声明它。
 3.  程序员甚至可能不知道会引发异常。
-4.  已检查的异常必须在编译时捕获。
+4.  受检异常必须在编译时捕获。
 5.  运行时异常不是必需的。
 
 #### Example
@@ -42,11 +42,11 @@ ArrayIndexOutOfBounds 异常。
 
 现在我们知道 Java 程序可以在任何时间（或任何位置）发生异常。 因此，我们需要知道如何处理这些异常。 处理异常是开发健壮的应用时必需的属性。 处理异常意味着在发生异常时将程序的执行转移到适当的处理程序。 我们可以使用 try-catch 块来处理异常。
 
-**try**： try 用于定义可能发生异常的代码块。
+**`try`**：`try`用于定义可能发生异常的代码块。
 
-**catch**： catch 用于匹配特定类型的异常。 一个 try 块可能有多个 catch 子句。
+**`catch`**：`catch`用于匹配特定类型的异常。 一个 try 块可能有多个 catch 子句。
 
-最终****：最终确定将在 try 块之后始终执行的代码块。 即使在例外的情况下。
+**`finally`**：`finally`确定将在 try 块之后始终执行的代码块。 即使在例外的情况下。
 
 ```java
  try {
@@ -72,10 +72,10 @@ ArrayIndexOutOfBounds 异常。
 
 ## 备忘单
 
-*   ***已检查*** & ***未检查的异常*** 是两种类型的异常 ***。***
-*   受检查的异常是那些 Exception 类的子类型，但不包括扩展 ***运行时异常*** 的类。
-*   ***错误*** 和 ***运行时异常*** 的子类型属于未经检查的异常。
-*   *最后，*块将始终在所有条件下调用**。**
+*   ***受检***和***非受检异常***是两种类型的异常。
+*   受检异常是那些`Exception`类的子类型，但不包括扩展***运行时异常***的类。
+*   ***错误***和***运行时异常***的子类型属于非受检异常。
+*   `finally`块将始终在所有条件下调用。
 *   System.exit（）是无法阻止 finally 块执行的唯一方法，在这种情况下，JVM 将关闭。
 *   还可以通过扩展 Exception 类来创建自定义异常。
 *   渔获物的订购应以最特殊的形式订购。 否则，编译器将抱怨无法访问的代码。

docs/32.md

@@ -29,9 +29,9 @@ public class ResourceMgt {
 
 如果您看上面的示例代码，要关闭 BufferedReader 资源，我们必须检查它是否仍然打开，然后调用 close（）方法。 close 方法可能会引发异常，因此必须将其包围在 try catch 块中。 对于每个打开的资源，都将重复此代码。 对于大型应用，由于这个原因，您将看到很多重复的代码。
 
-在 Java 7 和更高版本中，try-with-resources 语句可确保在该语句的末尾关闭所有打开的资源。 因此，try-with-resources 语句不过是声明一个或多个资源的 try 语句。 所谓资源就是实现 **java.lang.AutoCloseable** 接口的任何对象。 该接口又包括实现 **java.io.Closeable** 接口的所有对象。
+在 Java 7 和更高版本中，`try-with-resources`语句可确保在该语句的末尾关闭所有打开的资源。 因此，try-with-resources 语句不过是声明一个或多个资源的 try 语句。 所谓资源就是实现`java.lang.AutoCloseable`接口的任何对象。 该接口又包括实现`java.io.Closeable`接口的所有对象。
 
-因此，使用 **try-with-resources 语句**的同一示例可以写成：
+因此，使用`try-with-resources`语句的同一示例可以写成：
 
 ```java
 public class ResourceMgt {
@@ -54,7 +54,7 @@ public class ResourceMgt {
 *   如果 finally 块的唯一目的只是关闭资源，则不需要。
 *   自动资源管理。
 
-在我们的示例中，由于在 **try-with-resource** 语句中声明了 **BufferedReader** 实例，因此无论 try 语句是否成功完成，都将关闭它（如 readLine 方法 （）可以引发 IOException）。
+在我们的示例中，由于在`try-with-resource`语句中声明了`BufferedReader`实例，因此无论 try 语句是否成功完成，都将关闭它（如``readLine()`方法可以引发 IOException）。
 
 **值得注意的要点**：
 
@@ -92,7 +92,7 @@ public interface AutoClosable {
 
 让我们创建两个实现 AutoCloseable 接口的自定义类，
 
-**Bar.java**
+`Bar.java`
 
 ```java
 public class Bar implements AutoCloseable{
@@ -109,7 +109,7 @@ public class Bar implements AutoCloseable{
 }
 ```
 
-**Foo.java**
+`Foo.java`
 
 ```java
 public class Foo implements AutoCloseable{
@@ -129,7 +129,7 @@ public class Foo implements AutoCloseable{
 
 Foo 类的 doSomething（）和 close（）方法引发异常。
 
-**MyTryWithResources.java**
+`MyTryWithResources.java`
 
 ```java
 public class MyTryWithResources {

docs/33.md

@@ -26,15 +26,15 @@ try{
 ### 注意
 
 1.  在 try 块和 catch 块之间不能编写任何代码。
-2.  尝试块必须紧随其后的是 catch 或 finally 块，或二者兼而有之。 如果没有**捕获**块，则尽管 finally 方法具有 try / finally，但 final 方法应**声明异常**。
+2.  尝试块必须紧随其后的是 catch 或 finally 块，或二者兼而有之。 如果没有`catch`块，则尽管 finally 方法具有 try / finally，但 final 方法应**声明异常**。
 3.  您将无法获得成功或最终没有尝试块。
 4.  如果您不想在代码中处理异常，请使用**引发并声明**子句。 谁调用您的代码都必须使用 try / catch 块来处理它。
 
 ## 流量控制
 
-1.  如果 **try 块成功**，即未引发异常，则控制将移至 finally 块（如果存在）。 跳过捕获块。 在没有 finally 块的情况下，将执行 catch 块下面的任何代码。
-2.  如果 **try 块失败**（发生异常），则控制权转移到处理异常的 catch 块。 try 块中的其余代码永远不会执行。 如果存在 finally 块，则在 catch 块执行完成后运行。
-3.  如果 **try / catch 块**具有**返回语句**，那么即使执行 finally 块！ 流控制首先跳转到 finally 块，然后返回 return 语句。
+1.  如果`try`块成功，即未引发异常，则控制将移至 finally 块（如果存在）。 跳过捕获块。 在没有 finally 块的情况下，将执行 catch 块下面的任何代码。
+2.  如果`try`块失败（发生异常），则控制权转移到处理异常的 catch 块。 try 块中的其余代码永远不会执行。 如果存在 finally 块，则在 catch 块执行完成后运行。
+3.  如果`try/catch`块**具有**返回语句，那么即使执行`finally`块！ 流控制首先跳转到 finally 块，然后返回 return 语句。
 
 ### 例
 
@@ -71,7 +71,7 @@ returning from try block
 1.  try 块运行并打印“开始执行 try 块”。
 2.  一旦遇到 return 语句，流程将立即转移到 finally 块并打印“ finally 的 print 语句”。
 3.  最终块执行完成后，控制权返回 try 块中的 return 语句，并返回“从 try 块返回”。
-4.  如果**最后的**块具有**返回语句**，则来自 try / catch 块的 return 语句将被覆盖。
+4.  如果`finally`块具有**返回语句**，则来自 try / catch 块的 return 语句将被覆盖。
 
 ### 范例
 
@@ -136,7 +136,7 @@ catch(ArrayIndexOutOfBoundsException | SQLException ex){
 
 #### 注意
 
-1.  每当单个 catch 块处理多个异常时，参考变量（上例中为“ ex”）为**最终**，因此将其视为常量。 因此，无法为其分配其他任何值。 在某些情况下，这限制了异常处理能力。
+1.  每当单个 catch 块处理多个异常时，参考变量（上例中为“ ex”）为`final`，因此将其视为常量。 因此，无法为其分配其他任何值。 在某些情况下，这限制了异常处理能力。
 2.  不能将异常类型与其父类组合在一起，因为子类异常由于已经被捕获而变得不可访问。
 
 #### 范例

docs/35.md

@@ -49,14 +49,14 @@
 ## 方法重载备忘单
 
 *   使用相同的方法名称但使用*不同的参数*称为重载。
-*   ***构造器*** 也可以重载
+*   ***构造器***也可以重载
 *   重载的方法必须设置*不同的*参数。
-*   重载方法 ***可能*** 具有不同的返回类型 ***。***
-*   重载的方法 ***可能*** 具有*不同的访问修饰符。*
-*   重载的方法 ***可能会*** 抛出不同的异常 ***更宽或更窄的*** 没有限制
+*   重载的方法***可能***具有不同的返回类型。
+*   重载的方法***可能***具有不同的访问修饰符。
+*   重载的方法***可能***抛出不同的异常，***更宽或更窄的***没有限制。
 *   **超类**中的方法也可以在子类中重载。
-*   多态适用于覆盖不超载
-*   基于**参考类型**，确定在 ***编译时间*** 上确定将调用哪个重载方法。
+*   多态适用于覆盖和重载。
+*   基于**参考类型**，确定在***编译时间***上确定将调用哪个重载方法。
 
 方法重载示例
 

docs/36.md

@@ -34,7 +34,7 @@ System.out.println("Show method of Sub class");
 *   覆盖方法*不能使*具有比被覆盖的方法更多的*限制性访问修饰符*，但可以更少。
 *   参数列表必须与覆盖的方法完全匹配，如果不匹配，则很可能是您正在重载该方法。
 *   返回类型必须与在 Superclass 中的重写方法中声明的返回类型相同或为该子类型的子类型。
-*   覆盖方法*可以*抛出任何*未检查的异常（运行时）*，但是它可以抛出比被覆盖方法声明的范围更广或更新的检查异常，但不能抛出更少或狭窄的检查 例外。
+*   覆盖方法*可以*抛出任何*非受检异常（运行时）*，但是它可以抛出比被覆盖方法声明的范围更广或更新的检查异常，但不能抛出更少或狭窄的检查 例外。
 *   *不能覆盖最终的* 方法*。*
 *   *静态* 方法*无法覆盖*。 静态方法看起来可以覆盖，但它是隐藏的。
 *   如果*方法无法继承，则无法重写*。**
@@ -104,14 +104,14 @@ class superclass {
 
 *   *不能重写构造器*。
 *   覆盖方法必须具有相同的参数集。
-*   重写的方法必须具有相同的返回类型。 这些返回类型也可以是子类（ ***协变返回*** ）。
-*   覆盖的方法**无法使**具有更严格的访问修饰符。
-*   覆盖的方法**无法**抛出*新的或更广泛的*异常（ ***已选中*** ）。 看下面的例子
-*   覆盖的方法**可以引发**任何*未检查的异常。*
-*   **最终**方法 ***无法覆盖*** 。
-*   ***私有方法*** 没有继承到子类，因此*不能将*重写为子类中的*。*
+*   重写的方法必须具有相同的返回类型。 这些返回类型也可以是子类（***协变返回***）。
+*   覆盖的方法**无法**具有更严格的访问修饰符。
+*   覆盖的方法**无法**抛出*新的或更广泛的*异常（***受检***）。 看下面的例子
+*   覆盖的方法**可以引发**任何*非受检异常*。
+*   **最终**方法***无法覆盖***。
+*   ***私有方法***没有继承到子类，因此*不能*在子类中覆盖*。
 *   多态适用于覆盖。
-*   ***对象类型*** 确定将调用哪个覆盖方法，并由*运行时*确定。
+*   ***对象类型***确定将调用哪个覆盖方法，并由*运行时*确定。
 
 ### 方法覆盖异常示例
 

docs/37.md

@@ -6,7 +6,7 @@
 
 ## 声明接口
 
-可以使用 ***接口*** 关键字定义接口。 在 Java 8 之后，接口定义发生了很多变化。
+可以使用`interface`关键字定义接口。 在 Java 8 之后，接口定义发生了很多变化。
 
 ## Java 接口示例
 
@@ -39,7 +39,7 @@ public interface Interface_JAVA8 {
 }
 ```
 
-Java 8 引入了默认方法的概念。 现在，如果接口不是抽象的，则可以包含方法主体。 Interface 内部的方法可以包含“抽象”，“静态”或“默认”修饰符中的**。**
+Java 8 引入了默认方法的概念。 现在，如果接口不是抽象的，则可以包含方法主体。 Interface 内部的方法可以包含“抽象”，“静态”或“默认”修饰符。
 
 ## Java 9 接口私有方法
 
@@ -154,11 +154,11 @@ abstract class InterfaceExampleThree implements interfaceTwo {
 
 ### 子弹点
 
-*   接口是 100％抽象类（ ***隐式*** ）。 在 Java 8 之后，它不成立。
+*   接口是 100％抽象类（***隐式***）。 在 Java 8 之后，它不成立。
 *   接口可以由任何继承树中的任何类实现。
 *   接口中的所有方法都是抽象的。 （在 Java 8 中为 abstract / static / default）
-*   接口可以具有**常量**，这些常量是公开的，静态的和最终的（ ***隐式*** ）。
-*   接口方法隐式地 ***公开&抽象。 （在 Java 8 之前）*** 
+*   接口可以具有**常量**，这些常量是公开的，静态的和最终的（***隐式***）。
+*   接口方法是隐式公开和抽象的。 （在 Java 8 之前）
 *   接口也可以具有私有方法。 （Java 9）
 *   实现接口的类也可以是抽象类。
 *   实现接口的抽象类不必实现所有抽象方法。

docs/38.md

-# 遗产
+# 继承
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/inheritance/](https://javabeginnerstutorial.com/core-java-tutorial/inheritance/)
 
@@ -13,18 +13,18 @@ Java 继承定义了超类及其子类之间的 is-a 关系。 这意味着只
 3.  子类只能扩展一个超类
 4.  在超类中具有默认可访问性的成员也不会被其他包中的子类继承，因为这些成员只能通过其与超类在同一包中的子类中的简单名称进行访问。
 
-**这个**和**超级**关键字：
+`this`和`super`关键字：
 
-这两个关键字 super 和 super 帮助您显式命名所需的字段或方法。 使用此关键字和超级关键字，您可以完全控制是否要调用同一类中的方法或字段，还是要从直接父类中调用。 ***此*** 关键字用作对作为当前 Class 实例的当前 Object 的引用。 super 关键字还引用当前的 Object，但作为当前类的超类的实例。
+这两个关键字 super 和 super 帮助您显式命名所需的字段或方法。 使用此关键字和超级关键字，您可以完全控制是否要调用同一类中的方法或字段，还是要从直接父类中调用。 `this`关键字用作对作为当前 Class 实例的当前 Object 的引用。 super 关键字还引用当前的 Object，但作为当前类的超类的实例。
 
-***此*** 关键字引用当前对象，在局部变量隐藏或覆盖相同名称的字段的情况下很有用。 如果某个方法需要将当前对象传递给另一个方法，则可以使用此引用进行传递。 注意，该引用不能在静态上下文中使用，因为在任何 Object 的上下文中都不会执行静态代码。
+`this`关键字引用当前对象，在局部变量隐藏或覆盖相同名称的字段的情况下很有用。 如果某个方法需要将当前对象传递给另一个方法，则可以使用此引用进行传递。 注意，该引用不能在静态上下文中使用，因为在任何 Object 的上下文中都不会执行静态代码。
 
 ## Java 继承备忘单
 
-*   父类的所有**公开变量**将由子类继承*。*
-*   所有子类将仅继承*同一包中的所有默认变量。 包*之外的子类将不会继承任何默认成员。
-*   **私有成员** *无法由子类继承，因为它们对子类不可见，因此，子类可以使用相同的名称创建 Method 或属性，而不会出现任何问题。*
-*   所有子类都将继承*同一包或外部包* **（与默认设置不同）**中的受保护变量。
+*   父类的所有**公开变量**将由子类继承。
+*   所有子类将仅继承*同一包中的所有默认变量*。 包之外的子类将不会继承任何默认成员。
+*   **私有成员**无法由子类继承，因为它们对子类不可见，因此，子类可以使用相同的名称创建 Method 或属性，而不会出现任何问题。*
+*   所有子类都将继承*同一包或外部包* （**与默认设置不同**）中的受保护变量。
 *   未继承的方法**不能被覆盖**。 因此，覆盖的规则无法应用于这些方法。 但是方法仍然可以在子类中定义，尽管这些方法将不会被覆盖。 相反，它代表一个新的方法。
 *   静态方法或变量不参与继承。
 *   即使静态方法或变量不参与继承且不能被覆盖，也可以在子类中重新定义它们。 重新定义不称为覆盖，而是隐藏。

docs/40.md

@@ -2,13 +2,13 @@
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/this-keyword-java/](https://javabeginnerstutorial.com/core-java-tutorial/this-keyword-java/)
 
-## 这个是什么
+## `this`是什么
 
-***这个*** 是 Java 中的关键字。 可以在类的*方法*或*构造器*内部使用。 它（ ***此）*** 用作对当前对象的引用，当前对象的方法或构造器正在被调用。 此关键字可用于从实例方法或构造器中引用当前对象的任何成员。
+`this`是 Java 中的关键字。 可以在类的*方法*或*构造器*内部使用。 它（`this`） 用作对当前对象的引用，当前对象的方法或构造器正在被调用。 此关键字可用于从实例方法或构造器中引用当前对象的任何成员。
 
-## *此*关键字，带有字段（实例变量）
+## `this`关键字，带有字段（实例变量）
 
-*这个*关键字在处理变量隐藏时可能非常有用。 我们不能创建两个具有相同名称的实例/局部变量。 但是，创建一个实例变量&，一个具有相同名称的局部变量或 Method 参数是合法的。 在这种情况下，局部变量将隐藏实例变量，这称为变量隐藏。
+`this`关键字在处理变量隐藏时可能非常有用。 我们不能创建两个具有相同名称的实例/局部变量。 但是，创建一个实例变量&，一个具有相同名称的局部变量或 Method 参数是合法的。 在这种情况下，局部变量将隐藏实例变量，这称为变量隐藏。
 
 ### 变量隐藏示例
 
@@ -43,7 +43,7 @@ Value of variable :10
 Value of variable :40
 ```
 
-如您在上面的示例中看到的那样，实例变量正在隐藏，并且局部变量（或“方法参数”）的值不显示为实例变量。 要解决此问题，请使用 ***这个*** 关键字，并使用一个字段指向实例变量而不是局部变量。
+如您在上面的示例中看到的那样，实例变量正在隐藏，并且局部变量（或“方法参数”）的值不显示为实例变量。 要解决此问题，请使用`this`关键字，并使用一个字段指向实例变量而不是局部变量。
 
 ### Java 中此关键字的示例，用于变量隐藏
 
@@ -82,11 +82,11 @@ Value of Instance variable :5
 Value of Local variable :40
 ```
 
-## *此*关键字，带有构造器
+## `this`关键字和构造器
 
-***“ this”*** 关键字可以在构造器内使用，以调用同一 Class 中的另一个重载构造器。 这称为显式构造器调用。 如果一个类有两个重载的构造器，一个不带参数，另一个不带参数，则会发生这种情况。 然后**“** ***this”*** 关键字可用于从构造器中调用带有参数的构造器，而无需使用参数。 这是必需的，因为无法显式调用构造器。
+`this`关键字可以在构造器内使用，以调用同一 Class 中的另一个重载构造器。 这称为显式构造器调用。 如果一个类有两个重载的构造器，一个不带参数，另一个不带参数，则会发生这种情况。 然后`this`关键字可用于从构造器中调用带有参数的构造器，而无需使用参数。 这是必需的，因为无法显式调用构造器。
 
-### *的示例，此*与构造器
+### `this`与构造器的示例
 
 ```java
 class JBT {
@@ -114,18 +114,18 @@ Inside Constructor with String parameter as JBT
 Inside Constructor without parameter 
 ```
 
-如您所见，“ *this”* 可用于调用同一 Class 中的重载构造器。
+如您所见，`this`可用于调用同一 Class 中的重载构造器。
 
-**注意***：
+**注意**：
 
-*   ***此*** 关键字只能是构造器中的第一个语句。
-*   构造器可以具有 ***这个*** 或 ***超级*** 关键字，但不能同时具有这两个关键字。
+*   `this`关键字只能是构造器中的第一个语句。
+*   构造器可以具有`this`或`super`关键字，但不能同时具有这两个关键字。
 
-## *此*关键字和方法
+## `this`关键字和方法
 
-***此*** 关键字也可以在 Methods 内部使用，以从同一类调用另一个 Method。
+`this`关键字也可以在 Methods 内部使用，以从同一类调用另一个 Method。
 
-### 此关键字与 Method 的示例
+### `this`关键字与 Method 的示例
 
 ```java
 class JBT {

docs/41.md

@@ -88,7 +88,7 @@ Inside Static method
 Inside Static method
 ```
 
-**注***：静态关键字可以与变量和方法一起使用。 它是 ***不适用于*** 类。
+**注**：静态关键字可以与变量和方法一起使用。 它***不适用于***类。
 
 ## 类变量 – 静态字段
 
@@ -100,17 +100,17 @@ Inside Static method
 
 ## 静态关键字规则
 
-*   ***变量或方法*** 标记为 static 的属于 **类** ，而不是任何特定实例。
-*   **静态方法或变量** 可以在不创建或引用类实例的情况下使用。
+*   标记为`static`的***变量或方法***属于**类** ，而不是任何特定实例。
+*   **静态方法或变量**可以在不创建或引用类实例的情况下使用。
 *   如果存在实例，则该类的所有实例将共享一个类的静态变量，这将导致 **仅一个副本** 。
 *   静态方法不能访问非静态变量，也不能直接调用非静态方法（它可以通过 *实例* 调用或访问 Method 或变量）。
 
 ## 备忘单
 
-*   ***静态*** 是非访问修饰符。
+*   ***静态***是非访问修饰符。
 *   **静态**修饰符可以应用于变量或方法，块或内部类。
-*   ***静态成员*** 仅属于 Class 而不是实例。
-*   静态方法**无法访问*实例变量*。**
+*   ***静态成员***仅属于 Class 而不是实例。
+*   静态方法**无法访问***实例变量*。
 *   静态方法**不能替代*，因为它们是特定于类的，并且不属于实例。***
 *   可以将 ***重新定义为*** 静态方法。
 *   如果一个类包含任何静态块，则仅当将该类加载到 JVM 中时，才执行该块。 创建多个实例不会多次运行静态块。 仅构造器将执行多次。

docs/49.md

@@ -19,7 +19,7 @@ Map 是 Java Collection 框架下的一个 Interface。
 *   不允许地图包含自身作为键。
 *   地图可以包含自身作为值。
 *   一些地图实现可以包含的键和值有一些限制。
-*   尝试插入不合格的键或值将引发未经检查的异常。
+*   尝试插入不合格的键或值将引发非受检异常。
 
 # 具体地图实施