Skip to content

P
programiz-zh

OpenDocCN / programiz-zh
10 个月 前同步成功

通知 0
Star 48
Fork 7
P
programiz-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 eeb77e6b 编写于 作者: W wizardforcel
浏览文件
操作

2020-07-01 11:27:39

上级 7485dd51
隐藏空白更改
内联 并排
Showing with 255 addition and 256 deletion
docs/java/10.md
浏览文件 @ eeb77e6b
# Java 流控制
\ No newline at end of file
# Java 流程控制
\ No newline at end of file
docs/java/11.md
浏览文件 @ eeb77e6b
# Java if，if ... else 语句
# Java `if`，`if...else`语句
> 原文： [https://www.programiz.com/java-programming/if-else-statement](https://www.programiz.com/java-programming/if-else-statement)
#### 在本教程中，您将在示例的帮助下了解使用 Java if 和 if ... else 语句的 Java 中的控制流语句。
#### 在本教程中，您将在示例的帮助下了解使用 Java `if`和`if...else`语句的 Java 中的控制流语句。
在计算机编程中，通常需要根据指定条件是`true`还是`false`（仅在运行时才知道）执行代码的特定部分。 在这种情况下，将使用控制流语句。
* * *
## Java if（if-then）语句
## Java `if`（`if`）语句
在 Java 中， **if-then** 语句的语法为：
在 Java 中，`if`语句的语法为：
```java
if (expression) {
......@@ -18,7 +18,7 @@
}
```
此处`表达式`是布尔表达式。 布尔表达式返回 true 或 false。
此处`表达式`是布尔表达式。 布尔表达式返回`true`或`false`。
* 如果表达式的计算结果为`true`，则将执行`if`主体内的语句（括号内的语句）
* 如果表达式的计算结果为`false`，则将跳过`if`主体内部的语句
......@@ -27,15 +27,15 @@
### 语句如何工作？
<figure>![How if statement works in Java?](img/d943bf283f5fb86dfb3b52e494bdee2a.png "Working of Java if statement")
![How if statement works in Java?](img/d943bf283f5fb86dfb3b52e494bdee2a.png "Working of Java if statement")
Working of Java if statement
<figcaption>Working of Java if statement</figcaption>
</figure>
* * *
### 示例 1：Java if 语句
### 示例 1：Java `if`语句
```java
class IfStatement {
......@@ -61,15 +61,15 @@ This statement is always executed.
在上面的示例中，我们有一个名为`编号为`的变量。 这里，测试表达式检查`number`是否大于`0`（`number > 0`）。
由于`数`大于`0`。 因此，测试表达式的求值结果为`true`。 因此，将执行`if`主体内部的代码。
由于`number`大于`0`。 因此，测试表达式的求值结果为`true`。 因此，将执行`if`主体内部的代码。
现在，将`数字`的值更改为负整数。 假设-5。
现在，将`number`的值更改为负整数。 假设 -5。
```java
int number = -5;
```
如果使用新的`数字`值运行上述程序，则输出将是：
如果使用新的`number`值运行上述程序，则输出将是：
```java
This statement is always executed.
......@@ -81,13 +81,13 @@ This statement is always executed.
* * *
## Java if ... else（if-then-else）语句
## Java `if...else`（`if-else`）语句
如果将测试表达式求值为`true`，则`if`语句将执行代码的特定部分。 但是，如果将测试表达式求值为`false`，则它什么也不做。
在这种情况下，我们可以使用可选的`else`块。 如果将测试表达式求值为`false`，则将执行`else`块体内的语句。 在 Java 中，这称为 **if-then-else** 语句。
在这种情况下，我们可以使用可选的`else`块。 如果将测试表达式求值为`false`，则将执行`else`块体内的语句。 在 Java 中，这称为`if-else`语句。
**if-then-else** 语句的语法为：
`if-else`语句的语法为：
```java
if (expression) {
......@@ -98,21 +98,21 @@ else {
}
```
在这里，如果测试表达式为`true`，我们的程序将执行一个任务（如果在块中，则在任务内部），如果测试表达式为`false`，则将执行另一项任务（在 else 块中，在任务内部）。
在这里，如果测试表达式为`true`，我们的程序将执行一个任务（如果在块中，则在任务内部），如果测试表达式为`false`，则将执行另一项任务（在`else`块中，在任务内部）。
* * *
### 如果... else 语句如何工作？
### `if...else`语句如何工作？
![How if...else statement works in Java?](img/56c68f38a6428a68bf4bacb12149b227.png "Working of Java if-else statements")
<figure>![How if...else statement works in Java?](img/56c68f38a6428a68bf4bacb12149b227.png "Working of Java if-else statements")
Working of Java if-else statements
<figcaption>Working of Java if-else statements</figcaption>
</figure>
* * *
### 示例 2：Java if else 语句
### 示例 2：Java `if else`语句
```java
class IfElse {
......@@ -143,13 +143,13 @@ This statement is always executed.
由于`number`的值为`10`，因此测试表达式的值为`true`。 因此，将执行`if`主体内部的代码。
现在，将`数字`的值更改为负整数。 假设`-5`。
现在，将`number`的值更改为负整数。 假设`-5`。
```java
int number = -5;
```
如果使用新的`数字`值运行程序，则输出为：
如果使用新的`number`值运行程序，则输出为：
```java
The number is not positive.
......@@ -160,9 +160,9 @@ This statement is always executed.
* * *
## Java if..else..if 语句
## Java `if..else..if`语句
在 Java 中，我们有一个 **if ... else ... if** 梯形图，可用于执行多个其他块之间的一个代码块。
在 Java 中，我们有一个`if...else...if`梯形图，可用于执行多个其他块之间的一个代码块。
```java
if (expression1) {
......@@ -187,7 +187,7 @@ else {
* * *
### 示例 3：Java if..else..if 语句
### 示例 3：Java `if..else..if`语句
```java
class Ladder {
......@@ -217,7 +217,7 @@ class Ladder {
The number is 0.
```
在上面的示例中，我们正在检查`数字`是正数，负数还是零。 在这里，我们有两个测试表达式：
在上面的示例中，我们正在检查`number`是正数，负数还是零。 在这里，我们有两个测试表达式：
* `number > 0`-检查`number`是否大于`0`
* `number < 0`-检查`number`是否小于`0`
......@@ -226,13 +226,13 @@ The number is 0.
* * *
## Java 嵌套 if..else 语句
## Java 嵌套`if..else`语句
在 Java 中，也可以在`if..else`语句中包含`if..else`语句。 它称为嵌套`if...else`语句。
这是一个查找 3 个数字中最大的一个的程序：
### 示例 4：嵌套 if ... else 语句
### 示例 4：嵌套`if...else`语句
```java
class Number {
......@@ -280,4 +280,4 @@ The largest number is 4.5
**注意：**在上面的程序中，我们自己分配了变量的值来简化此操作。 但是，在实际应用中，这些值可能来自用户输入数据，日志文件，表单提交等。
Java 提供了一个称为**三元运算符**的特殊运算符，如果...其他语句，则它是**的一种简写形式。 要了解三元运算符，请访问 [Java 三元运算符](/java-programming/ternary-operator "Java Ternary Operator")。**
\ No newline at end of file
Java 提供了一个称为**三元运算符**的特殊运算符，它是`if..else`语句的**一种简写形式**。 要了解三元运算符，请访问 [Java 三元运算符](/java-programming/ternary-operator "Java Ternary Operator")。
\ No newline at end of file
docs/java/12.md
浏览文件 @ eeb77e6b
# Java switch 语句
# Java `switch`语句
> 原文： [https://www.programiz.com/java-programming/switch-statement](https://www.programiz.com/java-programming/switch-statement)
#### 在本教程中，您将学习如何使用 Java 中的 switch 语句来控制程序执行的流程
#### 在本教程中，您将学习如何使用 Java 中的`switch`语句来控制程序执行的流程
在 Java 中，我们使用 [if..else..if 梯形图](/java-programming/if-else-statement#if-else-ladder "Java if..else..if ladder")在多个块中执行一个代码块。 但是，if ... else ... if 梯子的语法太长。
在 Java 中，我们使用[`if..else..if`梯形图](/java-programming/if-else-statement#if-else-ladder "Java if..else..if ladder")在多个块中执行一个代码块。 但是，`if...else...if`梯子的语法太长。
因此，如果...其他...如果梯形图，我们可以使用`switch`语句代替长的**。`switch`语句的使用使我们的代码更具可读性。**
因此，我们可以使用`switch`语句代替长的`if...else...if`梯子。`switch`语句的使用使我们的代码更具可读性。
switch 语句的语法为：
`switch`语句的语法为：
```java
switch (variable/expression) {
......@@ -32,7 +32,7 @@ default:
现在，如果值与某个`case`标签匹配，则将执行所有与`case`标签匹配的语句。
例如，如果`variable/expression`等于`value2`。 在这种情况下，将执行与该`case`相匹配的所有语句（case2 的语句）。
例如，如果`variable/expression`等于`value2`。 在这种情况下，将执行与该`case`相匹配的所有语句（`case2`的语句）。
注意，在每种情况下都使用`break`语句。`break`语句用于终止`switch`语句的执行。
......@@ -40,15 +40,15 @@ default:
* * *
## 交换机声明流程图
## `switch`语句流程图
<figure>![Flowchart of the Java switch statement](img/4d11f702043df31b9fb41cd25cf47730.png "Flow chart of the Java switch statement")
![Flowchart of the Java switch statement](img/4d11f702043df31b9fb41cd25cf47730.png "Flow chart of the Java switch statement")
<figcaption>Flow chart of the Java switch statement</figcaption>
Flow chart of the Java switch statement
</figure>
注意：Java switch 语句仅适用于：
注意：Java `switch`语句仅适用于：
* [Java 基本数据类型](/java-programming/variables-primitive-data-types#data-types "Java Primitive data types")：字节，短型，字符和整数
* [Java 枚举类型](/java-programming/enums "Java Enumerated types")
......@@ -57,7 +57,7 @@ default:
* * *
## 示例 1：Java switch 语句
## 示例 1：Java `switch`语句
```java
class Main {
......@@ -112,11 +112,11 @@ The day is Wednesday
* * *
## 示例 2：使用 switch 语句制作计算器
## 示例 2：使用`switch`语句制作计算器
下面的程序从用户那里接收三个输入：**一个操作符**和 **2 个数字**。 根据用户提供的运算符，对这些数字进行计算。 然后结果显示在屏幕上。
在执行程序之前，请确保您了解 [Java 扫描程序](/java-programming/scanner "Java Scanner")，以接受用户的输入。
在执行程序之前，请确保您了解 [Java 扫描器](/java-programming/scanner "Java Scanner")，以接受用户的输入。
```java
import java.util.Scanner;
......
docs/java/123.md
浏览文件 @ eeb77e6b
......@@ -66,7 +66,7 @@ import java.util.Scanner;
* * *
## 用 Java 创建扫描程序对象
## 用 Java 创建扫描器对象
如上所述，导入包后，就可以创建`Scanner`对象。
......@@ -102,7 +102,7 @@ Scanner sc3 = new Scanner(String str);
* * *
### 示例 2：Java 扫描程序 nextInt（）
### 示例 2：Java 扫描器 nextInt（）
```java
import java.util.Scanner;
......@@ -237,13 +237,13 @@ Using nextLine(): Jonny Walker
与`next()`不同，`nextLine()`方法读取包括空格在内的整行输入。 当遇到下一个行字符`\n`时，该方法终止。
**推荐阅读：** [Java 扫描程序跳过 nextLine（）](https://stackoverflow.com/questions/13102045/scanner-is-skipping-nextline-after-using-next-or-nextfoo "Java Scanner skipping the nextLine()")。
**推荐阅读：** [Java 扫描器跳过 nextLine（）](https://stackoverflow.com/questions/13102045/scanner-is-skipping-nextline-after-using-next-or-nextfoo "Java Scanner skipping the nextLine()")。
* * *
## 具有 BigInteger 和 BigDecimal 的 Java 扫描仪
Java 扫描程序还可以用于读取大整数和大十进制数。 要了解 BigInteger 和 BigDecimal，请访问 *Java BigInteger* 和 *Java BigDecimal* 。
Java 扫描器还可以用于读取大整数和大十进制数。 要了解 BigInteger 和 BigDecimal，请访问 *Java BigInteger* 和 *Java BigDecimal* 。
* `nextBigInteger()`-从用户读取大整数值
* `nextBigDecimal()`-从用户读取大十进制值
......@@ -302,6 +302,6 @@ Using nextBigDecimal(): 9.55555
He is 22
```
在这种情况下，扫描程序对象将读取整行并将字符串分成标记：“ **He** ”，“ **为**”和“ **22** ”。 然后，对象遍历每个令牌，并使用其不同方法读取每个令牌。
在这种情况下，扫描器对象将读取整行并将字符串分成标记：“ **He** ”，“ **为**”和“ **22** ”。 然后，对象遍历每个令牌，并使用其不同方法读取每个令牌。
**注意**：默认情况下，空格用于划分令牌。
\ No newline at end of file
docs/java/13.md
浏览文件 @ eeb77e6b
# Java for 循环
# Java `for`循环
> 原文： [https://www.programiz.com/java-programming/for-loop](https://www.programiz.com/java-programming/for-loop)
#### 在本教程中，我们将借助示例学习如何在 Java 中使用 for 循环，并且还将学习 Loop 在计算机编程中的工作方式。
#### 在本教程中，我们将借助示例学习如何在 Java 中使用`for`循环，并且还将学习循环在计算机编程中的工作方式。
在计算机编程中，循环用于重复特定的代码块，直到满足特定条件（测试表达式为`false`）为止。 例如，
想象一下，我们需要在屏幕上打印一个句子 50 次。 好吧，我们可以通过使用 print 语句 50 次（不使用循环）来做到这一点。 您需要打印一百万次句子怎么样？ 您需要使用循环。 使用循环，我们可以只编写一次 print 语句，然后运行任意次。
想象一下，我们需要在屏幕上打印一个句子 50 次。 好吧，我们可以通过使用`print`语句 50 次（不使用循环）来做到这一点。 您需要打印一百万次句子怎么样？ 您需要使用循环。 使用循环，我们可以只编写一次 print 语句，然后运行任意次。
这只是一个简单的示例，显示了循环在计算机编程中的重要性。
* * *
## Java for 循环
## Java `for`循环
Java 中`for`循环的语法为：
......@@ -23,13 +23,13 @@ for (initialization; testExpression; update)
}
```
### for 循环的工作
### `for`循环的工作
1. The **initialization** expression is executed only once.
2. 然后，求值**测试**表达。 在这里，测试表达式是一个布尔表达式。
1. `initialization`表达式只求值一次。
2. 然后，求值`testExpression`表达。 在这里，测试表达式是一个布尔表达式。
3. 如果将测试表达式求值为`true`，则将执行`for`循环体内的
代码。
然后执行**更新**表达式。
然后执行`update`表达式。
再次求值测试表达式。
如果测试表达式为`true`，则执行`for`循环体内的代码，并执行更新表达式。
继续进行此过程，直到将测试表达式求值为`false`为止。
......@@ -39,15 +39,15 @@ for (initialization; testExpression; update)
### 用于循环流程图
<figure>![Java for Loop flowchart](img/c36e9c16d8984a3e6b540c4bacc48d37.png "Working of for loop")
![Java for Loop flowchart](img/c36e9c16d8984a3e6b540c4bacc48d37.png "Working of for loop")
Working of for loop
<figcaption>Working of for loop</figcaption>
</figure>
* * *
### 示例 1：for 循环
### 示例 1：`for`循环
```java
// Program to print a sentence 10 times
......@@ -79,9 +79,9 @@ Line 10
在上面的示例中，我们有
* **初始化表达式**：`int i = 1` .e
* **测试表达式**：i < = 10
* **更新表达式**：++ i
* **初始化表达式**：`int i = 1`
* **测试表达式**：`i < = 10`
* **更新表达式**：`++ i`
在此，最初`i`的值为 1。因此，测试表达式首次求值为`true`。 因此，将执行打印语句。 现在，将求值更新表达式。
......@@ -93,7 +93,7 @@ Line 10
* * *
### 示例 2：for 循环
### 示例 2：`for`循环
```java
// Program to find the sum of natural numbers from 1 to 1000.
......@@ -120,12 +120,12 @@ Sum = 500500
在这里，我们有一个名为`sum`的变量。 其初始值为`0`。 在 for 循环中，我们初始化了一个名为`i`的变量，其值为 1。
在 for 循环的每次迭代中，
在`for`循环的每次迭代中，
* `总和`变量被分配了值：`sum + i`
* `sum`变量被分配了值：`sum + i`
* `i`的值增加 1
循环一直进行到 i 的值大于 1000 为止。为了获得更好的可视化效果，
循环一直进行到`i`的值大于 1000 为止。为了获得更好的可视化效果，
```java
1st iteration: i = 1 and sum = 0+1 = 1
......@@ -163,7 +163,7 @@ class Infinite {
在此，测试表达式（`i <= 10`）永远不会是`false`，并且`hello`不会打印无数次（至少在理论上是这样）。
**注意**：for 语句中使用的初始化，更新和测试表达式是可选的。 这是无限`for`循环的另一个示例。
**注意**：`for`语句中使用的初始化，更新和测试表达式是可选的。 这是无限`for`循环的另一个示例。
```java
for ( ; ; ) {
......@@ -173,7 +173,7 @@ for ( ; ; ) {
* * *
### Java for-each 循环
### Java `for-each`循环
在 Java 中，有`for`循环的另一种语法可用于 [Java 数组](/java-programming/arrays "Java Arrays")和 [Java 集合](/java-programming/collections "Java Collections")（称为`for-each`循环）。 例如，
......@@ -183,4 +183,4 @@ for (int a : array) {
}
```
要了解更多信息，请访问： [Java for-each 循环](/java-programming/enhanced-for-loop "Java for-each Loop")
\ No newline at end of file
要了解更多信息，请访问： [Java `for-each`循环](/java-programming/enhanced-for-loop "Java for-each Loop")
\ No newline at end of file
docs/java/135.md
浏览文件 @ eeb77e6b
......@@ -32,12 +32,12 @@ Reversed Number: 4321
在此程序中，while 循环用于按以下步骤反转数字：
* 首先，将`num`除以 10 的余数存储在变量`数字`中。 现在，`数字`包含`数字`的最后一位，即 4。
`数字`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
* 首先，将`num`除以 10 的余数存储在变量`number`中。 现在，`number`包含`number`的最后一位，即 4。
`number`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
`num`除以 10，因此现在它仅包含前三个数字：123。
* 在第二次迭代后，`数字`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`number` = 12
* 在第三次迭代后，`数字`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`number` = 1
* 在第四次迭代后，`数字`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`number` = 0
* 在第二次迭代后，`number`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`number` = 12
* 在第三次迭代后，`number`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`number` = 1
* 在第四次迭代后，`number`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`number` = 0
* 现在`num` = 0，因此测试表达式`num != 0`失败并且 while 循环退出。 颠倒的``已经包含颠倒的数字 4321。
* * *
......
docs/java/136.md
浏览文件 @ eeb77e6b
......@@ -40,7 +40,7 @@ You entered: 10
然后，将打印`Enter a number`提示，以向用户提供有关下一步操作的可视提示。
然后`reader.nextInt()`会从键盘读取所有输入的整数，除非遇到换行符`\n (Enter)`。 输入的整数然后保存到整数变量`数字`中。
然后`reader.nextInt()`会从键盘读取所有输入的整数，除非遇到换行符`\n (Enter)`。 输入的整数然后保存到整数变量`number`中。
如果输入的字符不是整数，则编译器将抛出`InputMismatchException`。
......
docs/java/14.md
浏览文件 @ eeb77e6b
# Java for-each 循环（增强循环）
# Java `for-each`循环（增强循环）
> 原文： [https://www.programiz.com/java-programming/enhanced-for-loop](https://www.programiz.com/java-programming/enhanced-for-loop)
#### 在本教程中，我们将借助示例学习 Java 中另一种形式的 for 循环，称为增强的 for 循环或每个循环。
#### 在本教程中，我们将借助示例学习 Java 中另一种形式的`for`循环，称为增强的`for`循环或每个循环。
在 Java 中，在处理数组和集合时，我们可以使用增强形式的 for 循环。 也称为 for-each 循环。 这是因为循环会遍历数组或集合的每个元素。
在 Java 中，在处理数组和集合时，我们可以使用增强形式的`for`循环。 也称为`for-each`循环。 这是因为循环会遍历数组或集合的每个元素。
在了解 for-each 循环之前，请确保您了解：
在了解`for-each`循环之前，请确保您了解：
* [Java for 循环](/java-programming/for-loop "Java for Loop")
* [Java `for`循环](/java-programming/for-loop "Java for Loop")
* [Java 数组](/java-programming/arrays "Java Arrays")
* [Java 集合](/java-programming/collections "Java Collections")
* * *
## for 循环和 for-each 循环之间的区别
## `for`循环和`for-each`循环之间的区别
要知道在处理数组时为什么`for-each`循环比`for`循环更受青睐，我们来看下面的示例。
......@@ -70,13 +70,13 @@ u
在这里，我们可以看到两个程序的输出是相同的。
当我们仔细分析这两个程序时，我们可以注意到 for-each 循环更易于编写，并使我们的代码更具可读性。 这就是它被称为增强 for 循环的原因。
当我们仔细分析这两个程序时，我们可以注意到`for-each`循环更易于编写，并使我们的代码更具可读性。 这就是它被称为增强`for`循环的原因。
因此，建议尽可能在标准 for 循环上使用增强的 for 循环。
因此，建议尽可能在标准`for`循环上使用增强的`for`循环。
* * *
## Java for-each 循环
## Java `for-each`循环
我们首先来看一下每个循环的语法：
......@@ -103,7 +103,7 @@ for(data_type item : collections) {
让我们通过一个例子来阐明它。
## 示例：for-each 循环
## 示例：`for-each`循环
下面的程序计算整数数组的所有元素的总和。
......@@ -132,15 +132,15 @@ Sum = 19
在以上程序中，`for-each`循环的执行如下：
| 迭代 | 值 |
| 1 | 数字= 3 且总和= 0 + 3 = 3 |
| 2 | 数字= 4 且总和= 3 + 4 = 7 |
| 3 | 数字= 5 且总和= 7 + 5 = 12 |
| 4 | 数字= -5 且总和= 12 +（-5）= 7 |
| 5 | 数字= 0 且总和= 7 + 0 = 7 |
| 6 | 数字= 12 且总和= 7 + 12 = 19 |
| 1 | 数字`= 3`且总和`= 0 + 3 = 3` |
| 2 | 数字`= 4`且总和`= 3 + 4 = 7` |
| 3 | 数字`= 5`且总和`= 7 + 5 = 12` |
| 4 | 数字`= -5`且总和`= 12 + (-5) = 7` |
| 5 | 数字`= 0`且总和`= 7 + 0 = 7` |
| 6 | 数字`= 12`且总和`= 7 + 12 = 19` |
您可以在每次迭代中看到`for-each`循环
* 遍历`数字`数组中的每个元素
* 将其存储在`数字`变量中
* 并执行主体，即将`number`加到`和`
\ No newline at end of file
* 遍历`number`数组中的每个元素
* 将其存储在`number`变量中
* 并执行主体，即将`number`加到`sum`
\ No newline at end of file
docs/java/142.md
浏览文件 @ eeb77e6b
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/java-programming/examples/even-odd](https://www.programiz.com/java-programming/examples/even-odd)
#### 在该程序中，您将学习检查用户输入的数字是偶数还是奇数。 这将使用 Java 中的 if ... else 语句和三元运算符完成。
#### 在该程序中，您将学习检查用户输入的数字是偶数还是奇数。 这将使用 Java 中的 if...else 语句和三元运算符完成。
## 示例 1：使用 if ... else 语句检查数字是偶数还是奇数
## 示例 1：使用 if...else 语句检查数字是偶数还是奇数
```java
import java.util.Scanner;
......
docs/java/147.md
浏览文件 @ eeb77e6b
......@@ -34,7 +34,7 @@ public class PositiveNegative {
12.3 is a positive number.
```
如果将`数字`的值更改为负数（例如-12.3），则输出将是：
如果将`number`的值更改为负数（例如-12.3），则输出将是：
```java
-12.3 is a negative number.
......
docs/java/15.md
浏览文件 @ eeb77e6b
# Java while 和 do ... while 循环
# Java `while`和`do...while`循环
> 原文： [https://www.programiz.com/java-programming/do-while-loop](https://www.programiz.com/java-programming/do-while-loop)
#### 在本教程中，我们将借助示例学习如何在 Java 中使用 while 和 do while 循环，并且还将学习 Loop 在计算机编程中的工作方式
#### 在本教程中，我们将借助示例学习如何在 Java 中使用`while`和`do while`循环，并且还将学习循环在计算机编程中的工作方式
在计算机编程中，循环用于重复特定的代码块，直到满足特定条件（测试表达式为`false`）为止。 例如，
想象一下，我们需要在屏幕上打印一个句子 50 次。 好吧，我们可以通过使用 print 语句 50 次（不使用循环）来做到这一点。 您需要打印一百万次句子怎么样？ 您需要使用循环。 使用循环，我们可以只编写一次 print 语句，然后运行任意次数。
想象一下，我们需要在屏幕上打印一个句子 50 次。 好吧，我们可以通过使用`print`语句 50 次（不使用循环）来做到这一点。 您需要打印一百万次句子怎么样？ 您需要使用循环。 使用循环，我们可以只编写一次`print`语句，然后运行任意次数。
这只是一个简单的示例，显示了循环在计算机编程中的重要性。 Java 中有 3 种类型的循环：[循环](/java-programming/for-loop)，`while`循环和`do-while`循环。
* * *
## Java while 循环
## Java `while`循环
Java 中`while`循环的语法为：
......@@ -22,11 +22,11 @@ while (testExpression) {
}
```
### while 循环如何工作？
### `while`循环如何工作？
在以上语法中，括号内的**测试**表达式是布尔表达式。 如果测试表达式的计算结果为`true`，
* while 循环内的语句被执行。
* `while`循环内的语句被执行。
* 然后，再次求值测试表达式。
该过程一直进行到测试表达式被求值为`false`为止。 如果将测试表达式求值为`false`，
......@@ -35,17 +35,17 @@ while (testExpression) {
* * *
### While 循环流程图
### `While`循环流程图
<figure>![Java while loop flowchart](img/30e5a661c20677c618554d900cd8601f.png "Working of while Loop")
![Java while loop flowchart](img/30e5a661c20677c618554d900cd8601f.png "Working of while Loop")
Working of while Loop
<figcaption>Working of while Loop</figcaption>
</figure>
* * *
### 示例 1：while 循环
### 示例 1：`while`循环
```java
// Program to print line 10 times
......@@ -80,7 +80,7 @@ Line 10
在上面的示例中，我们有一个测试表达式（`i <= 10`）。 它检查`i`的值是否小于或等于 10。
在这里，最初`i`的值为 1。因此，测试表达式首次求值为`true`。 因此，将执行`while`循环内的 print 语句。
在这里，最初`i`的值为 1。因此，测试表达式首次求值为`true`。 因此，将执行`while`循环内的`print`语句。
在`while`循环中注意以下语句
......@@ -94,7 +94,7 @@ Line 10
* * *
### 示例 2：Java while 循环
### 示例 2：Java `while`循环
```java
// Program to find the sum of natural numbers from 1 to 100.
......@@ -120,11 +120,11 @@ class AssignmentOperator {
Sum = 5050
```
这里，我们有两个变量`和`和`i`，其初始值分别为 0 和 100。
这里，我们有两个变量`sum`和`i`，其初始值分别为 0 和 100。
在`while`循环的每次迭代中，
* `总和`变量被分配了值：`sum + i`
* `sum`变量被分配了值：`sum + i`
* `i`的值减少 1
循环继续进行，直到`i`的值等于 0。为实现更好的可视化效果，
......@@ -141,7 +141,7 @@ Sum = 5050
* * *
## Java 做... while 循环
## Java `do...while`循环
`do...while`循环类似于`while`循环，但有一个按键差异。 在检查测试表达式之前，`do...while`循环的主体将执行一次。
......@@ -155,7 +155,7 @@ do {
* * *
### ... while 循环如何工作？
### `do...while`循环如何工作？
`do...while`循环的主体执行一次（在检查测试表达式之前）。 只有这样，才检查测试表达式。
......@@ -165,17 +165,17 @@ do {
* * *
### do ... while 循环流程图
### `do...while`循环流程图
![Flowchart of do while loop in Java](img/d1b9b2b80aeb37477fda1f86be292d73.png "Working of do...while Loop")
<figure>![Flowchart of do while loop in Java](img/d1b9b2b80aeb37477fda1f86be292d73.png "Working of do...while Loop")
Working of do...while Loop
<figcaption>Working of do...while Loop</figcaption>
</figure>
* * *
### 示例 3：do ... while 循环
### 示例 3：`do...while`循环
下面的程序计算用户输入的数字总和，直到用户输入 0。
......@@ -217,7 +217,7 @@ Sum = 25.0
* * *
### 无限 while 循环
### 无限`while`循环
在使用循环时，我们应始终小心。 这是因为，如果我们错误地设置了测试表达式以使其永远不会为假，则`while`和`do...while`循环将永远运行。
......
docs/java/157.md
浏览文件 @ eeb77e6b
......@@ -32,12 +32,12 @@ Reversed Number: 4321
在此程序中，while 循环用于按以下步骤反转数字：
* 首先，将`num`除以 10 的余数存储在变量`数字`中。 现在，`数字`包含`数字`的最后一位，即 4。
`数字`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
* 首先，将`num`除以 10 的余数存储在变量`number`中。 现在，`number`包含`number`的最后一位，即 4。
`number`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
`num`除以 10，因此现在它仅包含前三个数字：123。
* 在第二次迭代后，`数字`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`number` = 12
* 在第三次迭代后，`数字`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`number` = 1
* 在第四次迭代后，`数字`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`number` = 0
* 在第二次迭代后，`number`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`number` = 12
* 在第三次迭代后，`number`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`number` = 1
* 在第四次迭代后，`number`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`number` = 0
* 现在`num` = 0，因此测试表达式`num != 0`失败并且 while 循环退出。 颠倒的``已经包含颠倒的数字 4321。
* * *
......
docs/java/16.md
浏览文件 @ eeb77e6b
# Java Break 语句
# Java `Break`语句
> 原文： [https://www.programiz.com/java-programming/break-statement](https://www.programiz.com/java-programming/break-statement)
#### 在本教程中，您将借助示例来学习 break 语句，该语句在 Java 中被标记为 break 语句。
#### 在本教程中，您将借助示例来学习`break`语句，该语句在 Java 中被标记为`break`语句。
在使用循环时，有时希望跳过循环内的某些语句或立即终止循环而不检查测试表达式。
......@@ -12,9 +12,9 @@
Java 中的`break`语句立即终止循环，程序的控制移至循环后的下一条语句。
它几乎总是与决策语句一起使用（ [Java if ... else 语句](/java-programming/if-else-statement)）。
它几乎总是与决策语句一起使用（ [Java `if...else`语句](/java-programming/if-else-statement)）。
这是 Java 中 break 语句的语法：
这是 Java 中`break`语句的语法：
```java
break;
......@@ -22,17 +22,17 @@ break;
* * *
## break 语句如何工作？
## `break`语句如何工作？
<figure>![How break statement works in Java programming?](img/8b6dddf93175bfcc760a9221b185b070.png "Working of Java break Statement")
![How break statement works in Java programming?](img/8b6dddf93175bfcc760a9221b185b070.png "Working of Java break Statement")
Working of Java break Statement
<figcaption>Working of Java break Statement</figcaption>
</figure>
* * *
### 示例 1：Java break 语句
### 示例 1：Java `break`语句
```java
class Test {
......@@ -60,7 +60,7 @@ class Test {
4
```
在上面的程序中，我们使用`for`循环在每次迭代中打印`i`的值。 要了解`for`循环的工作方式，请访问 [Java for 循环](/java-programming/for-loop "Java for Loop")。 在这里，请注意以下声明：
在上面的程序中，我们使用`for`循环在每次迭代中打印`i`的值。 要了解`for`循环的工作方式，请访问 [Java `for`循环](/java-programming/for-loop "Java for Loop")。 在这里，请注意以下声明：
```java
if (i == 5) {
......@@ -72,7 +72,7 @@ if (i == 5) {
* * *
### 示例 2：Java break 语句
### 示例 2：Java `break`语句
下面的程序计算用户输入的数字总和，直到用户输入负数。
......@@ -126,35 +126,35 @@ if (number < 0.0) {
}
```
这意味着当用户输入负数时，while 循环终止。
这意味着当用户输入负数时，`while`循环终止。
* * *
## Java 中断和嵌套循环
## Java `break`和嵌套循环
在[嵌套循环](/java-programming/nested-loop "Java nested Loop")的情况下，`break`语句终止最里面的循环。
<figure>![The break statement terminates the innermost while loop in case of nested loops.](img/56fee848ebc71a6592db0fd2c9007b74.png "Working of break Statement with Nested Loops")
![The break statement terminates the innermost while loop in case of nested loops.](img/56fee848ebc71a6592db0fd2c9007b74.png "Working of break Statement with Nested Loops")
Working of break Statement with Nested Loops
<figcaption>Working of break Statement with Nested Loops</figcaption>
</figure>
在这里，break 语句终止最内部的`while`循环，并且控制跳至外部循环。
在这里，`break`语句终止最内部的`while`循环，并且控制跳至外部循环。
* * *
## 标记的中断声明
## 标记的`break`语句
到目前为止，我们已经使用了未标记的`break`语句。 它终止最里面的循环和`switch`语句。 但是，Java 中还有另一种`break`语句形式，称为带标签的`break`。
到目前为止，我们已经使用了未标记的 break 语句。 它终止最里面的循环和 switch 语句。 但是，Java 中还有另一种 break 语句形式，称为带标签的 break。
我们也可以使用标记的`break`语句终止最外面的循环。
我们也可以使用标记的 break 语句终止最外面的循环。
![The labeled break statement is used to break the outermost loop.](img/171d5266b8c72bbaa191894f3cf0987f.png "Working of the labeled break statement in Java")
<figure>![The labeled break statement is used to break the outermost loop.](img/171d5266b8c72bbaa191894f3cf0987f.png "Working of the labeled break statement in Java")
Working of the labeled break statement in Java
<figcaption>Working of the labeled break statement in Java</figcaption>
</figure>
如上图所示，我们已经使用`标签`标识符来指定外部循环。 现在，注意如何使用`break`语句（`break label;`）。
......@@ -181,7 +181,7 @@ while (testExpression) {
* * *
### 示例 3：带标签的 break 语句
### 示例 3：带标签的`break`语句
```java
class LabeledBreak {
......@@ -213,7 +213,7 @@ i = 1; j = 2
i = 2; j = 1
```
在上面的示例中，`labeled break`语句用于终止标记为 first 的循环。 那是，
在上面的示例中，`labeled break`语句用于终止标记为`first`的循环。 那是，
```java
first:
......@@ -257,4 +257,4 @@ i = 4; j = 1
i = 4; j = 2
```
**注意**：`break`语句也用于终止`switch`语句内的大小写。 要了解更多信息，请访问 [Java switch 语句](/java-programming/switch-statement)。
\ No newline at end of file
**注意**：`break`语句也用于终止`switch`语句内的大小写。 要了解更多信息，请访问 [Java `switch`语句](/java-programming/switch-statement)。
\ No newline at end of file
docs/java/162.md
浏览文件 @ eeb77e6b
......@@ -49,7 +49,7 @@ public class Armstrong {
371 is an Armstrong number.
```
* 首先，给定数字（`数字`）的值存储在另一个整数变量`originalNumber`中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
* 首先，给定数字（`number`）的值存储在另一个整数变量`originalNumber`中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
* 然后，使用 while 循环循环遍历`originalNumber`，直到等于 0。
* 在每次迭代中，`number`的最后一位存储在`余数`中。
* 然后，使用`Math.pow()`功能将`余数`加 3（数字位数），并加到`结果`上。
......
docs/java/166.md
浏览文件 @ eeb77e6b
......@@ -31,4 +31,4 @@ Factors of 60 are: 1 2 3 4 5 6 10 12 15 20 30 60
在上述程序中，要查找其因素的编号存储在变量`number`中（60）。
重复执行`for`循环，直到`i <= number`为假。 在每次迭代中，检查`number`是否可被`i`精确整除（`i`是`数字`的因数）和`i`的值增加 1。
\ No newline at end of file
重复执行`for`循环，直到`i <= number`为假。 在每次迭代中，检查`number`是否可被`i`精确整除（`i`是`number`的因数）和`i`的值增加 1。
\ No newline at end of file
docs/java/169.md
浏览文件 @ eeb77e6b
......@@ -34,7 +34,7 @@ public class AddNumbers {
Sum = 210
```
将求和的数字存储在变量`数字`中。
将求和的数字存储在变量`number`中。
最初，从`main()`函数调用`addNumbers()`，并将 20 作为参数传递。
......
docs/java/17.md
浏览文件 @ eeb77e6b
# Java 继续声明
# Java `continue`语句
> 原文： [https://www.programiz.com/java-programming/continue-statement](https://www.programiz.com/java-programming/continue-statement)
#### 在本教程中，您将通过示例了解 Java 中的 continue 语句和标记为 continue 的语句。
#### 在本教程中，您将通过示例了解 Java 中的`continue`语句和标记为`continue`的语句。
在使用循环时，有时希望跳过循环内的某些语句或立即终止循环而不检查测试表达式。
......@@ -12,9 +12,9 @@
Java 中的`continue`语句跳过循环的当前迭代（`for`，`while`，`do...while`等），并且程序控制移至循环的结尾。 并且，求值循环的测试表达式。
在`for`循环的情况下，update 语句在测试表达式之前执行。
在`for`循环的情况下，`update`语句在测试表达式之前执行。
`continue`语句几乎总是用在决策语句中（ [if ... else 语句](/java-programming/if-else-statement)）。 它的语法是：
`continue`语句几乎总是用在决策语句中（[`if...else`语句](/java-programming/if-else-statement)）。 它的语法是：
```java
continue;
......@@ -24,11 +24,11 @@ continue;
## 连续语句如何工作？
<figure>![The continue statement is used in Java Loops (for, while, and do...while loops) to skip the current iteration of the loop.](img/13467eaab0527da1b3021f15025c836d.png "Working of Java continue statement")
![The continue statement is used in Java Loops (for, while, and do...while loops) to skip the current iteration of the loop.](img/13467eaab0527da1b3021f15025c836d.png "Working of Java continue statement")
Working of Java continue statement
<figcaption>Working of Java continue statement</figcaption>
</figure>
* * *
......@@ -62,7 +62,7 @@ class Test {
10
```
在上面的程序中，我们使用`for`循环在每次迭代中打印`i`的值。 要了解`for`循环的工作方式，请访问 [Java for 循环](/java-programming/for-loop)。 在这里，请注意以下声明：
在上面的程序中，我们使用`for`循环在每次迭代中打印`i`的值。 要了解`for`循环的工作方式，请访问 [Java `for`循环](/java-programming/for-loop)。 在这里，请注意以下声明：
```java
if (i > 5 && i < 9) {
......@@ -70,11 +70,11 @@ if (i > 5 && i < 9) {
}
```
这意味着，当`i`的值大于 4 且小于 9 时，将跳过循环内的 print 语句。 因此，我们得到跳过了 5、6、7 和 8 的输出。
这意味着，当`i`的值大于 4 且小于 9 时，将跳过循环内的`print`语句。 因此，我们得到跳过了 5、6、7 和 8 的输出。
* * *
### 示例 2：Java 继续语句
### 示例 2：Java `continue`语句
下面的程序计算用户输入的 5 个正数的总和。 如果用户输入负数或零，则将其从计算中跳过。
......@@ -130,15 +130,15 @@ if (number < 0.0) {
* * *
## Java 继续和嵌套循环
## Java `continue`和嵌套循环
在[嵌套循环](/java-programming/nested-loop)的情况下，`continue`跳过最里面的循环的当前迭代。
<figure>![The continue statement skipped the current iteration of the innermost loop in case of nested loops.](img/e85a2abed9501317a557c4b7cc9accac.png "Working of the continue Statement with Nested Loops")
![The continue statement skipped the current iteration of the innermost loop in case of nested loops.](img/e85a2abed9501317a557c4b7cc9accac.png "Working of the continue Statement with Nested Loops")
Working of the continue statement with Nested Loops
<figcaption>Working of the continue statement with Nested Loops</figcaption>
</figure>
* * *
......@@ -148,11 +148,11 @@ if (number < 0.0) {
我们也可以使用`labeled continue`语句终止最外面的循环。
<figure>![The labeled continue statement is used to skip the current iteration of the outermost labeled loop.](img/ab4de94d4d765d0976fab459e36ac2ca.png "Working of the labeled continue Statement in Java")
![The labeled continue statement is used to skip the current iteration of the outermost labeled loop.](img/ab4de94d4d765d0976fab459e36ac2ca.png "Working of the labeled continue Statement in Java")
Working of the labeled continue Statement in Java
<figcaption>Working of the labeled continue Statement in Java</figcaption>
</figure>
如上图所示，我们已经使用`标签`标识符来指定外部循环。 现在，注意如何使用`continue`语句（`continue label;`）。
......@@ -160,7 +160,7 @@ if (number < 0.0) {
* * *
### 示例 3：标记为 continue 的语句
### 示例 3：标记的`continue`语句
```java
class LabeledContinue {
......
docs/java/178.md
浏览文件 @ eeb77e6b
......@@ -31,6 +31,6 @@ Largest element = 55.50
在上面的程序中，我们将数组的第一个元素存储在最大的变量`中。`
然后，使用`最大的`比较数组中的其他元素。 如果任何数字大于`最大`，则将最大`最大`分配给`数字`。
然后，使用`最大的`比较数组中的其他元素。 如果任何数字大于`最大`，则将最大`最大`分配给`number`。
这样，打印时最大的编号存储在最大的`中。`
\ No newline at end of file
docs/java/19.md
浏览文件 @ eeb77e6b
......@@ -48,7 +48,7 @@ int[] age;
age = new int[5];
```
在此，`年龄`是一个数组。 它可以容纳 5 个`int`类型的值。
在此，`age`是一个数组。 它可以容纳 5 个`int`类型的值。
在 Java 中，我们可以在一个语句中声明并分配数组的内存。 例如，
......@@ -66,17 +66,17 @@ int[] age = new int[5];
int[] age = new int[5];
```
<figure>![Java array index](img/fb0b498feca0d98ab2cef4a07f9b5f01.png "Java Array Index")
![Java array index](img/fb0b498feca0d98ab2cef4a07f9b5f01.png "Java Array Index")
Java Array Index
<figcaption>Java Array Index</figcaption>
</figure>
在这里，我们有一个长度为 5 的数组。在图中，我们可以看到每个元素都由一个数字（数组索引）组成。 数组索引始终从 0 开始。
现在，我们可以使用索引号访问数组的元素。 例如，访问数组的第一个元素可以使用`age[0]`，第二个元素可以使用`age[1]`进行访问，依此类推。
**注意**：如果数组的长度为`n`，则数组的第一个元素为 arrayName [0]，最后一个元素为`arrayName[n-1]`。
**注意**：如果数组的长度为`n`，则数组的第一个元素为`arrayName[0]`，最后一个元素为`arrayName[n-1]`。
如果我们没有将任何值存储到数组，则数组将自行存储一些默认值（`int`类型为`0`，`boolean`类型为`false`）。 例如，
......@@ -107,9 +107,9 @@ class ArrayExample {
0
```
在上面的示例中，我们创建了一个名为 age 的数组。 但是，我们没有为该数组分配任何值。 因此，当我们访问数组的各个元素时，默认值将显示在屏幕上。
在上面的示例中，我们创建了一个名为`age`的数组。 但是，我们没有为该数组分配任何值。 因此，当我们访问数组的各个元素时，默认值将显示在屏幕上。
在这里，我们正在单独访问数组的元素。 有一种使用循环（通常为 [for 循环](/java-programming/for-loop)）访问数组元素的更好方法。 例如，
在这里，我们正在单独访问数组的元素。 有一种使用循环（通常为[`for`循环](/java-programming/for-loop)）访问数组元素的更好方法。 例如，
```java
class ArrayExample {
......@@ -154,11 +154,11 @@ int[] age = {12, 4, 5, 2, 5};
数组的长度由花括号内用逗号分隔的值的数量确定。 在我们的示例中，`age`的长度为 5。
<figure>![Elements are stored in the array](img/a4b14afa1c07858092f9f211932281db.png "Array initialization")
![Elements are stored in the array](img/a4b14afa1c07858092f9f211932281db.png "Array initialization")
Java Arrays initialization
<figcaption>Java Arrays initialization</figcaption>
</figure>
让我们编写一个简单的程序来打印此数组的元素。
......@@ -297,11 +297,11 @@ double[][] matrix = {{1.2, 4.3, 4.0},
* *Java 复制数组*
* *Java 数组方法*
* *Java 数组列出并列出到数组*
* *Java `ArrayList`和列表到数组*
* *Java 字符串数组*
* *Java int 数组*
* *双数组 Java*
* *Java `int`数组*
* *Java `double`数组*
* *Java 对象数组*
* *Java 字符串到数组和数组到字符串的转换*
* *如何使用 Java 打印数组？*
* *在 Java 中是否可以具有数组的动态长度？*
\ No newline at end of file
* *在 Java 中数组是否可以具有动态长度？*
\ No newline at end of file
docs/java/20.md
浏览文件 @ eeb77e6b
......@@ -14,11 +14,11 @@ int[][] a = new int[3][4];
在这里，我们创建了一个名为`和`的多维数组。 它是一个二维数组，最多可容纳 12 个元​​素，
<figure>![2-dimensional array in Java](img/c46b2ff7c300432581a0faacd07f2f36.png "2-dimensional Array")
![2-dimensional array in Java](img/c46b2ff7c300432581a0faacd07f2f36.png "2-dimensional Array")
2-dimensional Array
<figcaption>2-dimensional Array</figcaption>
</figure>
请记住，Java 使用基于零的索引，即 Java 中数组的索引以 0 而不是 1 开头。
......@@ -46,11 +46,11 @@ int[][] a = {
如我们所见，多维数组的每个元素都是数组本身。 而且，与 C/C++ 不同，Java 中多维数组的每一行可以具有不同的长度。
<figure>![2d array example in Java with variable length](img/8d2520cbfa1deb81d3e6f4ee15416fd4.png "Initialization of 2-dimensional Array")
![2d array example in Java with variable length](img/8d2520cbfa1deb81d3e6f4ee15416fd4.png "Initialization of 2-dimensional Array")
Initialization of 2-dimensional Array
<figcaption>Initialization of 2-dimensional Array</figcaption>
</figure>
### 示例：二维数组
......
docs/java/21.md
浏览文件 @ eeb77e6b
......@@ -60,7 +60,7 @@ class Main {
-1, 2, 3, 4, 5, 6
```
在这里，我们可以看到我们更改了`数字`数组的一个值。 当我们打印`positiveNumbers`数组时，我们可以看到相同的值也已更改。
在这里，我们可以看到我们更改了`number`数组的一个值。 当我们打印`positiveNumbers`数组时，我们可以看到相同的值也已更改。
这是因为两个数组都引用同一个数组对象。 这是因为复制浅。 要了解有关浅拷贝的更多信息，请访问[浅拷贝](http://stackoverflow.com/questions/1175620/in-java-what-is-a-shallow-copy)。
......
docs/java/217.md
浏览文件 @ eeb77e6b
......@@ -34,11 +34,11 @@ public class Numeric {
12345.15 is a number
```
在上面的程序中，我们有一个名为`字符串`的`String`，其中包含要检查的字符串。 我们还有一个布尔值`数字`，它存储最终结果是否为数字。
在上面的程序中，我们有一个名为`字符串`的`String`，其中包含要检查的字符串。 我们还有一个布尔值`number`，它存储最终结果是否为数字。
要检查`字符串`是否仅包含数字，在 try 块中，我们使用`Double`的`parseDouble()`方法将字符串转换为`Double`。
如果抛出错误（即`NumberFormatException`错误），则表示`字符串`不是数字，并且`数字`设置为`false`。 否则，这是一个数字。
如果抛出错误（即`NumberFormatException`错误），则表示`字符串`不是数字，并且`number`设置为`false`。 否则，这是一个数字。
但是，如果要检查是否有多个字符串，则需要将其更改为函数。 而且，逻辑基于抛出异常，这可能会非常昂贵。
......
docs/java/23.md
浏览文件 @ eeb77e6b
......@@ -130,11 +130,11 @@ l1.turnOn();
当使用上述语句调用该方法时，将执行`turnOn()`方法主体内的所有语句。 然后，程序的控制跳回到`l1.turnOn()`之后的语句；
<figure>![How methods work in Java?](img/5c2b6e65098d3536292a2a716f96985c.png "Working of Methods in Java")
![How methods work in Java?](img/5c2b6e65098d3536292a2a716f96985c.png "Working of Methods in Java")
Working of Methods in Java
<figcaption>Working of Methods in Java</figcaption>
</figure>
同样，可以通过以下方式访问实例变量：
......
docs/java/24.md
浏览文件 @ eeb77e6b
......@@ -118,11 +118,11 @@ myMethod();
该语句调用先前声明的`myMethod()`方法。
<figure>![Working of the method call in Java](img/524d4cee02ac3668c0bda12c0770e843.png "Working of the method call in Java")
![Working of the method call in Java](img/524d4cee02ac3668c0bda12c0770e843.png "Working of the method call in Java")
Working of the method call in Java
<figcaption>Working of the method call in Java</figcaption>
</figure>
1. 在执行程序代码时，它在代码中遇到`myFunction();`。
2. 然后执行分支到`myFunction()`方法，并在该方法体内执行代码。
......@@ -245,11 +245,11 @@ Squared value of 10 is: 100
在这里，我们将方法的返回类型称为`int`。 因此，该方法应始终返回整数值。
<figure>![Representation of a method returning a value](img/3119eccc9e076e7cfe62028f7ce6ffe2.png "Representation of a method returning a value")
![Representation of a method returning a value](img/3119eccc9e076e7cfe62028f7ce6ffe2.png "Representation of a method returning a value")
Representation of a method returning a value
<figcaption>Representation of a method returning a value</figcaption>
</figure>
如我们所见，此方法的范围是有限的，因为它总是返回相同的值。 现在，让我们修改上面的代码片段，以使它始终返回传递给该方法的任何整数的平方值，而不是始终返回平方值 10。
......@@ -288,11 +288,11 @@ Squared value of 4 is: 16
这里，`square(`）方法接受参数`i`并返回`i`的平方。 返回的值存储在变量`结果`中。
<figure>![Example showing passing argument to method and returning value](img/a4d7ea6f6937289efc4a781e08bfa8ba.png "Passing arguments and returning a value from a method in Java")
![Example showing passing argument to method and returning value](img/a4d7ea6f6937289efc4a781e08bfa8ba.png "Passing arguments and returning a value from a method in Java")
Passing arguments and returning a value from a method in Java
<figcaption>Passing arguments and returning a value from a method in Java</figcaption>
</figure>
如果我们传递任何其他数据类型而不是 int，则编译器将引发错误。 这是因为 Java 是一种强类型语言。
......
docs/java/27.md
浏览文件 @ eeb77e6b
......@@ -220,10 +220,10 @@ I have 4 legs.
## 一图概述了访问修饰符
<figure>![Accessibility of all Access Modifiers in Java](img/2d390a56daf23e3f76b9075aa101f39e.png "Accessibility of all Access Modifiers in Java")
![Accessibility of all Access Modifiers in Java](img/2d390a56daf23e3f76b9075aa101f39e.png "Accessibility of all Access Modifiers in Java")
Accessibility of all Access Modifiers in Java
<figcaption>Accessibility of all Access Modifiers in Java</figcaption>
</figure>
访问修饰符主要用于封装。 我可以帮助我们控制程序的哪些部分可以访问类的成员。 这样就可以防止滥用数据。 要了解有关封装的更多信息，请访问 [Java 封装](/java-programming/encapsulation "Java Encapsulation")。
\ No newline at end of file
docs/java/28.md
浏览文件 @ eeb77e6b
......@@ -109,7 +109,7 @@ class Main {
obj.age = 8
```
现在，我们正在获得预期的输出。 这是因为调用构造函数时，构造函数内部的`this`被调用了构造函数的对象`obj`代替。 因此，将`年龄`变量分配给值`8`。
现在，我们正在获得预期的输出。 这是因为调用构造函数时，构造函数内部的`this`被调用了构造函数的对象`obj`代替。 因此，将`age`变量分配给值`8`。
另外，如果参数和实例变量的名称不同，则编译器会自动附加此关键字。 例如，代码：
......
docs/java/30.md
浏览文件 @ eeb77e6b
......@@ -12,17 +12,17 @@
### 递归如何工作？
<figure>![A function is calling itself](img/98c8b3e1c9ca805d7cabab0f8bea1bf4.png "Working of Java Recursion")
![A function is calling itself](img/98c8b3e1c9ca805d7cabab0f8bea1bf4.png "Working of Java Recursion")
Working of Java Recursion
<figcaption>Working of Java Recursion</figcaption>
</figure>
在上面的示例中，我们从`main`方法内部调用了`recurse()`方法。 （正常方法调用）。 并且，在 recurse（）方法内部，我们再次调用相同的 recurse 方法。 这是一个递归调用。
为了停止递归调用，我们需要在方法内部提供一些条件。 否则，该方法将被无限调用。
因此，我们使用 [if ... else 语句](/java-programming/if-else-statement "Java if...else")（或类似方法）来终止方法内部的递归调用。
因此，我们使用 [if...else 语句](/java-programming/if-else-statement "Java if...else")（或类似方法）来终止方法内部的递归调用。
* * *
......@@ -52,7 +52,7 @@ class Factorial {
4 factorial = 24
```
在上面的示例中，我们有一个名为`factorial()`的方法。 从`main()`方法中调用`factorial()`。`数字`变量作为参数传递。
在上面的示例中，我们有一个名为`factorial()`的方法。 从`main()`方法中调用`factorial()`。`number`变量作为参数传递。
在这里，请注意以下声明：
......@@ -70,11 +70,11 @@ return n * factorial(n-1);
下图将使您更好地了解如何使用递归执行阶乘程序。
<figure>![Finding the factorial of a number using recursion](img/2fadcf39da8f7f8c908856a362725c5e.png "Factorial Program using Recursion")
![Finding the factorial of a number using recursion](img/2fadcf39da8f7f8c908856a362725c5e.png "Factorial Program using Recursion")
Factorial Program using Recursion
<figcaption>Factorial Program using Recursion</figcaption>
</figure>
* * *
......
docs/java/31.md
浏览文件 @ eeb77e6b
......@@ -39,7 +39,7 @@ Is name an instance of String: true
Is age an instance of Integer: true
```
在上面的示例中，我们创建了`String`类型的对象`名称`和`Integer`类型的另一个对象`年龄`。 然后，我们使用`instanceof`运算符检查`名称`是否为`String`类型，以及`年龄`是否为`Integer`类型。
在上面的示例中，我们创建了`String`类型的对象`名称`和`Integer`类型的另一个对象`age`。 然后，我们使用`instanceof`运算符检查`名称`是否为`String`类型，以及`age`是否为`Integer`类型。
* * *
......
docs/java/39.md
浏览文件 @ eeb77e6b
......@@ -75,15 +75,15 @@ class Main {
My age is 24
```
在上面的示例中，我们有一个`private`字段`age`。 由于它是私有的，因此无法从类外部访问它。 为了访问`年龄`，我们使用了`public`方法`getAge()`和`setAge()`。 这些方法称为 getter 和 setter 方法。
在上面的示例中，我们有一个`private`字段`age`。 由于它是私有的，因此无法从类外部访问它。 为了访问`age`，我们使用了`public`方法`getAge()`和`setAge()`。 这些方法称为 getter 和 setter 方法。
如果尝试从`主`类访问`年龄`字段，则会收到错误消息。
如果尝试从`主`类访问`age`字段，则会收到错误消息。
```java
p1.age = 24; // error: age has private access in Person
```
通过将`年龄`设为私有，我们可以限制来自课堂之外的未经授权的访问。 这是数据隐藏。
通过将`age`设为私有，我们可以限制来自课堂之外的未经授权的访问。 这是数据隐藏。
* * *
......@@ -124,7 +124,7 @@ I am a teacher
* 在 Java 中，封装可帮助我们将相关的字段和方法保持在一起，这使我们的代码更整洁且易于阅读。
* 它有助于控制我们数据字段的修改。 考虑一种情况，我们希望类中的`年龄`字段为非负数。 在这里，我们可以确定年龄`private`并可以在方法`setAge()`中应用逻辑。 例如，
* 它有助于控制我们数据字段的修改。 考虑一种情况，我们希望类中的`age`字段为非负数。 在这里，我们可以确定年龄`private`并可以在方法`setAge()`中应用逻辑。 例如，
```java
class Person {
......
docs/java/4.md
浏览文件 @ eeb77e6b
......@@ -12,11 +12,11 @@ JVM（Java 虚拟机）是使您的计算机运行 Java 程序的抽象机。
Java 是与平台无关的语言。 这是因为当您编写 Java 代码时，它最终是为 JVM 而不是物理机（计算机）编写的。 由于 JVM 执行与平台无关的 Java 字节码，因此 Java 与平台无关。
<figure>![How does Java program work?](img/78c88b2cb68225a328607e3142dcde31.png "Working of Java Program")
![How does Java program work?](img/78c88b2cb68225a328607e3142dcde31.png "Working of Java Program")
Working of Java Program
<figcaption>Working of Java Program</figcaption>
</figure>
如果您对学习 JVM 体系结构感兴趣，请访问 [JVM 体系结构说明](https://dzone.com/articles/jvm-architecture-explained)。
......@@ -28,11 +28,11 @@ JRE（Java 运行时环境）是一个软件包，提供 Java 类库，Java 虚
JRE 是 JVM 的超集。
<figure>![JRE contains JVM and other Java class libraries.](img/3ec88fb0a9d3b5347fdb6065d741b65f.png "Java Runtime Environment")
![JRE contains JVM and other Java class libraries.](img/3ec88fb0a9d3b5347fdb6065d741b65f.png "Java Runtime Environment")
Java Runtime Environment
<figcaption>Java Runtime Environment</figcaption>
</figure>
如果您需要运行 Java 程序而不是开发它们，则需要 JRE。 您可以从 [Java SE Runtime Environment 8 下载](http://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html)页面下载 JRE。
......@@ -44,11 +44,11 @@ JDK（Java 开发套件）是使用 Java 开发应用程序所需的软件开发
除了 JRE，JDK 还包含许多开发工具（编译器，JavaDoc，Java Debugger 等）。
<figure>![JDK contains JRE and other tools to develop Java applications.](img/70d0a6ead31a22745b9f926e601cd51d.png "Java development kit")
![JDK contains JRE and other tools to develop Java applications.](img/70d0a6ead31a22745b9f926e601cd51d.png "Java development kit")
Java Development Kit
<figcaption>Java Development Kit</figcaption>
</figure>
如果要开发 Java 应用程序，请[下载 JDK](http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html) 。
......@@ -56,8 +56,7 @@ JDK（Java 开发套件）是使用 Java 开发应用程序所需的软件开发
## JVM，JRE 和 JDK 之间的关系。
<figure>![JRE contains JVM and class libraries and JDK contains JRE, compilers, debuggers, and JavaDoc](img/e81a27912388282d5dc563dda1cdf750.png "Relationship between JVM, JRE, and JDK")
![JRE contains JVM and class libraries and JDK contains JRE, compilers, debuggers, and JavaDoc](img/e81a27912388282d5dc563dda1cdf750.png "Relationship between JVM, JRE, and JDK")
<figcaption>Relationship between JVM, JRE, and JDK</figcaption>
Relationship between JVM, JRE, and JDK
</figure>
\ No newline at end of file
docs/java/5.md
浏览文件 @ eeb77e6b
......@@ -61,11 +61,11 @@ Java 编程语言具有一套自己的变量命名规则和约定。 这是您
* Java 中的变量区分大小写。
* 变量的名称是 Unicode 字母和数字的序列。 它可以以字母`$`或`_`开头。 但是，习惯上以字母开头的变量名。 同样，变量名称不能在 Java 中使用空格。
<figure>![Java variable naming convention](img/e2c5773c156f1f65b8be5ea5e5756ce1.png "Variable Naming Convention")
![Java variable naming convention](img/e2c5773c156f1f65b8be5ea5e5756ce1.png "Variable Naming Convention")
<figcaption>变量命名约定</figcaption>
变量命名约定
</figure>
* 创建变量时，请选择一个有意义的名称。 例如，`得分`，`number`，`级别`比诸如`s`，`n`等变量名更有意义。 和`1`。
* 如果选择一字变量名称，请使用所有小写字母。 例如，最好使用`速度`而不是`SPEED`或`sPEED`。
......
docs/java/57.md
浏览文件 @ eeb77e6b
......@@ -16,11 +16,11 @@ Java 允许我们通过日志记录过程来创建和捕获日志消息和文件
下图表示 Java 日志记录 API（`java.util.logging`）的核心组件和控制流程。
<figure>![The flow of control of Java Logging API](img/9cd80e66a62f7c466eb14130b5431c48.png "Java Logging")
![The flow of control of Java Logging API](img/9cd80e66a62f7c466eb14130b5431c48.png "Java Logging")
Java Logging
<figcaption>Java Logging</figcaption>
</figure>
### 1.记录仪
......
docs/java/6.md
浏览文件 @ eeb77e6b
......@@ -394,7 +394,7 @@ false
## 三元运算符
条件运算符或三元运算符`?:`是`if-then-else`语句的简写。 条件运算符的语法为：
条件运算符或三元运算符`?:`是`if-else`语句的简写。 条件运算符的语法为：
```java
variable = Expression ? expression1 : expression2
......
docs/java/77.md
浏览文件 @ eeb77e6b
......@@ -17,7 +17,7 @@ Java 集合框架的`HashMap`类提供 [Map 接口](/java-programming/map "Java
HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);
```
在上面的代码中，我们创建了一个名为`数字`的哈希图。
在上面的代码中，我们创建了一个名为`number`的哈希图。
这里，
......
docs/java/78.md
浏览文件 @ eeb77e6b
......@@ -21,7 +21,7 @@ Java 集合框架的`LinkedHashMap`类提供 [Map 接口](/java-programming/map
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);
```
在上面的代码中，我们创建了一个名为`数字`的链接哈希图。
在上面的代码中，我们创建了一个名为`number`的链接哈希图。
这里，
......
docs/java/79.md
浏览文件 @ eeb77e6b
......@@ -27,7 +27,7 @@ Java 集合框架的`WeakHashMap`类提供了哈希表数据结构的功能。
WeakHashMap<Key, Value> numbers = new WeakHashMap<>(8, 0.6);
```
在上面的代码中，我们创建了一个名为`数字`的弱哈希图。
在上面的代码中，我们创建了一个名为`number`的弱哈希图。
这里，
......
docs/java/81.md
浏览文件 @ eeb77e6b
......@@ -31,7 +31,7 @@ Java 集合框架的`SortedMap`接口可对存储在映射中的键进行排序
SortedMap<Key, Value> numbers = new TreeMap<>();
```
我们使用`TreeMap`类创建了一个名为`数字`的排序映射。
我们使用`TreeMap`类创建了一个名为`number`的排序映射。
这里，
......
docs/java/82.md
浏览文件 @ eeb77e6b
......@@ -29,7 +29,7 @@ Java 集合框架的`NavigableMap`接口提供了在地图条目之间导航的
NavigableMap<Key, Value> numbers = new TreeMap<>();
```
在上面的代码中，我们创建了一个名为`TreeMap`类的`数字`的可导航地图。
在上面的代码中，我们创建了一个名为`TreeMap`类的`number`的可导航地图。
这里，
......
docs/java/84.md
浏览文件 @ eeb77e6b
......@@ -31,7 +31,7 @@ Java 集合框架的`ConcurrentMap`接口提供了线程安全的映射。 也
CocurrentMap<Key, Value> numbers = new ConcurrentHashMap<>();
```
在上面的代码中，我们创建了一个名为`数字`的并发映射。
在上面的代码中，我们创建了一个名为`number`的并发映射。
这里，
......
docs/java/85.md
浏览文件 @ eeb77e6b
......@@ -21,7 +21,7 @@ Java 集合框架的`ConcurrentHashMap`类提供了线程安全的映射。 也
ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);
```
在上面的代码中，我们创建了一个名为`数字`的并发哈希图。
在上面的代码中，我们创建了一个名为`number`的并发哈希图。
这里，
......
docs/java/90.md
浏览文件 @ eeb77e6b
......@@ -27,7 +27,7 @@ Java 集合框架的`LinkedHashSet`类提供哈希表和链接列表数据结构
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);
```
在这里，我们创建了一个名为`数字`的链接哈希集。
在这里，我们创建了一个名为`number`的链接哈希集。
注意，部分`new LinkedHashSet<>(8, 0.75)`。 在此，第一个参数是**容量**，第二个参数是 **loadFactor** 。
......
docs/java/92.md
浏览文件 @ eeb77e6b
......@@ -27,7 +27,7 @@ Java Collections 框架的`NavigableSet`接口提供了在设置的元素之间
NavigableSet<String> numbers = new TreeSet<>();
```
在这里，我们创建了一个名为`TreeSet`类的`数字`的可导航集合。
在这里，我们创建了一个名为`TreeSet`类的`number`的可导航集合。
* * *
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或