2020-06-23 12:46:32

docs/10.md

@@ -20,7 +20,7 @@
 
 ## 创建一个包
 
-现在，我们将为我们的 Java 项目创建一个程序包。 **包**用于避免*命名冲突*，以便*控制访问*（访问修饰符）和*来捆绑相关类型*的组。
+现在，我们将为我们的 Java 项目创建一个程序包。 **包**用于避免*命名冲突*，以便*控制访问*（访问修饰符）和*捆绑相关类型*的组。
 
 要创建包，请在 Java 项目（`JBTProject`）中选择`src`文件夹，右键单击该文件夹并选择“**新建 -> 包**”。
 

docs/108.md

@@ -98,7 +98,7 @@ public class FirstJunitTest {
 
 ![JUnit import packages](img/ce8da4202841e9f631539ef66816bcfb.png)
 
-在这三个注释下的**方法**是*公开的*，返回类型为 *void* 。 在 *junit.framework.TestCase* 类下，我们有 **setUp（）**和 **tearDown（）**方法。 最佳实践是重写这些方法，以分别编写初始化代码和清除代码。 这不仅可以防止内存泄漏，还可以使代码更易于阅读。 JUnit 首先调用 setUp（）方法，然后调用 test 方法，最后调用 tearDown（）方法。 对于附加到@Test 的每个测试方法，都会发生这种情况。
+在这三个注释下的**方法**是*公开的*，返回类型为 *void* 。 在 *junit.framework.TestCase* 类下，我们有 **setUp（）**和 **tearDown（）**方法。 最佳实践是覆盖这些方法，以分别编写初始化代码和清除代码。 这不仅可以防止内存泄漏，还可以使代码更易于阅读。 JUnit 首先调用 setUp（）方法，然后调用 test 方法，最后调用 tearDown（）方法。 对于附加到@Test 的每个测试方法，都会发生这种情况。
 
 #### 要运行测试，
 

docs/13.md

@@ -34,7 +34,7 @@
 
 #### 最终变量：
 
-当变量设置为 final 时，其值*不能*更改为。 最终变量就像常量。
+当变量设置为 final 时，其值*不能*更改。 最终变量就像常量。
 
 **示例**：`public static final int i = 10;`
 
@@ -92,7 +92,7 @@
 
 `Strictfp`非访问修饰符强制浮点或浮点操作遵守 IEEE 754 标准。
 
-**注意**：`Strictfp`非访问修饰符*无法将*应用于变量。
+**注意**：`Strictfp`非访问修饰符*无法*应用于变量。
 
 ## 备忘单
 
@@ -100,7 +100,7 @@
 *   静态关键字可以应用于**变量**和**方法**。
 *   静态变量是那些不与任何实例关联但与类关联的变量，这意味着所有实例都将访问该变量的同一单个副本。
 *   局部变量*不能*声明为`static`。
-*   *静态关键字也可以应用于*方法*。 它们将适用于所有实例，并且它们将不依赖于实例创建。
+*   静态关键字也可以应用于*方法*。 它们将适用于所有实例，并且它们将不依赖于实例创建。
 *   最终修饰符可以应用于*方法*和*变量*。
 *   `Final`是唯一可用于局部变量的修饰符。
 *   一旦声明为`final`，则变量的值无法更改。

docs/131.md

@@ -55,4 +55,4 @@ Apache ANT 具有强大的功能，足以超越“谢谢”的门槛！ 我们
 
 ![sample build.xml](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20839%20425'%3E%3C/svg%3E)
 
-<noscript><img alt="sample build.xml" class="alignnone size-full wp-image-12640" height="425" src="img/28116bee6867f10c68cb8a7b00821a1e.png" width="839"/><p>让我们一次将构建文件提取一个标签。</p><p><strong>项目</strong>：这具有三个属性。</p><ol><li>名称 – 项目名称</li><li>default – 如果未提供任何内容，则应执行的默认目标</li><li>baseDir – 从中计算文件中相对路径的基本目录。 “。” 指执行的当前目录</li></ol><p><strong>目标</strong>：如示例构建文件中所示，一个项目可以具有一个或多个目标。 目标是一组任务。 我们可以选择希望 ANT 执行的目标，并用逗号分隔它们的名称。 如果未指定目标，则将执行默认目标。</p><p>这里要注意的重要属性是“依赖”。 这指定了它所依赖的目标名称。 例如，编译目标将仅在其依赖的初始化目标执行后执行。 因此，depends 属性指定执行目标的顺序。</p><p><strong>任务</strong>：这是一段可以执行的代码。 每个任务可以具有一个或多个属性作为键值对。</p><p>句法：</p><p>&lt; <em>名称</em> <em> attribute1 </em> =” <em> value1 </em>” <em> attribute2 </em> =” <em> value2 </em>”…/ &gt;</p><p><em>名称</em>是任务的名称，<em>属性 N </em>和<em> valueN </em>分别是属性名称和值名称。</p><p>这是现成的<a href="https://ant.apache.org/manual/tasklist.html">内置任务</a>的长长列表。 我们也可以编写自己的任务。 （还记得吗？都是用 Java 编写的）。</p><p>您一定想知道，为什么要深入研究构建文件，而不是立即安装并开始执行操作！ 传递这么多 ANT 知识是有原因的。 随着我们在旅途中的进一步发展，您将对此表示赞赏。 请稍等...</p><p>现在开始营业！</p><p><strong>步骤 1 </strong>：转到“ https://ant.apache.org/bindownload.cgi”，然后单击“ apache-ant-1.10.2-bin.zip”以在下面下载.zip 文件 “蚂蚁的当前版本”。</p><p><img alt="Download link" class="alignnone size-full wp-image-12641" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/1_downloadLink.jpg" height="98" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20572%2098'%3E%3C/svg%3E" width="572"/></p><noscript><img alt="Download link" class="alignnone size-full wp-image-12641" height="98" src="img/14970a7f07b1ccaa7596be317ad9fa33.png" width="572"/><p><strong>步骤 2：</strong>下载.zip 存档后，将所有文件提取到本地计算机上的目录中。</p><p><strong>步骤 3 </strong>：如下设置环境变量 ANT_HOME 和 Path，</p><p>右键点击“计算机”-&gt;属性-&gt;高级系统设置-&gt;“高级”标签-&gt;环境变量-&gt;在系统变量下单击“新建”。</p><p>ANT_HOME 设置为提取 Apache ANT 文件的文件夹的路径。</p><p><img alt="System variable settings" class="alignnone size-full wp-image-12642" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/2_SystemVariable.jpg" height="162" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20376%20162'%3E%3C/svg%3E" width="376"/></p><noscript><img alt="System variable settings" class="alignnone size-full wp-image-12642" height="162" src="img/ba0bc910e93456af8ef5bbf18bafd97b.png" width="376"/><p>类似地，编辑 Path 变量以包含％ANT_HOME％\ bin。</p><p><strong>步骤 4 </strong>：通过在“命令提示符”中键入以下命令来验证是否已安装 Apache ANT</p><p><em>蚂蚁版本</em></p><p><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/3_CmdVersionCheck.jpg" height="86" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20354%2086'%3E%3C/svg%3E" width="354"/></p><noscript><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" height="86" src="img/418f05483293c425772a4636e1d0364c.png" width="354"/><p><strong>步骤 5：</strong>下一个任务是打开 Eclipse IDE，</p><li>右键单击 Java 项目-&gt;导出</li><li>在“常规”下，选择“蚂蚁构建文件”，然后点击“下一步”</li><li>确保已选择所需的项目</li><li>取消选中“创建目标以使用 Eclipse 编译器编译项目”，以删除对 Eclipse 的任何依赖</li><p><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/4_Buildfiles-1.jpg" height="407" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20509%20407'%3E%3C/svg%3E" width="509"/></p><noscript><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" height="407" src="img/f6b7286b63d7900c3782225e686a6833.png" width="509"/><p>单击“完成”以查看自动生成的 eclipse 文件。</p><p>就是这样！ 您已经准备好将所有项目作为 ANT 构建运行。 这很简单，不是吗？</p><p><strong> <em>即时贴：</em> </strong> <em> Eclipse 与 ANT 集成在一起。 为了确保 Eclipse 的“蚂蚁之家”指向最新版本的 ANT，请单击 Windows-&gt;首选项-&gt; Ant-&gt;运行时。 点击“类路径”标签。 展开“蚂蚁房屋入境”并验证路径。 如果指向的是其他版本，请单击“蚂蚁之家”并浏览用于提取 Apache ANT 文件的文件夹的位置。 </em></p><p>在我们的下一篇文章中，让我们做到这一点，并在 ANT 目标的帮助下生成 JUnit 报告。</p><p>安装愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/" title="10b. Advanced WebDriver – Generating JUnit Report"> 10b。 高级 WebDriver – 生成 JUnit 报告</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
+<noscript><img alt="sample build.xml" class="alignnone size-full wp-image-12640" height="425" src="img/28116bee6867f10c68cb8a7b00821a1e.png" width="839"/><p>让我们一次将构建文件提取一个标签。</p><p><strong>项目</strong>：这具有三个属性。</p><ol><li>名称 – 项目名称</li><li>default – 如果未提供任何内容，则应执行的默认目标</li><li>baseDir – 从中计算文件中相对路径的基本目录。 “。” 指执行的当前目录</li></ol><p><strong>目标</strong>：如示例构建文件中所示，一个项目可以具有一个或多个目标。 目标是一组任务。 我们可以选择希望 ANT 执行的目标，并用逗号分隔它们的名称。 如果未指定目标，则将执行默认目标。</p><p>这里要注意的重要属性是“依赖”。 这指定了它所依赖的目标名称。 例如，编译目标将仅在其依赖的初始化目标执行后执行。 因此，depends 属性指定执行目标的顺序。</p><p><strong>任务</strong>：这是一段可以执行的代码。 每个任务可以具有一个或多个属性作为键值对。</p><p>句法：</p><p>&lt; <em>名称</em> <em> attribute1 </em> =” <em> value1 </em>” <em> attribute2 </em> =” <em> value2 </em>”…/ &gt;</p><p><em>名称</em>是任务的名称，<em>属性 N </em>和<em> valueN </em>分别是属性名称和值名称。</p><p>这是现成的<a href="https://ant.apache.org/manual/tasklist.html">内置任务</a>的长长列表。 我们也可以编写自己的任务。 （还记得吗？都是用 Java 编写的）。</p><p>您一定想知道，为什么要深入研究构建文件，而不是立即安装并开始执行操作！ 传递这么多 ANT 知识是有原因的。 随着我们在旅途中的进一步发展，您将对此表示赞赏。 请稍等...</p><p>现在开始营业！</p><p><strong>步骤 1 </strong>：转到“ https://ant.apache.org/bindownload.cgi”，然后单击“ apache-ant-1.10.2-bin.zip”以在下面下载.zip 文件 “蚂蚁的当前版本”。</p><p><img alt="Download link" class="alignnone size-full wp-image-12641" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/1_downloadLink.jpg" height="98" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20572%2098'%3E%3C/svg%3E" width="572"/></p><noscript><img alt="Download link" class="alignnone size-full wp-image-12641" height="98" src="img/14970a7f07b1ccaa7596be317ad9fa33.png" width="572"/><p><strong>步骤 2：</strong>下载.zip 存档后，将所有文件提取到本地计算机上的目录中。</p><p><strong>步骤 3 </strong>：如下设置环境变量 ANT_HOME 和 Path，</p><p>右键点击“计算机”-&gt;属性-&gt;高级系统设置-&gt;“高级”标签-&gt;环境变量-&gt;在系统变量下单击“新建”。</p><p>ANT_HOME 设置为提取 Apache ANT 文件的文件夹的路径。</p><p><img alt="System variable settings" class="alignnone size-full wp-image-12642" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/2_SystemVariable.jpg" height="162" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20376%20162'%3E%3C/svg%3E" width="376"/></p><noscript><img alt="System variable settings" class="alignnone size-full wp-image-12642" height="162" src="img/ba0bc910e93456af8ef5bbf18bafd97b.png" width="376"/><p>类似地，编辑 Path 变量以包含% ANT_HOME% \ bin。</p><p><strong>步骤 4 </strong>：通过在“命令提示符”中键入以下命令来验证是否已安装 Apache ANT</p><p><em>蚂蚁版本</em></p><p><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/3_CmdVersionCheck.jpg" height="86" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20354%2086'%3E%3C/svg%3E" width="354"/></p><noscript><img alt="ANT version check in cmd" class="alignnone size-full wp-image-12643" height="86" src="img/418f05483293c425772a4636e1d0364c.png" width="354"/><p><strong>步骤 5：</strong>下一个任务是打开 Eclipse IDE，</p><li>右键单击 Java 项目-&gt;导出</li><li>在“常规”下，选择“蚂蚁构建文件”，然后点击“下一步”</li><li>确保已选择所需的项目</li><li>取消选中“创建目标以使用 Eclipse 编译器编译项目”，以删除对 Eclipse 的任何依赖</li><p><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/04/4_Buildfiles-1.jpg" height="407" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20509%20407'%3E%3C/svg%3E" width="509"/></p><noscript><img alt="Generating ANT buildfile" class="alignnone size-full wp-image-12638" height="407" src="img/f6b7286b63d7900c3782225e686a6833.png" width="509"/><p>单击“完成”以查看自动生成的 eclipse 文件。</p><p>就是这样！ 您已经准备好将所有项目作为 ANT 构建运行。 这很简单，不是吗？</p><p><strong> <em>即时贴：</em> </strong> <em> Eclipse 与 ANT 集成在一起。 为了确保 Eclipse 的“蚂蚁之家”指向最新版本的 ANT，请单击 Windows-&gt;首选项-&gt; Ant-&gt;运行时。 点击“类路径”标签。 展开“蚂蚁房屋入境”并验证路径。 如果指向的是其他版本，请单击“蚂蚁之家”并浏览用于提取 Apache ANT 文件的文件夹的位置。 </em></p><p>在我们的下一篇文章中，让我们做到这一点，并在 ANT 目标的帮助下生成 JUnit 报告。</p><p>安装愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/" title="10b. Advanced WebDriver – Generating JUnit Report"> 10b。 高级 WebDriver – 生成 JUnit 报告</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/156.md

@@ -125,4 +125,4 @@ new Vue({
 
 ![mouseover event](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20450%20255'%3E%3C/svg%3E)
 
-<noscript><img alt="mouseover event" class="alignnone size-full wp-image-14144" height="255" src="img/a1c490148c18e07a6f32b328ddfde462.png" width="450"/><p>我们还没有完成！</p><h2>使用事件对象</h2><p>还记得 JavaScript 世界中的<a href="https://www.w3schools.com/jsref/obj_event.asp">本机事件对象</a>吗？ 触发事件时，将创建 Event 对象，并将其自动传递给使用<code>v-on</code>指令调用的任何方法。 再次感谢 Vue！ 让我们看一些例子来了解这一点。</p><p>Event 对象具有“ <code>target</code>”方法，该方法返回触发事件的元素，并与<code>element.tagName</code>属性一起使用返回元素的 HTML 标记名称。</p><p><strong>Index.html (code snippet)</strong></p><pre><code class="language-html">&lt;div&gt; &lt;!-- Listening to mouse events --&gt; &lt;button v-on:mouseover="showRole"&gt;Hover over me!&lt;/button&gt; {{ role }} &lt;p&gt;{{ "Tag Name:" + tagName }}&lt;/p&gt; &lt;/div&gt;</code></pre><p><strong>Index.js</strong></p><pre><code class="language-javascript">new Vue({ el: "#app", data: { role: "", tagName: "" }, // define all custom methods within the 'methods' object methods: { showRole() { // 'this' keyword refers to the current Vue instance this.role = "developer"; this.tagName = event.target.tagName; } } });</code></pre><p>使用<code>event.target</code>将返回“ <code>[object HTMLButtonElement]</code>”，而<code>event.target.tagName</code>将返回“ <code>BUTTON</code>”。</p><p><img alt="Event object" class="alignnone size-full wp-image-14143" data-lazy-sizes="(max-width: 402px) 100vw, 402px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj.jpg 402w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj-300x190.jpg 300w" height="255" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20402%20255'%3E%3C/svg%3E" width="402"/></p><noscript><img alt="Event object" class="alignnone size-full wp-image-14143" height="255" sizes="(max-width: 402px) 100vw, 402px" src="img/f8145617a1b29741272a1a997f640584.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj.jpg 402w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj-300x190.jpg 300w" width="402"/><h2>与 Event 对象一起传递参数</h2><p>到目前为止，我们肯定知道两件事，</p><ol><li>将创建<code>Event</code>对象，并将其自动传递给触发事件时正在调用的方法。</li><li>只需在方法名称后面的括号内指定参数，即可将参数传递给这些方法非常容易。</li></ol><p>如果我们想使用此自动创建的<code>Event</code>对象将自己的参数<em> <strong>沿</strong> </em>传递，该怎么办？ 我们也可以这样做吗？</p><p>答案是肯定的！ 绝对没错！！</p><p>这里要记住的重点是<em> <strong>的命名</strong> </em>。 Vue 将原始 DOM 事件存储在名为“ <code>$event</code>”的变量中。 注意不要重写或拼写错误，因为它是 Vue.js 使用的受保护名称，以了解这不是自定义参数，而是<code>Event</code>对象本身。</p><p>让我们对代码进行这些更改。</p><p><strong>Index.html (code snippet)</strong></p><pre><code class="language-html">&lt;button v-on:mouseover="showRole('developer', $event)"&gt;Hover over me!&lt;/button&gt; {{ role }} &lt;p&gt;{{ "Tag Name:" + tagName }}&lt;/p&gt;</code></pre><p><strong> Index.js（代码段）</strong></p><pre><code class="language-javascript">showRole(customRole, event) { // 'this' keyword refers to the current Vue instance this.role = customRole; this.tagName = event.target.tagName; }</code></pre><p>在总结之前，这里是供您欣赏的完整代码！</p><p><strong>Index.html</strong></p><pre><code class="language-html">&lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;Hello Vue!&lt;/title&gt; &lt;!-- including Vue with development version CDN --&gt; &lt;script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"&gt;&lt;/script&gt; &lt;/head&gt; &lt;body&gt; &lt;div id="app"&gt; &lt;h2&gt;Welcome&lt;/h2&gt; &lt;!-- Using key modifiers with keyboard events --&gt; &lt;button v-on:keyup.enter="greet"&gt;greet&lt;/button&gt; &lt;hr/&gt; &lt;div&gt; &lt;!-- Passing arguments along with original DOM event --&gt; &lt;button v-on:mouseover="showRole('developer', $event)"&gt;Hover over me!&lt;/button&gt; {{ role }} &lt;p&gt;{{ "Tag Name:" + tagName }}&lt;/p&gt; &lt;/div&gt; &lt;/div&gt; &lt;!-- including index.js file --&gt; &lt;script src="index.js"&gt;&lt;/script&gt; &lt;/body&gt; &lt;/html&gt;</code></pre><p><strong>Index.js</strong></p><pre><code class="language-javascript">new Vue({ el: "#app", data: { role: "", tagName: "" }, // define all custom methods within the 'methods' object methods: { greet() { alert("Hi"); }, showRole(customRole, event) { // 'this' keyword refers to the current Vue instance this.role = customRole; this.tagName = event.target.tagName; } } });</code></pre><p>因此，我们现在可以将自定义参数与带有<code>$event</code>变量的自动创建的<code>Event</code>对象一起传递。 上面讨论的所有代码以及注释都可以在<a href="https://github.com/JBTAdmin/vuejs"> GitHub 存储库</a>中找到。</p><p>这使我们到了本主题的结尾。 祝您有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/13-shorthands-for-v-bind-and-v-on/" title="13\. Let’s use shorthands"> 13.让我们使用速记</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file
+<noscript><img alt="mouseover event" class="alignnone size-full wp-image-14144" height="255" src="img/a1c490148c18e07a6f32b328ddfde462.png" width="450"/><p>我们还没有完成！</p><h2>使用事件对象</h2><p>还记得 JavaScript 世界中的<a href="https://www.w3schools.com/jsref/obj_event.asp">本机事件对象</a>吗？ 触发事件时，将创建 Event 对象，并将其自动传递给使用<code>v-on</code>指令调用的任何方法。 再次感谢 Vue！ 让我们看一些例子来了解这一点。</p><p>Event 对象具有“ <code>target</code>”方法，该方法返回触发事件的元素，并与<code>element.tagName</code>属性一起使用返回元素的 HTML 标记名称。</p><p><strong>Index.html (code snippet)</strong></p><pre><code class="language-html">&lt;div&gt; &lt;!-- Listening to mouse events --&gt; &lt;button v-on:mouseover="showRole"&gt;Hover over me!&lt;/button&gt; {{ role }} &lt;p&gt;{{ "Tag Name:" + tagName }}&lt;/p&gt; &lt;/div&gt;</code></pre><p><strong>Index.js</strong></p><pre><code class="language-javascript">new Vue({ el: "#app", data: { role: "", tagName: "" }, // define all custom methods within the 'methods' object methods: { showRole() { // 'this' keyword refers to the current Vue instance this.role = "developer"; this.tagName = event.target.tagName; } } });</code></pre><p>使用<code>event.target</code>将返回“ <code>[object HTMLButtonElement]</code>”，而<code>event.target.tagName</code>将返回“ <code>BUTTON</code>”。</p><p><img alt="Event object" class="alignnone size-full wp-image-14143" data-lazy-sizes="(max-width: 402px) 100vw, 402px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj.jpg 402w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj-300x190.jpg 300w" height="255" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20402%20255'%3E%3C/svg%3E" width="402"/></p><noscript><img alt="Event object" class="alignnone size-full wp-image-14143" height="255" sizes="(max-width: 402px) 100vw, 402px" src="img/f8145617a1b29741272a1a997f640584.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj.jpg 402w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/5_p2-event-obj-300x190.jpg 300w" width="402"/><h2>与 Event 对象一起传递参数</h2><p>到目前为止，我们肯定知道两件事，</p><ol><li>将创建<code>Event</code>对象，并将其自动传递给触发事件时正在调用的方法。</li><li>只需在方法名称后面的括号内指定参数，即可将参数传递给这些方法非常容易。</li></ol><p>如果我们想使用此自动创建的<code>Event</code>对象将自己的参数<em> <strong>沿</strong> </em>传递，该怎么办？ 我们也可以这样做吗？</p><p>答案是肯定的！ 绝对没错！！</p><p>这里要记住的重点是<em> <strong>的命名</strong> </em>。 Vue 将原始 DOM 事件存储在名为“ <code>$event</code>”的变量中。 注意不要覆盖或拼写错误，因为它是 Vue.js 使用的受保护名称，以了解这不是自定义参数，而是<code>Event</code>对象本身。</p><p>让我们对代码进行这些更改。</p><p><strong>Index.html (code snippet)</strong></p><pre><code class="language-html">&lt;button v-on:mouseover="showRole('developer', $event)"&gt;Hover over me!&lt;/button&gt; {{ role }} &lt;p&gt;{{ "Tag Name:" + tagName }}&lt;/p&gt;</code></pre><p><strong> Index.js（代码段）</strong></p><pre><code class="language-javascript">showRole(customRole, event) { // 'this' keyword refers to the current Vue instance this.role = customRole; this.tagName = event.target.tagName; }</code></pre><p>在总结之前，这里是供您欣赏的完整代码！</p><p><strong>Index.html</strong></p><pre><code class="language-html">&lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;Hello Vue!&lt;/title&gt; &lt;!-- including Vue with development version CDN --&gt; &lt;script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"&gt;&lt;/script&gt; &lt;/head&gt; &lt;body&gt; &lt;div id="app"&gt; &lt;h2&gt;Welcome&lt;/h2&gt; &lt;!-- Using key modifiers with keyboard events --&gt; &lt;button v-on:keyup.enter="greet"&gt;greet&lt;/button&gt; &lt;hr/&gt; &lt;div&gt; &lt;!-- Passing arguments along with original DOM event --&gt; &lt;button v-on:mouseover="showRole('developer', $event)"&gt;Hover over me!&lt;/button&gt; {{ role }} &lt;p&gt;{{ "Tag Name:" + tagName }}&lt;/p&gt; &lt;/div&gt; &lt;/div&gt; &lt;!-- including index.js file --&gt; &lt;script src="index.js"&gt;&lt;/script&gt; &lt;/body&gt; &lt;/html&gt;</code></pre><p><strong>Index.js</strong></p><pre><code class="language-javascript">new Vue({ el: "#app", data: { role: "", tagName: "" }, // define all custom methods within the 'methods' object methods: { greet() { alert("Hi"); }, showRole(customRole, event) { // 'this' keyword refers to the current Vue instance this.role = customRole; this.tagName = event.target.tagName; } } });</code></pre><p>因此，我们现在可以将自定义参数与带有<code>$event</code>变量的自动创建的<code>Event</code>对象一起传递。 上面讨论的所有代码以及注释都可以在<a href="https://github.com/JBTAdmin/vuejs"> GitHub 存储库</a>中找到。</p><p>这使我们到了本主题的结尾。 祝您有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/vue-js/13-shorthands-for-v-bind-and-v-on/" title="13\. Let’s use shorthands"> 13.让我们使用速记</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/16.md

@@ -126,9 +126,9 @@ String is not Hi
 
 * * *
 
-### 如果其他 If 语句
+### `if-else if`语句
 
-`if-else if`语句由多个`if`条件和`else`语句组成。 如果*条件*为真，则将执行随附的代码。 如果*如果条件*为假，则它将检查下一个`if`条件。如果条件为下一个下一个*，则将执行附带的代码，否则将执行代码的`else`部分。 `If Else If `语句仅将***布尔表达式***视为有效条件。
+`if-else if`语句由多个`if`条件和`else`语句组成。 如果*条件*为真，则将执行随附的代码。 如果`if`条件为假，则它将检查下一个`if`条件。如果下一个条件为真，则将执行附带的代码，否则将执行代码的`else`部分。 `If Else If`语句仅将***布尔表达式***视为有效条件。
 
 > 与其他语言不同，Java 不接受数字作为条件运算符。 它仅将*布尔表达式*视为返回`TRUE`或`FALSE`的条件。
 > 

docs/163.md

@@ -48,7 +48,7 @@ else:
    a = 42
 ```
 
-如您所见，Python 代码更具可读性（尽管我也是一个有良好基础的 Java 开发人员，但我认为这是我的看法，因此我可以重写前面的示例以使其可读）。 如果您有 ***缩进行（请仔细查看 python 代码中的缩进）*** ，则表示它属于同一执行组。 例如，在 Java 中，它将不会：
+如您所见，Python 代码更具可读性（尽管我也是一个有良好基础的 Java 开发人员，但我认为这是我的看法，因此我可以覆盖前面的示例以使其可读）。 如果您有 ***缩进行（请仔细查看 python 代码中的缩进）*** ，则表示它属于同一执行组。 例如，在 Java 中，它将不会：
 
 ```java
 if(a == 42)
@@ -106,7 +106,7 @@ IndentationError：unindent 与任何外部缩进级别都不匹配
 
 标识符是用于标识变量，类，函数，模块或其他对象的名称。
 
-在 Python 中，您可以以字母（大写或小写无关紧要）或下划线（_）开头，并在其后跟随零个或多个字母，数字和下划线。 标识符名称中不允许使用标点符号（例如@，$和％）。
+在 Python 中，您可以以字母（大写或小写无关紧要）或下划线（_）开头，并在其后跟随零个或多个字母，数字和下划线。 标识符名称中不允许使用标点符号（例如@，$和% ）。
 
 该语言区分大小写，这意味着您可以拥有一个名为 my_variable 的变量和另一个名为 My_variable 的变量，它们将被视为不同的变量。 因此**要小心**，因为这在开发时也会引起问题。
 

docs/166.md

@@ -151,7 +151,7 @@ Spam, Spam, Spam, Spaaam!
 
 ### 字符串格式
 
-字符串格式化在 Python 中很酷。 格式有两种版本：带％符号（类似于 C 的 printf 方法）和字符串本身的 format（）方法。 但是，在大多数情况下，我将同时介绍这两种版本，第二种版本更好，更易于使用。
+字符串格式化在 Python 中很酷。 格式有两种版本：带% 符号（类似于 C 的 printf 方法）和字符串本身的 format（）方法。 但是，在大多数情况下，我将同时介绍这两种版本，第二种版本更好，更易于使用。
 
 让我们直接进入细节。
 
@@ -166,9 +166,9 @@ Spam, Spam, Spam, Spaaam!
 'My name is Bob and I am 31 years young!'
 ```
 
-如您所见，两个格式化选项之间没有太大区别。 但是，如果您查看第一个版本，则可以看到变量使用的占位符（％s 和％d）与第二个版本中的占位符不同。
+如您所见，两个格式化选项之间没有太大区别。 但是，如果您查看第一个版本，则可以看到变量使用的占位符（% s 和% d）与第二个版本中的占位符不同。
 
-关键是对于％格式，您必须告诉参数的类型以根据结果字符串中的格式启用 python。 这也意味着如果要多次打印变量，则必须重复变量。
+关键是对于% 格式，您必须告诉参数的类型以根据结果字符串中的格式启用 python。 这也意味着如果要多次打印变量，则必须重复变量。
 
 格式函数与参数索引一起使用，并根据类型确定格式。 因此，您不必明确提及参数的类型。 如果您提供的参数数量与占位符相同，则可以保留参数索引。
 
@@ -185,21 +185,21 @@ IndexError: tuple index out of range
 'My name is Bob and I am 31 years young and I have read 31 books!'
 ```
 
-取决于您以后使用哪种格式，但是在本系列文章中，我将坚持使用格式功能。 但是，如果您更喜欢％，这里有一些字符以及它们在 format-string 中的作用：
-
-*   **％c** ：字符
-*   **％s** ：格式化前通过 str（）进行字符串转换
-*   **％i** ：带符号的十进制整数
-*   **％d** ：带符号的十进制整数
-*   **％u** ：无符号十进制整数
-*   **％o** ：弱八进制
-*   **％x** ：十六进制整数（小写字母）
-*   **％X** ：十六进制整数（大写字母）
-*   **％e** ：指数符号（小写的“ e”）
-*   **％E** ：指数表示法（大写的“ E”）
-*   **％f** ：浮点实数
-*   **％g** ：％f 和％e 中的较短者
-*   **％G** ：％f 和％E 中的较短者
+取决于您以后使用哪种格式，但是在本系列文章中，我将坚持使用格式功能。 但是，如果您更喜欢% ，这里有一些字符以及它们在 format-string 中的作用：
+
+*   **% c** ：字符
+*   **% s** ：格式化前通过 str（）进行字符串转换
+*   **% i** ：带符号的十进制整数
+*   **% d** ：带符号的十进制整数
+*   **% u** ：无符号十进制整数
+*   **% o** ：弱八进制
+*   **% x** ：十六进制整数（小写字母）
+*   **% X** ：十六进制整数（大写字母）
+*   **% e** ：指数符号（小写的“ e”）
+*   **% E** ：指数表示法（大写的“ E”）
+*   **% f** ：浮点实数
+*   **% g** ：% f 和% e 中的较短者
+*   **% G** ：% f 和% E 中的较短者
 
 ### 参考文献
 

docs/17.md

@@ -79,7 +79,7 @@ class JBTClass {
 
 ## 使用克隆
 
-我们还可以使用`CloneO()`方法创建现有对象的*的副本*。
+我们还可以使用`CloneO()`方法创建现有对象的*副本*。
 
 ```java
 /*

docs/178.md

@@ -350,7 +350,7 @@ for result in (apply_processing to(item) for item in iterable):
 
 #### 实践中的生成器表达式
 
-这是上一本书的清单示例，使用表格 2 进行了重写：
+这是上一本书的清单示例，使用表格 2 进行了覆盖：
 
 ```java
 #Example: Generator Expressions

docs/189.md

@@ -12,7 +12,7 @@
 
 为此，您可以创建自己的自定义解决方案或使用 Hibernate Envers，它是 Hibernate 核心的一部分，提供了开箱即用的功能。
 
-仅提及一个场景：您是汽车零售应用的开发人员。 有人出售一辆豪华轿车的正常价格要低 80％的汽车，却没人知道谁改变了价格。 最后，您会感到内 gui，因为您没有监视，因此必须在很短的时间内解决此问题。
+仅提及一个场景：您是汽车零售应用的开发人员。 有人出售一辆豪华轿车的正常价格要低 80% 的汽车，却没人知道谁改变了价格。 最后，您会感到内 gui，因为您没有监视，因此必须在很短的时间内解决此问题。
 
 如果听起来很绝望，并且您想袖手旁观，请继续阅读。
 

docs/23.md

@@ -34,7 +34,7 @@ var      :   Name of the variable
 
 ## Java 中的变量类型
 
-Java 中的变量可以在代码中的任何位置定义（*在类*旁，*在方法旁或作为方法参数*），并且可以具有不同的修饰符。 根据这些条件，Java 中的变量可以分为四类。
+Java 中的变量可以在代码中的任何位置定义（*在类旁，在方法旁或作为方法参数*），并且可以具有不同的修饰符。 根据这些条件，Java 中的变量可以分为四类。
 
 *   实例变量
 *   静态变量

docs/25.md

@@ -36,7 +36,7 @@ private int pageNumber;
 *   *实例变量*无法具有`strictfp`修饰符。
 *   *实例变量*无法具有`native`修饰符。
 *   *实例变量*不能具有`static`修饰符，因为它会变为类级别的变量。
-*   实例变量将获得默认值，这意味着无需初始化即可使用实例变量。 对于*局部变量，情况并非如此。*
+*   实例变量将获得默认值，这意味着无需初始化即可使用实例变量。 对于*局部变量*，情况并非如此。
 
 | 实例变量类型 | 默认值 |
 | 布尔值 | 假 |

docs/27.md

@@ -62,7 +62,7 @@ public void setCount(int count)
 }
 ```
 
-此关键字是解决歧义所必需的。 如果没有**这个**，编译器将无法知道我们是否要为其自身分配*计数*方法参数值。 如果删除**这个**关键字，则仍然会收到编译警告。
+`this`关键字是解决歧义所必需的。 如果没有`this`，编译器将无法知道我们是否要为其自身分配*计数*方法参数值。 如果删除`this`关键字，则仍然会收到编译警告。
 
 ## 超类场遮蔽
 

docs/29.md

@@ -4,18 +4,18 @@
 
 Java for 循环和增强的 for 循环是一种控制流语句，它提供了一种紧凑的方法来迭代**值**范围。 循环的  重复遍历代码，直到满足特定条件为止。
 
-在此期间，Java 为 *循环*添加了不同类型的*。*
+在此期间，Java `for`*循环*具有不同类型。
 
 *   for 循环
 *   增强了 for 循环或 foreach
 
 ## for 循环
 
-for 循环是 3 个表达式的组合，需要理解才能有效地将其***用于循环***。
+for 循环是 3 个表达式的组合，需要理解才能有效地使用`for`循环。
 
-*   *初始化* 表达式初始化循环； 它会在循环开始时执行一次。
+*   *初始化*表达式初始化循环； 它会在循环开始时执行一次。
 *   *终止表达式*用于停止循环。 每次迭代都会对它进行评估，并且当*终止*表达式的评估结果为`false`时，循环终止。
-*   通过循环的每次迭代后，将调用*增量* / decrement 表达式。
+*   通过循环的每次迭代后，将调用*递增/递减*表达式。
 
 ### 循环的*语法*
 
@@ -173,5 +173,5 @@ are Current Index: 3
 you?Current Index: 4
 ```
 
-可以在[的此处找到](https://github.com/JBTAdmin/java-tutorial/blob/master/for_loop.java)[的代码 *，用于循环* 和 *，用于循环* 。](https://github.com/JBTAdmin/java-tutorial/blob/master/for_loop.java)
+可以在[此处](https://github.com/JBTAdmin/java-tutorial/blob/master/for_loop.java)找到`for`循环的代码。
 

docs/31.md

@@ -28,8 +28,8 @@ IO 异常。
 
 ### 非受检异常
 
-1.  ***非受检异常*** 是 *RuntimeException* 及其任何*子类*。
-2.  编译器不会强制程序员捕获非受检异常或在 throws 子句中声明它。
+1.  ***非受检异常***是`RuntimeException`及其任何*子类*。
+2.  编译器不会强制程序员捕获非受检异常或在`throws`子句中声明它。
 3.  程序员甚至可能不知道会引发异常。
 4.  受检异常必须在编译时捕获。
 5.  运行时异常不是必需的。

docs/33.md

@@ -114,9 +114,9 @@ returning from finally block
 
 ### Explanation
 
-对于方法调用， *riskyAction* （“ hello”）：try 块成功并打印“ try 块中的 hello”。 由于它具有 return 语句，因此控制权转移到 finally 块。 finally 块还具有一个 return 语句，该语句将覆盖 try 块中的语句，因此该方法将返回“ finally 块返回”并打印到控制台。
+对于方法调用，`riskyAction("hello")`：try 块成功并打印“ try 块中的 hello”。 由于它具有 return 语句，因此控制权转移到 finally 块。 finally 块还具有一个 return 语句，该语句将覆盖 try 块中的语句，因此该方法将返回“ finally 块返回”并打印到控制台。
 
-对于 *riskyAction* （“ howdy”）：try 块引发异常，该异常在 catch 块中处理，该异常打印“ catch 块中的 howdy”。 就像我们在 try 块成功的情况下看到的一样，finally 块的 return 语句也覆盖 catch 块中的 return 语句。 结果，该方法返回“从 finally 块返回”并打印到控制台。
+对于`riskyAction("howdy")`：try 块引发异常，该异常在 catch 块中处理，该异常打印“ catch 块中的 howdy”。 就像我们在 try 块成功的情况下看到的一样，finally 块的 return 语句也覆盖 catch 块中的 return 语句。 结果，该方法返回“从 finally 块返回”并打印到控制台。
 
 **注意**：由于无论是否发生异常，finally 块总是被执行，因此，如果它具有 return 语句，则可以预期到意外的结果，并且可能变得难以调试。 **作为一种好的做法，最好避免在 finally 块中编写 return 语句。**
 

docs/35.md

@@ -56,7 +56,7 @@
 *   重载的方法***可能***抛出不同的异常，***更宽或更窄的***没有限制。
 *   **超类**中的方法也可以在子类中重载。
 *   多态适用于覆盖和重载。
-*   基于**参考类型**，确定在***编译时间***上确定将调用哪个重载方法。
+*   基于**引用类型**，确定在***编译时间***上确定将调用哪个重载方法。
 
 方法重载示例
 
@@ -106,11 +106,11 @@ public class MethodOverloading {
 
 
 *   使用相同的方法名称但使用*不同的参数*称为重载。
-*   ***构造器*** 也可以重载
+*   **构造器**也可以重载
 *   重载的方法必须设置*不同的*参数。
-*   重载方法 ***可能*** 具有不同的返回类型 ***。***
-*   重载的方法 ***可能*** 具有*不同的访问修饰符。*
-*   重载的方法 ***可能会*** 抛出不同的异常 ***更宽或更窄的*** 没有限制
+*   重载方法**可能**具有不同的返回类型。
+*   重载的方法**可能**具有*不同的访问修饰符*。
+*   重载的方法**可能会**抛出不同的异常，**更宽或更窄的**没有限制。
 *   **超类**中的方法也可以在子类中重载。
-*   多态适用于覆盖不超载
-*   基于**参考类型**，确定在 ***编译时间*** 上确定将调用哪个重载方法。
\ No newline at end of file
+*   多态适用于覆盖和重载。
+*   基于**引用类型**，确定在**编译时**确定将调用哪个重载方法。
\ No newline at end of file

docs/36.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-overriding/](https://javabeginnerstutorial.com/core-java-tutorial/java-overriding/)
 
-从其**超类**继承该方法的类可以选择**覆盖**它。 覆盖的好处是可以定义特定于特定类的行为的能力。 对于具体的子类，如果在层次结构中没有其他超类实现抽象类中定义的所有方法，则将其强制实现。 覆盖有时称为*运行时绑定*。 这意味着将调用哪个重写方法将由引用类型而不是实例类型确定。
+从其**超类**继承该方法的类可以选择**覆盖**它。 覆盖的好处是可以定义特定于特定类的行为的能力。 对于具体的子类，如果在层次结构中没有其他超类实现抽象类中定义的所有方法，则将其强制实现。 覆盖有时称为*运行时绑定*。 这意味着将调用哪个覆盖方法将由引用类型而不是实例类型确定。
 
 * * *
 
@@ -31,17 +31,17 @@ System.out.println("Show method of Sub class");
 
 ## 方法替代规则
 
-*   覆盖方法*不能使*具有比被覆盖的方法更多的*限制性访问修饰符*，但可以更少。
+*   覆盖方法*不能*具有比被覆盖的方法更多的*限制性访问修饰符*，但可以更少。
 *   参数列表必须与覆盖的方法完全匹配，如果不匹配，则很可能是您正在重载该方法。
-*   返回类型必须与在 Superclass 中的重写方法中声明的返回类型相同或为该子类型的子类型。
-*   覆盖方法*可以*抛出任何*非受检异常（运行时）*，但是它可以抛出比被覆盖方法声明的范围更广或更新的检查异常，但不能抛出更少或狭窄的检查 例外。
-*   *不能覆盖最终的* 方法*。*
-*   *静态* 方法*无法覆盖*。 静态方法看起来可以覆盖，但它是隐藏的。
-*   如果*方法无法继承，则无法重写*。**
+*   返回类型必须与在超类中的覆盖方法中声明的返回类型相同或为该子类型的子类型。
+*   覆盖方法*可以*抛出任何*非受检异常（运行时）*，但是它可以抛出比被覆盖方法声明的范围更广或更新的检查异常，但不能抛出更少或狭窄的异常检查。
+*   *不能覆盖最终的方法*。
+*   *静态*方法*无法覆盖*。 静态方法看起来可以覆盖，但它是隐藏的。
+*   如果*方法无法继承，则无法覆盖*。
 
 ## 从超类调用 Overridden 方法
 
-如果要在执行子类方法之前调用超类的重写方法，该怎么办。 您可以使用 SUPER 关键字。
+如果要在执行子类方法之前调用超类的覆盖方法，该怎么办。 您可以使用 SUPER 关键字。
 
 ```java
 public class SubClass extends superclass {
@@ -102,9 +102,9 @@ class superclass {
 
 ## 备忘单
 
-*   *不能重写构造器*。
+*   *不能覆盖构造器*。
 *   覆盖方法必须具有相同的参数集。
-*   重写的方法必须具有相同的返回类型。 这些返回类型也可以是子类（***协变返回***）。
+*   覆盖的方法必须具有相同的返回类型。 这些返回类型也可以是子类（***协变返回***）。
 *   覆盖的方法**无法**具有更严格的访问修饰符。
 *   覆盖的方法**无法**抛出*新的或更广泛的*异常（***受检***）。 看下面的例子
 *   覆盖的方法**可以引发**任何*非受检异常*。

docs/37.md

@@ -49,22 +49,22 @@ Java 8 引入了默认方法的概念。 现在，如果接口不是抽象的，
 
 接口需要遵循一些规则。
 
-*   所有接口方法都是 *隐式公开和抽象* 。 即使您使用关键字，也不会产生问题，如第二个 Method 声明中所见。 （在 Java 8 之前）
-*   接口只能声明*常量*。 实例变量是不允许的。 这意味着接口内的所有变量必须是公开的，静态的，最终的。 接口内的变量是*隐式公开静态最终*。
+*   所有接口方法都是*隐式公开抽象*的。 即使您使用关键字，也不会产生问题，如第二个 Method 声明中所见。 （在 Java 8 之前）
+*   接口只能声明*常量*。 实例变量是不允许的。 这意味着接口内的所有变量必须是公开的，静态的，最终的。 接口内的变量是*隐式公开静态最终*的。
 *   接口方法不能为*静态*。 （在 Java 8 之前）
-*   接口方法不能是 *final，strictfp 或本机*。
-*   该接口可以 *扩展* 一个或多个其他接口。 注意：该接口只能扩展另一个接口。
+*   接口方法不能是`final`，`strictfp`或`native`。
+*   该接口可以*扩展*一个或多个其他接口。 注意：该接口只能扩展另一个接口。
 
 ## 接口声明规则（JAVA 8）
 
 接口逻辑在 Java 8 中已更改。因此，上述某些逻辑不适用于 Java 8 之后的接口。
 
-*   所有接口方法都可以具有“抽象”，“静态”或“默认”修饰符。
-*   如果对方法使用 static 或 default 修饰符，则接口方法可以具有主体。
+*   所有接口方法都可以具有`abstract`，`static`或默认修饰符。
+*   如果对方法使用`static`或`default`修饰符，则接口方法可以具有主体。
 
 ## 接口与抽象类
 
-*接口*就像具有 *100％抽象类* 一样。 接口不能具有*非抽象方法*，而抽象类则可以。 一个类可以实现多个接口，而只能扩展一个类。 由于抽象类属于类的层次结构，因此它们可以扩展其他类，而接口只能扩展接口。
+*接口*就像*100% 抽象类*一样。 接口不能具有*非抽象方法*，而抽象类则可以。 一个类可以实现多个接口，而只能扩展一个类。 由于抽象类属于类的层次结构，因此它们可以扩展其他类，而接口只能扩展接口。
 
 ## 在类中使用接口
 
@@ -154,7 +154,7 @@ abstract class InterfaceExampleThree implements interfaceTwo {
 
 ### 重点
 
-*   接口是 100％抽象类（***隐式***）。 在 Java 8 之后，它不成立。
+*   接口是 100% 抽象类（***隐式***）。 在 Java 8 之后，它不成立。
 *   接口可以由任何继承树中的任何类实现。
 *   接口中的所有方法都是抽象的。 （在 Java 8 中为 abstract / static / default）
 *   接口可以具有**常量**，这些常量是公开的，静态的和最终的（***隐式***）。

docs/38.md

@@ -24,7 +24,7 @@ Java 继承定义了超类及其子类之间的 is-a 关系。 这意味着只
 *   父类的所有**公开变量**将由子类继承。
 *   所有子类将仅继承*同一包中的所有默认变量*。 包之外的子类将不会继承任何默认成员。
 *   **私有成员**无法由子类继承，因为它们对子类不可见，因此，子类可以使用相同的名称创建 Method 或属性，而不会出现任何问题。*
-*   所有子类都将继承*同一包或外部包* （**与默认设置不同**）中的受保护变量。
+*   所有子类都将继承*同一包或外部包*（**与默认设置不同**）中的受保护变量。
 *   未继承的方法**不能被覆盖**。 因此，覆盖的规则无法应用于这些方法。 但是方法仍然可以在子类中定义，尽管这些方法将不会被覆盖。 相反，它代表一个新的方法。
 *   静态方法或变量不参与继承。
 *   即使静态方法或变量不参与继承且不能被覆盖，也可以在子类中重新定义它们。 重新定义不称为覆盖，而是隐藏。

docs/41.md

@@ -12,7 +12,7 @@
 
 *   *方法*
 *   *变量*
-*   *类嵌套在另一个类*中
+*   *嵌套在另一个类中的类*
 *   *初始化块*
 
 ## 不适用于

docs/46.md

@@ -17,7 +17,7 @@ Java HashMap 是基于 HashTable 的 Map 实现。 这就是为什么面试官
 
 ## 创建 HashMap
 
-在创建 HashMap 时未定义任何参数时，将使用默认的初始容量（16）和默认的负载系数（0.75）。 该 HashMap 最多可以包含 16 个元素，并且在插入第 13 个元素时会调整 HashMap 的大小。 这是因为负载系数为 75％（。75），并且在添加第 13 个元素（12 + 1）时将超过此阈值。
+在创建 HashMap 时未定义任何参数时，将使用默认的初始容量（16）和默认的负载系数（0.75）。 该 HashMap 最多可以包含 16 个元素，并且在插入第 13 个元素时会调整 HashMap 的大小。 这是因为负载系数为 75% （。75），并且在添加第 13 个元素（12 + 1）时将超过此阈值。
 
 您还可以提供初始容量和 loadFactor。 但是初始容量不能超过最大容量（2 功率 30），并且负载系数不能为零或负数。
 

docs/59.md

@@ -155,7 +155,7 @@ private Workday(String representation) {
 
 枚举字段很好，但是如何访问该字段？ 我告诉过您，新的表示形式是表示该枚举的值，但是当前我们无法在枚举本身之外访问该属性。
 
-除此之外，还有一个基本方法可用于所有枚举：name（）以字符串形式返回当前值的名称。 这意味着在基本情况下，您可以使用此方法显示枚举的值（例如，在 UI 或日志条目中）。 **当然**也存在 toString（）函数，但是有时开发人员会重写它，以使其对程序员更友好（或用户友好？）显示。 作为最佳实践，如果要显示枚举的名称，建议您使用 name（）方法而不是 toString（）。
+除此之外，还有一个基本方法可用于所有枚举：name（）以字符串形式返回当前值的名称。 这意味着在基本情况下，您可以使用此方法显示枚举的值（例如，在 UI 或日志条目中）。 **当然**也存在 toString（）函数，但是有时开发人员会覆盖它，以使其对程序员更友好（或用户友好？）显示。 作为最佳实践，如果要显示枚举的名称，建议您使用 name（）方法而不是 toString（）。
 
 要从上面更改表示示例（当我们遍历 values（）时），只需编写一个函数，该函数将返回新的变量表示并在迭代中使用它：
 

docs/62.md

@@ -99,7 +99,7 @@ Thread bat = new Thread(r);
 
 将相同的目标分配给多个线程意味着多个执行线程将运行同一作业（并且同一作业将执行多次）。
 
-> Thread 类本身实现了 Runnable。 （毕竟，它有一个我们要重写的 run（）方法。）这意味着您可以将 Thread 传递给另一个 Thread 的构造器。
+> Thread 类本身实现了 Runnable。 （毕竟，它有一个我们要覆盖的 run（）方法。）这意味着您可以将 Thread 传递给另一个 Thread 的构造器。
 
 ## Thread 类中的重载构造器：
 

docs/64.md

@@ -101,7 +101,7 @@ interface NoParameterInterface {
 
 ### 单参数 Lambda 表达式
 
-您已经看到了不带参数的 Lambda 表达式示例。 我们来看一个带有单个参数的 Lambda 表达式示例。 为此，创建一个名为 **SingleParameter** 的类，并将以下代码粘贴在那里。
+您已经看到了不带参数的 Lambda 表达式示例。 我们来看一个带有单个参数的 Lambda 表达式示例。 为此，创建一个名为`SingleParameter`的类，并将以下代码粘贴在那里。
 
 ```java
 public class SingleParameter {

docs/65.md

@@ -52,7 +52,7 @@ lambda 表达式的关键是->箭头符号。
 *   return 语句是可选的
 *   表达式主体周围的花括号是可选的—如果表达式主体包含单个语句
 
-因为我们的简单表达式符合上述所有四个要点，所以我们可以像这样重写 lambda 表达式：
+因为我们的简单表达式符合上述所有四个要点，所以我们可以像这样覆盖 lambda 表达式：
 
 ```java
 x -> x * x;

docs/84.md

@@ -16,7 +16,7 @@
 [![Firefox_Download](img/02bd3a668c1d9c0d492b54ad13fd2d3f.png) [](https://javabeginnerstutorial.com/wp-content/uploads/2016/08/Download-Firefox.jpg) 
 下载设置文件后，它看起来像这样。
 ![Firefox .exe file](img/914298339f17ebc56235411b9a2315e1.png)
-因此，继续并单击 exe 文件。 提取达到 100％后，将弹出 Mozilla Firefox 安装向导。 点击“下一步”按钮。
+因此，继续并单击 exe 文件。 提取达到 100% 后，将弹出 Mozilla Firefox 安装向导。 点击“下一步”按钮。
 ![Firefox Setup Wizard 1](img/e632b3b7f694e709b33bf13c183582d5.png)
 您可以很好地使用标准作为设置类型。 完全留给您方便。 我选择“标准”，然后单击“下一步”。
 ![Firefox Setup Wizard 2](img/3d3159103f060a91c2039d00e300f47c.png)

docs/9.md

@@ -39,7 +39,7 @@ public class ConstructorExample {
 构造器的语法不同于下面描述的方法。
 
 *   构造器不能具有非访问修饰符，而方法可以。
-*   构造器不能具有返回类型（*包括 void* ），而方法需要它。
+*   构造器不能具有返回类型（*包括`void`*），而方法需要它。
 *   构造器名称必须与类名称相同，而方法不受限制。
 *   根据 Java 命名约定，方法名称应为驼峰式，而构造方法名称应以大写字母开头。
 
@@ -113,7 +113,7 @@ Inside Constructor
 This is in method
 ```
 
-类中的构造器必须与给定的类具有相同的名称。 构造器的语法 *不包含返回类型* ，因为构造器从不返回值。 构造器还可以包括各种类型的参数。 使用`new`运算符调用构造器时，类型必须与构造器定义中指定的类型匹配。
+类中的构造器必须与给定的类具有相同的名称。 构造器的语法*不包含返回类型*，因为构造器从不返回值。 构造器还可以包括各种类型的参数。 使用`new`运算符调用构造器时，类型必须与构造器定义中指定的类型匹配。
 
 如果未提供显式构造器，则 Java 提供一个*默认构造器*，其中**不带参数**并且不执行任何特殊操作或初始化。 隐式默认构造器执行的唯一操作是使用`super()`调用来调用超类构造器。