2020-06-25 14:52:40

docs/10.md

@@ -36,7 +36,7 @@
 
 ![8](img/eb19acc335fcbd5e33e250f47c1fab25.png)
 
-在对话框中提供类名称，然后单击完成。 其他选项可供选择。 选择其他选项以创建您的主要方法。
+在对话框中提供类名称，然后单击完成。 其他选项可供选择。 选择其他选项以创建您的`main`方法。
 
 创建类之后，项目的结构将如下所示。
 

docs/126.md

@@ -41,7 +41,7 @@ Set<String> winHandles = driver.getWindowHandles();
 5.  点击按钮打开新窗口
 6.  获取两个打开的窗口的窗口句柄
 7.  通过两个句柄循环
-8.  切换到带有手柄参考的新窗口
+8.  切换到带有句柄参考的新窗口
 9.  获取标题并将其打印到控制台
 10.  关闭新视窗
 11.  将控件切换回父窗口，然后将 URL 打印到控制台

docs/127.md

@@ -22,7 +22,7 @@ driver.manage().window().maximize();
 5.  点击按钮打开小窗口
 6.  获取两个打开的窗口的窗口句柄
 7.  通过两个句柄循环
-8.  切换到带有手柄参考的新窗口
+8.  切换到带有句柄参考的新窗口
 9.  获取标题并将其打印到控制台
 10.  将小窗口最大化到全屏尺寸
 11.  关闭新视窗

docs/139.md

@@ -217,6 +217,6 @@ public class RadioBtns_Checkboxes {
 
 ![property file eclipse output](img/259ea2204c75dfa434e16dd2865ada9a.png)
 
-属性文件使自动化测试人员的生活成真，梦想成真。 由此证明！ 现在该尝试使用今天的概念了。 请务必戴好安全帽，以免碰到[例外](https://javabeginnerstutorial.com/core-java-tutorial/exception-handling-try-catch-java/)！ 还有一件事，我可以在 [GitHub 仓库](https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver/Property%20Files)中找到所有代码文件。 去看一下！
+属性文件使自动化测试人员的生活成真，梦想成真。 由此证明！ 现在该尝试使用今天的概念了。 请务必戴好安全帽，以免碰到[异常](https://javabeginnerstutorial.com/core-java-tutorial/exception-handling-try-catch-java/)！ 还有一件事，我可以在 [GitHub 仓库](https://github.com/JBTAdmin/Selenium/tree/master/AdvancedWebDriver/Property%20Files)中找到所有代码文件。 去看一下！
 
 再见！ 祝你有美好的一天！

docs/162.md

@@ -141,7 +141,7 @@ pip 1.5.6 from /Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/s
 
 否则，当您有两个具有相同名称的模块或要从恰好具有相同名称的不同模块中导入两个方法时，可能会发生另一个问题。 在这种情况下将使用哪一个？ 您如何同时使用两者？
 
-幸运的是，有一个解决方案：您可以为导入的模块甚至导入的部件（功能，类）指定自定义名称。
+幸运的是，有一个解决方案：您可以为导入的模块甚至导入的部件（函数，类）指定自定义名称。
 
 ```py
 >>> import multiprocessing as mp # from now on you can use 'mp' instead of 'multiprocessing'

docs/163.md

@@ -16,7 +16,7 @@ Type "help", "copyright", "credits" or "license" for more information.
 We want a shrubbery!
 ```
 
-这是基本的 Python 应用，它将给定的字符串输出到控制台。 基本上，我们将使用打印功能将所有消息写入控制台。
+这是基本的 Python 应用，它将给定的字符串输出到控制台。 基本上，我们将使用`print`函数将所有消息写入控制台。
 
 ## 基本语法
 
@@ -93,7 +93,7 @@ File "<stdin>", line 3
 
 注释代码有时是必要的（尽管一些开发人员说，如果必须编写注释来描述代码，则应重新编写代码）。
 
-您可以使用井号（# ）。 这告诉解释器，井号后面的同一行上的文字仅是注释，它们无意执行：
+您可以使用井号（`#`）。 这告诉解释器，井号后面的同一行上的文字仅是注释，它们无意执行：
 
 ```py
 >>> print(1+2) # results in 3 : this is comment
@@ -128,7 +128,7 @@ False class finally is return None continue for lambda try True def from nonloca
 
 我现在不会从这里开始编写带有用户输入的应用，但是我将告诉您如何要求用户提供一些东西。
 
-它带有输入功能，并且使用非常简单：
+它带有输入函数，并且使用非常简单：
 
 ```py
 >>> entered = input("Enter some text: ")
@@ -137,9 +137,9 @@ Enter some text: 42
 '42'
 ```
 
-如您所见，您可以将参数传递给输入函数，并且该参数将显示为用户的命令提示符。 他/她输入内容后，将其作为字符串存储在输入的变量中。
+如您所见，您可以将参数传递给`input`函数，并且该参数将显示为用户的命令提示符。 他/她输入内容后，将其作为字符串存储在输入的变量中。
 
-稍后，我们将更全面地检查输入功能。
+稍后，我们将更全面地检查`input`函数。
 
 ## 基本运算符
 

docs/165.md

@@ -70,7 +70,7 @@ C: \Python and then press Enter. // It is the path of the python directory
 
 ## Macintosh 安装
 
-在 Mac 中使用 Python 时，无需安装或配置其他任何东西。 但是在安装 Python 之前，您需要先安装 GCC。 可以通过下载 XCode，命令行工具或 OSX GCC 安装程序包来获得 GCC。 但是，如果您已安装 XCode，则无需安装 OSX-GCC 安装程序，因为它可能会引起问题。 在执行 XCode 的全新安装时，您需要通过在终端上运行`xcode-select –install`来添加命令行工具。 由于 OS X 由大量 UNIX 实用程序组成，因此熟悉 Linux 系统的人会注意到缺少一个像样的包管理器的关键组件，因此 Homebrew 将填补这一空白。
+在 Mac 中使用 Python 时，无需安装或配置其他任何东西。 但是在安装 Python 之前，您需要先安装 GCC。 可以通过下载 XCode，命令行工具或 OSX GCC 安装程序包来获得 GCC。 但是，如果您已安装 XCode，则无需安装 OSX-GCC 安装程序，因为它可能会引起问题。 在执行 XCode 的全新安装时，您需要通过在终端上运行`xcode-select –install`来添加命令行工具。 由于 OS X 由大量 UNIX 工具组成，因此熟悉 Linux 系统的人会注意到缺少一个像样的包管理器的关键组件，因此 Homebrew 将填补这一空白。
 
 现在要安装 Homebrew，请打开终端或 OS X 终端仿真器并运行
 

docs/166.md

@@ -50,7 +50,7 @@
 
 字符串在 Python 中定义为引号之间表示的字符列表。 我们可以使用单引号（`'`或单引号）或双引号（`"`）来表示字符串。 我们可以在一个字符串中使用另一个字符串，但是如果您使用单引号将字符串开头，则也必须以该字符串结尾。
 
-这些字符串是单行字符串，这意味着您无法将它们分散在多行中，这会导致错误。 但是，在讨论评论时，我们讨论了以三个引号开头的字符串（再次使用单引号或双引号也没有关系）。 它们可以通过多条线传播。 但是，它们会在最后转换为常规字符串，并且在写文本时仅在换行符（`\n`）处按回车符。 这种字符串最常见的用法是文档。 当我们到达函数和类时，我们将讨论这个主题。
+这些字符串是单行字符串，这意味着您无法将它们分散在多行中，这会导致错误。 但是，在讨论注释时，我们讨论了以三个引号开头的字符串（再次使用单引号或双引号也没有关系）。 它们可以通过多条线传播。 但是，它们会在最后转换为常规字符串，并且在写文本时仅在换行符（`\n`）处按回车符。 这种字符串最常见的用法是文档。 当我们到达函数和类时，我们将讨论这个主题。
 
 让我们举个简单的示例：
 
@@ -185,7 +185,7 @@ IndexError: tuple index out of range
 'My name is Bob and I am 31 years young and I have read 31 books!'
 ```
 
-取决于您以后使用哪种格式，但是在本系列文章中，我将坚持使用格式功能。 但是，如果您更喜欢% ，这里有一些字符以及它们在格式字符串中的作用：
+取决于您以后使用哪种格式，但是在本系列文章中，我将坚持使用`format`函数。 但是，如果您更喜欢`%`，这里有一些字符以及它们在格式字符串中的作用：
 
 *   **`%c`**：字符
 *   **`%s`**：格式化前通过`str()`进行字符串转换

docs/167.md

@@ -51,11 +51,11 @@ IndexError: list index out of range
 
 第二种方法是使用切片。 这样，您可以将新元素添加到列表中（或替换当前存在的元素）。 在这种情况下，您必须使用列表作为操作的右侧。 同样，**使用此方法时要小心**，因为如果从错误的位置进行切片，最终可能会丢失当前内容。
 
-而且，如果要将列表附加到列表的末尾，则必须使用需要将 iterable 作为参数的扩展功能-否则可以使用串联。 串联与我们在字符串中学到的相同：加号（`+`）。
+而且，如果要将列表附加到列表的末尾，则必须使用需要将可迭代对象作为参数的`extend`函数-否则可以使用连接。 连接与我们在字符串中学到的相同：加号（`+`）。
 
-将元素插入列表开头的最佳方法是对[：0]使用切片。 这会将元素插入列表的开头。
+将元素插入列表开头的最佳方法是对`[:0]`使用切片。 这会将元素插入列表的开头。
 
-如果必须在给定索引处将元素插入列表中的某处，请使用具有两个参数的列表插入功能：插入位置的索引和要插入的对象。 如果索引被某个值占用，则新对象将在给定索引处插入此值之前。 如果未占用索引，则将对象附加到列表。
+如果必须在给定索引处将元素插入列表中的某处，请使用具有两个参数的列表`insert`函数：插入位置的索引和要插入的对象。 如果索引被某个值占用，则新对象将在给定索引处插入此值之前。 如果未占用索引，则将对象附加到列表。
 
 ```py
 >>> a = []
@@ -111,7 +111,7 @@ IndexError: list assignment index out of range
 [1, 2, 4, 3]
 ```
 
-如您所见，将列表追加到列表会在末尾插入整个列表，而不是所提供列表的值。 因此，在这种情况下，请小心并使用扩展。
+如您所见，将列表附加到列表会在末尾插入整个列表，而不是所提供列表的值。 因此，在这种情况下，请小心并使用扩展。
 
 ### 更新 python 列表中的元素
 
@@ -149,7 +149,7 @@ IndexError: list assignment index out of range
 [1, 2, 3]
 ```
 
-如果要从列表中删除所有元素，可以使用新的空列表重新分配列表，或使用列表的清除功能。
+如果要从列表中删除所有元素，可以使用新的空列表重新分配列表，或使用列表的`clear`函数。
 
 这两种方法的区别在于，第一种方法确实在内存中留下了一些占用空间，并且列表的 ID 发生了变化，而清除列表则保留了 ID（内存位置）。
 

docs/168.md

@@ -100,7 +100,7 @@ TypeError: 'int' object is not iterable
 {1, 2, 3, 4, 5, 6, 7, (3, 4)}
 ```
 
-如上例所示，您需要为`add`函数提供一个不可变的元素（就像创建集合时一样）。 更新功能采用多个参数，这些参数必须是集合。 这些集合是不可变的，也不必只是必须是集合。 在所有情况下，都避免重复。
+如上例所示，您需要为`add`函数提供一个不可变的元素（就像创建集合时一样）。 `update`函数采用多个参数，这些参数必须是集合。 这些集合是不可变的，也不必只是必须是集合。 在所有情况下，都避免重复。
 
 ## 移除元素
 

docs/169.md

@@ -50,7 +50,7 @@ KeyError: 'baked beans'
 None
 ```
 
-如果您有两个列表，则可能需要将它们合并为对列表（最终是键值对）。 您可以使用 zip 功能执行此操作。 之后，您可以将此压缩列表转换为字典，其中每对的第一个元素将是键，而对的第二个元素将是值。
+如果您有两个列表，则可能需要将它们合并为对列表（最终是键值对）。 您可以使用`zip`函数执行此操作。 之后，您可以将此压缩列表转换为字典，其中每对的第一个元素将是键，而对的第二个元素将是值。
 
 ```py
 >>> food = ['eggs', 'sausage','bacon','spam']
@@ -82,7 +82,7 @@ None
 {'bacon': 1, 'eggs': 2, 'spam': 1}
 ```
 
-更新功能将字典作为参数或键值对列表。 元组是这些键值对的理想候选者。
+`update`函数将字典作为参数或键值对列表。 元组是这些键值对的理想候选者。
 
 要从字典中删除元素，可以使用众所周知的`del`语句，并提供键和字典名称。 自然，如果字典中不存在该键，则将得到一个`KeyError`。
 

docs/171.md

@@ -107,11 +107,11 @@ What do you want?
 
 ### 范围
 
-在上面的示例中，一次又一次地定义数字列表似乎很麻烦。 这是 Python，因此必须有一些可利用开发人员的构造方法。 这是范围功能。
+在上面的示例中，一次又一次地定义数字列表似乎很麻烦。 这是 Python，因此必须有一些可利用开发人员的构造方法。 这是`range`函数。
 
 该函数需要一个参数：停止值； 和两个可选参数：`start`和`step`。
 
-如果提供了唯一停靠点，则范围功能会生成一个从数字 0 到停靠点数字（不包括停靠点数字）的范围，步长为 1。
+如果提供了唯一停靠点，则`range`函数会生成一个从数字 0 到停靠点数字（不包括停靠点数字）的范围，步长为 1。
 
 ```py
 >>> for i in range(10):
@@ -131,7 +131,7 @@ What do you want?
 
 如您在上面的示例中看到的那样，数字以 0 到 9 的步长打印从 0 到 9。
 
-如果提供了起始参数，则范围功能会在起始编号和终止编号之间创建一个范围（同样，终止编号是唯一的）。
+如果提供了起始参数，则`range`函数会在起始编号和终止编号之间创建一个范围（同样，终止编号是唯一的）。
 
 如果起始编号大于或等于终止编号，则不执行循环。
 

docs/173.md

@@ -10,7 +10,7 @@
 
 面向对象技术大约在 60 年代后期，但直到 90 年代初才在开发人员中获得了发展空间。 我们将学习以下四个主要原则：
 
-*   封装形式
+*   封装
 *   数据抽象
 *   继承
 *   多态
@@ -23,15 +23,15 @@
 
 如果我们回头看面向对象，那么我们可以说一类是一个对象的定义，一个对象是指定类的实例。
 
-一个类定义了未来对象具有的属性和功能，以及该语言是否使用访问限制，您可以在类定义中告诉公众可以访问哪些部分，该类的扩展还是仅内部使用。
+一个类定义了未来对象具有的属性和函数，以及该语言是否使用访问限制，您可以在类定义中告诉公众可以访问哪些部分，该类的扩展还是仅内部使用。
 
 现在是时候深入研究 OOP 的四大原则了。
 
-### 封装形式
+### 封装
 
-封装是指将数据和功能打包到单个组件中。 但是，在我们的情况下，进入一类，其他编程语言支持其他替代方法。 该类的功能将根据存储在该类的字段中的数据进行操作。
+封装是指将数据和函数打包到单个组件中。 但是，在我们的情况下，进入一类，其他编程语言支持其他替代方法。 该类的函数将根据存储在该类的字段中的数据进行操作。
 
-在某些编程语言中，封装用于隐藏信息，或更准确地说：限制对数据和功能的访问。 这些语言包括 C++ 和 Java，例如，您可以在其中使用`private`，`protected`和`public`来限制对字段和方法的访问。 但是在 Python 中没有这样的限制级别。 您可以访问类的每个字段和功能。
+在某些编程语言中，封装用于隐藏信息，或更准确地说：限制对数据和函数的访问。 这些语言包括 C++ 和 Java，例如，您可以在其中使用`private`，`protected`和`public`来限制对字段和方法的访问。 但是在 Python 中没有这样的限制级别。 您可以访问类的每个字段和函数。
 
 但是，有一个约定没有写下来，但是每个 Python 开发人员都知道并且应该知道：名称以双下划线（`__`）开头的类（字段和函数）的成员应视为私有的，不应调用或访问。
 
@@ -47,7 +47,7 @@
 
 ### 继承
 
-继承是 OOP 的一项关键功能，其中一个类基于另一类的模板/实现（从该类继承）。 这是一种代码重用的基本方法，您可以将子类之间的通用功能和信息封装到一个基类中。
+继承是 OOP 的一项关键功能，其中一个类基于另一类的模板/实现（从该类继承）。 这是一种代码重用的基本方法，您可以将子类之间的通用函数和信息封装到一个基类中。
 
 继承模型有不同类型，但是最常见的两种是*单继承*和*多继承*。 Python 使用**多重继承**，这意味着一个类可以根据需要扩展任意多个类。
 

docs/174.md

@@ -164,7 +164,7 @@ Calling vehicle1 method
 
 **多态**
 
-多态是一个过程，其中函数以不同的方式用于不同的输入。 基本上，多态是如果类 B 从类 A 继承而来，则它不能继承类 A 的所有内容，因此可以继承类 A 的某些功能。
+多态是一个过程，其中函数以不同的方式用于不同的输入。 基本上，多态是如果类 B 从类 A 继承而来，则它不能继承类 A 的所有内容，因此可以继承类 A 的某些函数。
 
 **示例：**
 

docs/177.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://javabeginnerstutorial.com/python-tutorial/python-3-guess-the-number-the-return/](https://javabeginnerstutorial.com/python-tutorial/python-3-guess-the-number-the-return/)
 
-我们之前已经看过这个示例。 在那里，我包括了很多处理用户输入和主要逻辑的循环……现在该重构应用以使用功能了。 这应该使代码易于阅读，以后我们可以重用部分代码。
+我们之前已经看过这个示例。 在那里，我包括了很多处理用户输入和主要逻辑的循环……现在该重构应用以使用函数了。 这应该使代码易于阅读，以后我们可以重用部分代码。
 
-这些可重复使用的部分之一是数字读数。 我们有两个要点，我们希望用户输入数字并编写了略微相同的代码。 这是开始重构并将其提取为一个功能的好地方。
+这些可重复使用的部分之一是数字读数。 我们有两个要点，我们希望用户输入数字并编写了略微相同的代码。 这是开始重构并将其提取为一个函数的好地方。
 
 因此，让我们将其提取为一个函数。 唯一的区别是我们打印出的询问用户输入数字的消息。 可以将其作为函数的参数来处理，因为这是唯一的可变部分。 因此，让我们看一下函数的定义：
 
@@ -80,7 +80,7 @@ while True:
 
 看起来很不错，没有重复的代码，而且非常精简。 但是，如果您对测试有所了解，您可能会说这段代码有一个很大的“主”块，很难测试。
 
-我必须同意。 单元测试（尽管我将在下一章中进行介绍）在这里会很麻烦。 解决方案是将这个较大的主循环拆分为较小的功能，这些功能可以单独进行测试。
+我必须同意。 单元测试（尽管我将在下一章中进行介绍）在这里会很麻烦。 解决方案是将这个较大的主循环拆分为较小的函数，这些函数可以单独进行测试。
 
 例如，求值用户是赢还是输。 为此，我们可以编写一个函数，该函数将秘密数字，猜测，猜测计数和猜测数字作为输入，并对消息进行求值以告知用户。 但是一个函数的四个参数很多，因此现在让我们对其进行划分。 基于这些输入，我将创建一个函数来告诉用户秘密数字是猜中的数字是更高还是更低。
 

docs/178.md

@@ -117,7 +117,7 @@ TypeError: 'float' object is not iterable
 生成器可以看作是迭代器的经过改进的版本，旨在由程序员以更直观的方式编写，并使用更少的代码。 生成器和迭代器之间存在细微的差异：
 
 *   生成器是一种特殊的迭代器
-*   他们定义了类似行为的功能
+*   他们定义了类似行为的函数
 *   他们跟踪自己的内部状态（例如局部变量），这与迭代器不同
 
 > 为了扩展最后一点，迭代器在每次循环时都以新状态开始-对`__next__()`的每次调用都是一个新的函数调用，需要自己设置并创建自己的状态。
@@ -142,7 +142,7 @@ TypeError: 'float' object is not iterable
 
 简而言之，生成器函数是一种特殊的函数，可以在运行时逐个产生其结果，而不必等待完成并立即返回所有结果。
 
-它们很容易发现，因为您会注意到，使用关键字“`yield`”返回值。 此处可以使用通常的“返回”，但只能退出该功能。
+它们很容易发现，因为您会注意到，使用关键字“`yield`”返回值。 此处可以使用通常的“返回”，但只能退出该函数。
 
 > 如果生成器没有设法“*产生*”任何数据，但是击中了“返回”，则调用者将返回一个空列表（`[]`）
 
@@ -214,7 +214,7 @@ def generator_function(collection):
         return
 ```
 
-如评论中所述，第一种形式逐步遍历可迭代的项目集合，并对每个项目进行某种处理，然后再“屈服”。 虽然不是很令人兴奋，但对于简单的旧迭代当然可以实现，但是它的强大之处在于它可以成为其他生成器链的一部分。 由于每个项目需要更多的处理，生成器很快变得易于维护代码。
+如注释中所述，第一种形式逐步遍历可迭代的项目集合，并对每个项目进行某种处理，然后再“屈服”。 虽然不是很令人兴奋，但对于简单的旧迭代当然可以实现，但是它的强大之处在于它可以成为其他生成器链的一部分。 由于每个项目需要更多的处理，生成器很快变得易于维护代码。
 
 第二种形式是一个示例，可以适用于生成任意长度的值的序列，支持无限序列或无限循环序列等。 例如，该机制在处理数学或科学问题时非常有用。
 
@@ -240,7 +240,7 @@ for result in generator_function(arguments):
 
 在第二种形式中，不存储生成器，而是由“`for`”循环立即使用生成器。
 
-#### 实践中的生成器功能
+#### 实践中的生成器函数
 
 这是说明创建和使用简单生成器函数的示例。 它将文本文件过滤为仅包含特定字符串的行。 它还显示了三种稍微不同的调用生成器的方式，有关详细信息，请参见注释：
 
@@ -330,7 +330,7 @@ new_generator = (apply_processing to(item) for item in iterable if condition)
 
 它们看起来类似于列表推导，但实际上，列表推导会在返回之前将其整个输出构建到内存中的列表中，而生成器表达式一次只会返回其输出一项。
 
-创建生成器后，即可使用与使用生成器功能几乎相同的方式来使用（或使用）生成器。 这里有一些示例：
+创建生成器后，即可使用与使用生成器函数几乎相同的方式来使用（或使用）生成器。 这里有一些示例：
 
 ```py
 #Form 1 - more readable
@@ -362,7 +362,7 @@ with open("Programming_Books_List.txt",'r') as file_obj:
         print(match)
 ```
 
-注意，**仅需要这三行**。 使用生成器功能执行此操作所需的最少行数为 7。 这要简洁得多，并能生成精美的代码，但不能在所有情况下都使用。
+注意，**仅需要这三行**。 使用生成器函数执行此操作所需的最少行数为 7。 这要简洁得多，并能生成精美的代码，但不能在所有情况下都使用。
 
 ## 为什么要使用生成器？
 

docs/183.md

@@ -122,7 +122,7 @@
 
 ### 一对一关系
 
-对于一个实体，此关系类型仅包含一种引用类型，而对于另一实体也是如此。 在这种情况下，您可以选择用于存储参考的实体。例如，如果我将 ISBN 提取为具有其他一些属性的单独实体，则可能是书籍与 ISBN 号之间的关系：一本书具有一本 ISBN 和一本 ISBN 准确地指一本书。
+对于一个实体，此关系类型仅包含一种引用类型，而对于另一实体也是如此。 在这种情况下，您可以选择用于存储引用的实体。例如，如果我将 ISBN 提取为具有其他一些属性的单独实体，则可能是书籍与 ISBN 号之间的关系：一本书具有一本 ISBN 和一本 ISBN 准确地指一本书。
 
 ### 一对多和多对一关系
 
@@ -148,7 +148,7 @@ final Book book = new Book("9781617291999", "Java 8 in Action", new Date());
  session.getTransaction().commit();
 ```
 
-如您所见，我使用一些 lambda 来动态创建作者。 有趣的部分是最后一个语句，`forEach`块：我将这本书添加到当前作者的图书列表中，然后将当前作者添加到这本书的作者列表中。 以后需要在数据库中一起查找书籍和作者时，需要使用此参考（如果您手动查询或使用 Hibernate 加载数据集）。
+如您所见，我使用一些 lambda 来动态创建作者。 有趣的部分是最后一个语句，`forEach`块：我将这本书添加到当前作者的图书列表中，然后将当前作者添加到这本书的作者列表中。 以后需要在数据库中一起查找书籍和作者时，需要使用此引用（如果您手动查询或使用 Hibernate 加载数据集）。
 
 现在的结果与上次有所不同：
 

docs/184.md

@@ -4,7 +4,7 @@
 
 上一次我们研究了将实体关系映射到数据库。 现在该关注主要的对象关系：继承。
 
-如您所知，对象可以彼此继承，以将通用功能移到超类中，并且子代中只有不同部分。 使用 Hibernate 也可以实现相同的目的：您可以将通用功能分组到父类中，并且仅将差异添加到子类中，还可以将此关系映射到数据库。
+如您所知，对象可以彼此继承，以将通用函数移到超类中，并且子代中只有不同部分。 使用 Hibernate 也可以实现相同的目的：您可以将通用函数分组到父类中，并且仅将差异添加到子类中，还可以将此关系映射到数据库。
 
 ## 这个示例
 

docs/21.md

@@ -57,11 +57,11 @@ String jbt = "JBT";
 String str=new String("javabeginnerstutorial");
 ```
 
-当我们使用`new`运算符创建`String`时，实际上是像第一个选项那样在堆中创建`String`对象。 在这里，我们在堆内存中创建一个字符串对象，其值为`"abc"`。 和一个名为“`str`”的参考。
+当我们使用`new`运算符创建`String`时，实际上是像第一个选项那样在堆中创建`String`对象。 在这里，我们在堆内存中创建一个字符串对象，其值为`"abc"`。 和一个名为“`str`”的引用。
 
 还请注意，当我们使用`""`（字面值）创建此`String`对象时，还将创建字面值。 总共将有 1 个字符串对象 1 个字符串字面值并将创建引用。 但是引用将仅引用堆中的`String`对象，而不引用字符串池中的字面值。
 
-当我们使用`""`时，我们正在创建字面值（`""`中的所有内容均视为字面值）。 在这种情况下（第二种情况），JVM 将在字符串池中查找所有引用，并检查其中是否有指向值`"abc"`的堆中的字符串对象，如果找到，则将返回该对象的引用。 否则，JVM 将在堆中创建一个新的字符串对象，并在字符串池中对其进行内化（使用`inter()`方法）（此对象的引用将添加到字符串池中），以供以后参考。 并且将返回新创建对象的引用。 现在，如果我们再次编写相同的代码来创建`String`字面值。
+当我们使用`""`时，我们正在创建字面值（`""`中的所有内容均视为字面值）。 在这种情况下（第二种情况），JVM 将在字符串池中查找所有引用，并检查其中是否有指向值`"abc"`的堆中的字符串对象，如果找到，则将返回该对象的引用。 否则，JVM 将在堆中创建一个新的字符串对象，并在字符串池中对其进行内化（使用`inter()`方法）（此对象的引用将添加到字符串池中），以供以后引用。 并且将返回新创建对象的引用。 现在，如果我们再次编写相同的代码来创建`String`字面值。
 
 #### 字符串字面值
 

docs/31.md

@@ -46,7 +46,7 @@ Java 中的每个异常都是`Exception`类的子类型，而`Exception`类又
 
 **`catch`**：`catch`用于匹配特定类型的异常。 一个`try`块可能有多个`catch`子句。
 
-**`finally`**：`finally`确定将在`try`块之后始终执行的代码块。 即使在例外的情况下。
+**`finally`**：`finally`确定将在`try`块之后始终执行的代码块。 即使在异常的情况下。
 
 ```java
  try {

docs/32.md

@@ -58,7 +58,7 @@ public class ResourceMgt {
 
 **值得注意的要点**：
 
-*   `try-with-resources`语句就像普通的`try`语句一样。 它可以照常捕获并最终阻止。
+*   `try-with-resources`语句就像普通的`try`语句一样。 它可以拥有常规`catch`和`finally`块。
 *   重要的是要记住，在`catch`和`finally`块运行之前，已声明的资源已关闭。
 *   要在同一`try`语句中声明多个资源，必须使用
 

docs/33.md

@@ -26,13 +26,13 @@ try{
 ### 注意
 
 1.  在`try`块和`catch`块之间不能编写任何代码。
-2.  尝试块必须紧随其后的是`catch`或`finally`块，或二者兼而有之。 如果没有`catch`块，则尽管`finally`方法具有`try/finally`，但`final`方法应**声明异常**。
-3.  您将无法获得成功或最终没有尝试块。
+2.  `try`块必须紧随其后的是`catch`或`finally`块，或二者兼而有之。 如果没有`catch`块，则尽管`finally`方法具有`try/finally`，但`final`方法应**声明异常**。
+3.  您不能拥有不带`catch`或`finally`的`try`块。
 4.  如果您不想在代码中处理异常，请使用**引发并声明**子句。 谁调用您的代码都必须使用`try/catch`块来处理它。
 
 ## 控制流
 
-1.  如果`try`块成功，即未引发异常，则控制将移至`finally`块（如果存在）。 跳过捕获块。 在没有`finally`块的情况下，将执行`catch`块下面的任何代码。
+1.  如果`try`块成功，即未引发异常，则控制将移至`finally`块（如果存在）。 跳过`catch`块。 在没有`finally`块的情况下，将执行`catch`块下面的任何代码。
 2.  如果`try`块失败（发生异常），则控制权转移到处理异常的`catch`块。 `try`块中的其余代码永远不会执行。 如果存在`finally`块，则在`catch`块执行完成后运行。
 3.  如果`try/catch`块**具有**返回语句，那么即使执行`finally`块！ 流控制首先跳转到`finally`块，然后返回`return`语句。
 
@@ -70,7 +70,7 @@ returning from try block
 
 1.  `try`块运行并打印“开始执行`try`块”。
 2.  一旦遇到`return`语句，流程将立即转移到`finally`块并打印“`finally`的`print`语句”。
-3.  最终块执行完成后，控制权返回`try`块中的`return`语句，并返回“从`try`块返回”。
+3.  `finally`块执行完成后，控制权返回`try`块中的`return`语句，并返回“从`try`块返回”。
 4.  如果`finally`块具有**返回语句**，则来自`try/catch`块的`return`语句将被覆盖。
 
 ### 示例
@@ -124,7 +124,7 @@ returning from finally block
 
 在 Java 7 之前，为了处理多个异常，使用了多个`catch`块（从最特定到最普通）。 编写代码是为了打印栈跟踪，执行错误恢复，链接异常，允许用户做出决定等。但是编写多个`catch`块包含许多**重复代码**。 另外，程序员倾向于捕获更广泛或更普遍的异常，而不是特定的异常。 例如，捕获`IOException`而不是`FileNotFoundException`。
 
-从 **Java SE 7 和更高版本**起，这些缺陷已通过**单捕获块**解决，该块可以**处理多种类型的异常**。 在这里，要处理的异常类型在以竖线（`|`）分隔的`catch`子句的主题中指定。
+从 **Java SE 7 和更高版本**起，这些缺陷已通过**单`catch`块**解决，该块可以**处理多种类型的异常**。 在这里，要处理的异常类型在以竖线（`|`）分隔的`catch`子句的主题中指定。
 
 #### 示例
 
@@ -146,11 +146,11 @@ catch(ArrayIndexOutOfBoundsException | SQLException ex){
 ## 仔细查看`Finally`块
 
 1.  一旦`try`块中的控件退出，无论是否引发异常，都将始终执行`finally`块。
-2.  最终块未执行，
+2.  `finally`块未执行，
     1.  如果在执行`try/catch`块代码时 JVM 退出
     2.  如果在控制权到达`finally`块之前执行了`System.exit()`
     3.  如果执行`try/catch`代码的线程被中断或杀死
-3.  最终块通过关闭可能已打开的资源来防止任何资源泄漏。
+3.  `finally`块通过关闭可能已打开的资源来防止任何资源泄漏。
 4.  如果要恢复任何资源，则必须将代码放在`finally`块中。
 5.  仅带有`finally`块的`try`块（即没有`catch`块）仍应声明该异常以进行处理。
 

docs/41.md

@@ -96,7 +96,7 @@ Inside Static method
 
 ## 类方法 – 静态方法
 
-可以在没有类实例的情况下调用类似于类变量的类方法。 类方法通常用于为 Java 程序提供全局功能。 例如，`java.lang.Math`包中的方法是类方法。 您不能从静态方法内部调用非静态方法。
+可以在没有类实例的情况下调用类似于类变量的类方法。 类方法通常用于为 Java 程序提供全局函数。 例如，`java.lang.Math`包中的方法是类方法。 您不能从静态方法内部调用非静态方法。
 
 ## `static`关键字规则
 

docs/43.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-array-tutorial/](https://javabeginnerstutorial.com/core-java-tutorial/java-array-tutorial/)
 
-Java 数组是一种数据结构类型，用于存储相同类型的多个变量。 数组可以包含基元和对象。 数组中的变量是有序的，但未排序。 数组中的每个元素都有一个索引，数组中元素的起始索引为 0。
+Java 数组是一种数据结构类型，用于存储相同类型的多个变量。 数组可以包含原始类型和对象。 数组中的变量是有序的，但未排序。 数组中的每个元素都有一个索引，数组中元素的起始索引为 0。
 
-> 数组将始终是堆中的对象。 不管它存储什么，基元还是对象。
+> 数组将始终是堆中的对象。 不管它存储什么，原始类型还是对象。
 
 ## 数组声明（语法）
 

docs/46.md

@@ -31,7 +31,7 @@ Java `HashMap`是基于哈希表的`Map`实现。 这就是为什么面试官总
 
 **值**：与指定键关联的值。
 
-首先，`HashMap`将为给定密钥生成一个哈希码，然后检查是否已经有与给定密钥相关联的值。 如果是，则它将返回已经关联的值。 否则，它将通过提供的键在`HashMap`中增加价值。
+首先，`HashMap`将为给定密钥生成一个哈希码，然后检查是否已经有与给定密钥相关联的值。 如果是，则它将返回已经关联的值。 否则，它将通过提供的键在`HashMap`中增加值。
 
 ## 重点
 

docs/54.md

@@ -23,7 +23,7 @@ Java 序列化是一个过程，其中对象的当前状态将保存在字节流
 
 Java 已经提供了开箱即用的方式（`java.io.Serializable`接口）来序列化对象。 如果要序列化任何类，则该类需要实现给定的接口。
 
-**注**：可序列化接口是标记接口。 因此，`Serializable`接口中没有任何方法。
+**注**：`Serializable`接口是标记接口。 因此，`Serializable`接口中没有任何方法。
 
 ## Java 类序列化代码
 

docs/55.md

@@ -56,7 +56,7 @@ Last Name of Employee: null
 
 ## 类层次结构和可序列化
 
-在这里，我将讨论`Serializable`接口对类层次结构的影响。 如果一个类实现了`Serializable`接口，则可以保存该类的状态。 但是，如果同一类扩展了另一个未实现可序列化接口的类，则不会保存超类的状态。
+在这里，我将讨论`Serializable`接口对类层次结构的影响。 如果一个类实现了`Serializable`接口，则可以保存该类的状态。 但是，如果同一类扩展了另一个未实现`Serializable`接口的类，则不会保存超类的状态。
 
 为了了解区别，我们将更新原始的`Employee`类。 现在，该类将扩展另一个类`superEmployee`。 该超类将不会实现`Serializable`接口。
 

docs/56.md

@@ -304,7 +304,7 @@ Company Address: DEL
 Education: MCA 
 ```
 
-在这里，您可以看到教育的价值得以保存。 此值是接口的一部分。 但是由于这是恒定的，因此在序列化时将其保存。
+在这里，您可以看到教育的值得以保存。 此值是接口的一部分。 但是由于这是恒定的，因此在序列化时将其保存。
 
 I think I have covered all possible scenarios. Do let me know in case any particular scenario is not covered in this article. Feel free to say me hi,  if you like this article. And yes I didn’t qualify for the interview. 😛
 

docs/59.md

@@ -18,7 +18,7 @@
    }
 ```
 
-要存储工作日，我们创建一个实用程序类来存储工作日的常量：
+要存储工作日，我们创建一个工具类来存储工作日的常量：
 
 ```java
 public class Workdays {
@@ -41,7 +41,7 @@ private String workday;
 }
 ```
 
-我想您已经看到了这种方法的缺点：即使`Workdays`类中未定义工作日，也可以轻松地将工作日设置为“星期六”或“星期日”。 此解决方案不是价值安全的。 这不是我们想要实现的。
+我想您已经看到了这种方法的缺点：即使`Workdays`类中未定义工作日，也可以轻松地将工作日设置为“星期六”或“星期日”。 此解决方案不是值安全的。 这不是我们想要实现的。
 
 为了解决这个问题，我们将`Workdays`类转换为一个枚举：
 
@@ -51,7 +51,7 @@ MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY
 }
 ```
 
-所需的打字次数更少，现在该解决方案是价值安全的。 我们只需要调整`Schredule`类：
+所需的打字次数更少，现在该解决方案是值安全的。 我们只需要调整`Schredule`类：
 
 ```java
 public class Schedule {
@@ -69,7 +69,7 @@ public void setWorkday(Workday workday) {
 
 ## 条件和枚举
 
-枚举非常适合条件表达式（如果是语句或切换块）。 关于枚举的好处是它们是常量值，因此您可以将它们与`==`运算符进行比较，该运算符比使用`equals()`更优雅-并且避免了可能的`NullPointerExceptions`。 顺便说一句：如果您查看`Enum`类`equals()`的实现，您将看到以下内容：
+枚举非常适合条件表达式（`if`语句或`switch`块）。 关于枚举的好处是它们是常量值，因此您可以将它们与`==`运算符进行比较，该运算符比使用`equals()`更优雅-并且避免了可能的`NullPointerExceptions`。 顺便说一句：如果您查看`Enum`类`equals()`的实现，您将看到以下内容：
 
 ```java
 public final boolean equals(Object other) {
@@ -87,7 +87,7 @@ System.out.println("Hurray! Tomorrow is weekend!");
 }
 ```
 
-或在开关块中：
+或在`switch`块中：
 
 ```java
 switch(currentSchedule.getWorkday()) {

docs/62.md

@@ -25,7 +25,7 @@
 可以通过两种方式定义线程
 
 *   扩展`java.lang.Thread`类。
-*   实现可运行接口。
+*   实现`Runnable`接口。
 
 ### 扩展 Java 线程类：
 
@@ -80,7 +80,7 @@ MyRunnable r = new MyRunnable();
 Thread t = new Thread(r);
 ```
 
-如果使用无参构造器创建线程，则该线程将调用其自己的`run()`。 这是在第一种情况下发生的（扩展`Thread`类），但是在`Runnable`的情况下，需要知道实现了可运行接口的类的`run`方法需要被调用，而不是`Thread`类的`run()`。 因此，我们需要将该类作为参数传递给`Thread`。 单个可运行实例可以传递给多个`Thread`对象。
+如果使用无参构造器创建线程，则该线程将调用其自己的`run()`。 这是在第一种情况下发生的（扩展`Thread`类），但是在`Runnable`的情况下，需要知道实现了`Runnable`接口的类的`run`方法需要被调用，而不是`Thread`类的`run()`。 因此，我们需要将该类作为参数传递给`Thread`。 单个可运行实例可以传递给多个`Thread`对象。
 
 ```java
 public class TestThreads {
@@ -216,7 +216,7 @@ return count;
 }
 ```
 
-`MyClass.class`事物称为类文字。 它告诉编译器（谁告诉 JVM）：去找我代表代表`MyClass`类的类实例。
+`MyClass.class`事物称为类字面值。 它告诉编译器（谁告诉 JVM）：去找我代表代表`MyClass`类的类实例。
 
 > 在同一类中调用非静态同步方法的线程只有在使用同一实例调用它们时才会彼此阻塞。 由于每个实例只有一个锁。 在同一类中调用静态同步方法的线程将始终相互阻塞，因为每个类只有一个锁。
 

docs/64.md

@@ -6,7 +6,7 @@
 
 ## Java Lambda 表达式
 
-Java Lambda 表达式是 Java 的一个重要的新功能，已在 Java 8 中引入。Lambda 表达式是不属于任何类的匿名函数（无名称的函数），表示该函数没有名称，并且没有类。 Lambda 表达式通过促进 Java 中的函数式编程大大简化了开发。 它用于提供函数式接口的实现（函数式接口是仅包含一种方法的接口。例如，Java 标准的`Runnable`接口是函数式接口）。 它还有助于迭代，过滤和从集合库中提取数据。 Lambda 表达式使您可以将代码视为数据，将功能视为方法参数。
+Java Lambda 表达式是 Java 的一个重要的新功能，已在 Java 8 中引入。Lambda 表达式是不属于任何类的匿名函数（无名称的函数），表示该函数没有名称，并且没有类。 Lambda 表达式通过促进 Java 中的函数式编程大大简化了开发。 它用于提供函数式接口的实现（函数式接口是仅包含一种方法的接口。例如，Java 标准的`Runnable`接口是函数式接口）。 它还有助于迭代，过滤和从集合库中提取数据。 Lambda 表达式使您可以将代码视为数据，将函数视为方法参数。
 
 ### Lambda 表达式的语法
 

docs/65.md

@@ -173,7 +173,7 @@ IntStream.rangeClosed(1, 10).map(square).forEach(System.out::println);
 
 ## 柯里化
 
-固化是部分功能应用的名称。 这就是说，您有一个函数，该函数需要多个参数，但是大多数参数已经为人所知，并且将保持不变-只有一个会发生变化。 而且，除了在调用函数时提供每个参数之外，还可以部分咖喱函数并设置一些默认参数。
+柯里化是函数部分应用的名称。 这就是说，您有一个函数，该函数需要多个参数，但是大多数参数已经为人所知，并且将保持不变-只有一个会发生变化。 而且，除了在调用函数时提供每个参数之外，还可以部分咖喱函数并设置一些默认参数。
 
 让我们看一下以下示例：
 

docs/86.md

@@ -30,7 +30,7 @@
 *   编辑菜单使我们可以撤消，重做，剪切，复制，粘贴，删除和全选命令。
 *   此菜单中值得记住的选项是“**插入新命令**”和“**插入新注释**”。
 *   “插入新命令”将允许用户在当前所选命令的顶部顶部插入新命令。
-*   “插入新评论”将允许用户在当前所选行的顶部上添加新评论。 这对于文档目的非常有用。
+*   “插入新注释”将允许用户在当前所选行的顶部上添加新注释。 这对于文档目的非常有用。
 
 这是为您提供的“编辑”菜单，
 

docs/90.md

@@ -14,7 +14,7 @@
 
 *值* – 必须将哪些数据传递给目标
 
-一些命令并不总是需要目标和值。 例如，“关闭”命令用于关闭窗口。 而“点击”命令需要一个目标，而“类型”命令则需要目标和价值。
+一些命令并不总是需要目标和值。 例如，“关闭”命令用于关闭窗口。 而“点击”命令需要一个目标，而“类型”命令则需要目标和值。
 
 Selenium 命令具有三种不同的样式：*操作，访问器和断言*。
 

docs/93.md

@@ -16,8 +16,8 @@
 
 *   ID
 *   Name
-*   连结文字
-*   的 CSS
+*   链接文本
+*   CSS
 *   判断
 *   XPath