Java 知识量：11 - 45 - 220
if/else语句用于根据特定条件执行不同的操作。这是其基本语法：
if (condition) {
// code to be executed if condition is true
} else {
// code to be executed if condition is false
}这个代码段检查condition是否为真。如果condition为真，则执行if语句块中的代码；如果condition为假，则执行else语句块中的代码。
例如，假设有一个变量score，想检查这个分数是否及格（大于或等于60）：
int score = 75;
if (score >= 60) {
System.out.println("You passed the exam.");
} else {
System.out.println("You failed the exam.");
}在这个例子中，因为score大于或等于60，所以输出会是 "You passed the exam."。
还可以使用else if来指定新的条件进行测试，如果第一个条件为假：
if (condition1) {
// code to be executed if condition1 is true
} else if (condition2) {
// code to be executed if condition1 is false and condition2 is true
} else {
// code to be executed if both condition1 and condition2 are false
}这种结构非常有用，因为它允许你根据多个条件执行不同的操作。
switch语句是一种多路选择结构，它允许根据变量的值来选择要执行的代码块。switch语句通常用于替换一系列嵌套的if-else语句，使代码更简洁和易读。
以下是switch语句的基本语法：
switch (expression) {
case value1:
// 代码块1
break;
case value2:
// 代码块2
break;
// 更多的case语句
default:
// 默认代码块（可选）
}其中：
expression：要测试的变量或表达式。该表达式必须是一个整型（byte, short, int, char）、枚举、字符串或者从Java SE 7开始，它还可以是一个String类型。
case：用于指定要比较的值。每个case后面跟着一个冒号（:）。
break：用于跳出switch语句，结束当前的case。如果省略break，则会继续执行下一个case，直到遇到break或整个switch语句结束。
default：可选的，用于处理没有匹配的情况。如果没有匹配的case，则执行default代码块。
下面是一个使用switch语句的简单示例：
public class SwitchExample {
public static void main(String[] args) {
int day = 3;
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
default:
System.out.println("Invalid day");
}
}
}在这个例子中，根据变量day的值来输出星期几。如果day的值不在1到7之间，就会执行default代码块，输出"Invalid day"。
while语句用于执行重复任务，只要指定的条件为真，就会重复执行一组语句。下面是一个基本的while循环的例子：
int i = 0;
while (i < 10) {
System.out.println(i);
i++;
}在这个例子中，只要i小于10，就会一直打印i的值，然后增加i的值。当i不再小于10时，循环就会结束。
注意：在while循环中，确保循环的终止条件能够在某个时间点达成，否则循环会一直进行下去，导致程序无法正常结束。在以上例子中，通过每次循环后递增i的值来确保终止条件（i < 10）最终会变为假，从而结束循环。
Java中的do-while循环语句用于执行一段代码块。do-while循环与while循环类似，但是do-while循环至少会执行一次代码块，然后再检查条件。如果条件为真，循环将继续执行，直到条件为假。
以下是Java中do-while循环的语法：
do {
// 代码块
} while (条件);在上面的语法中，"代码块"是要执行的代码，"条件"是一个布尔表达式，用于确定是否继续循环。
以下是一个示例，演示如何使用do-while循环打印数字1到5：
int i = 1;
do {
System.out.println(i);
i++;
} while (i <= 5);在上面的示例中，do-while循环将打印数字1到5，因为循环会在i的值达到6之后停止。
for语句用于执行重复的任务。以下是它的基本结构：
for (初始化; 条件; 迭代) {
// 代码块
}其中：
初始化：在循环开始前执行一次，通常用于设置计数器变量。
条件：每次循环开始前都会检查此条件。如果为true，则执行循环。如果为false，则停止循环。
迭代：每次循环后执行一次，通常用于更新计数器。
示例如下：
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}在这个例子中：
初始化：声明并定义了一个名为i的变量，并将其初始化为1。
条件：设定了一个条件i <= 10。这意味着只要i的值小于或等于10，循环就会继续。
迭代：每次循环结束时，都会增加i的值（i++）。这是一个简单的操作，使i的值增加1。
for each语句是一种用于循环遍历数组或集合中每个元素的语法结构。它提供了一种简洁的方式来迭代数组或集合，而不需要使用索引或迭代器。
for each语句的语法如下：
for (元素类型 变量名 : 数组或集合) {
// 循环体内的操作
}其中，元素类型是要遍历的数组或集合中元素的类型，变量名是一个用于引用当前元素的变量名，数组或集合是要遍历的数组或集合。
以下是一个使用for each语句遍历数组的示例：
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
System.out.println(number);
}在上面的示例中，定义了一个名为numbers的整数数组，并使用for each语句遍历数组中的每个元素，并将它们打印到控制台上。
也可以使用"for each"语句遍历其他类型的集合，例如List、Set等。只需将元素类型替换为集合中元素的类型，变量名替换为当前元素的引用变量名，数组或集合替换为要遍历的集合对象即可。
break语句用于跳出当前循环（例如for、while或do-while循环）。当在循环内部使用break语句时，循环将立即终止，程序控制将传递到循环之后的下一条语句。
下面是一个简单的示例，展示了在使用break语句时如何跳出for循环：
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break; // 当 i 等于 5 时跳出循环
}
System.out.println(i);
}在上面的代码中，当i的值达到5时，break语句将终止for循环。因此，该程序将输出1到4的数字，然后终止。
注意，break语句只能跳出其所在的循环，如果嵌套了多层循环，break只能跳出最内层的循环。如果你想跳出外层循环，可以使用带有标签的break语句。
带有标签的break语句示例：
outer: for (int i = 1; i <= 5; i++) {
inner: for (int j = 1; j <= 5; j++) {
if (i * j == 10) {
break outer; // 当 i * j 等于 10 时跳出外层循环
}
System.out.println(i * j);
}
}在上面的示例中，当i * j的值达到10时，带有标签的break outer语句将终止外层循环。
continue语句用于跳过当前循环中的剩余语句，并立即进入下一次循环。这意味着，如果continue语句在一个循环内部（例如，for、while或者do-while循环）被执行，那么循环的剩余部分将被跳过，程序将立即返回到循环的开头，开始下一次的循环。
以下是一个简单的例子说明continue语句的用法：
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // 如果i是偶数，则跳过剩余的语句，直接进入下一次循环
}
System.out.println(i); // 如果i是奇数，这行代码将被执行
}在这个例子中，当i是偶数时，continue语句被执行，因此"System.out.println(i);"这行代码被跳过。所以，这段代码最后只会打印出奇数。
Java中的try/catch/finally语句用于处理可能在代码中发生的异常。
try语句块包含可能引发异常的代码。如果在try块中发生异常，则程序将跳转到相应的catch块，以处理异常。catch块包含处理特定异常的代码。
finally语句块包含无论是否发生异常都需要执行的代码。无论try或catch块中的代码如何结束，finally块中的代码都会执行。这对于关闭文件、网络连接和其他资源非常有用，以确保它们被正确释放。
以下是一个简单的示例：
try {
// 可能引发异常的代码
int result = 1 / 0; // 除以0会引发异常
} catch (ArithmeticException e) {
// 处理异常的代码
System.out.println("发生了算术异常: " + e.getMessage());
} finally {
// 无论是否发生异常都需要执行的代码
System.out.println("最终会执行此代码块。");
}在上面的示例中，try块中的代码尝试除以0，这会引发算术异常。catch块捕获并处理该异常，而finally块中的代码无论是否发生异常都会执行。
throw语句用于引发一个异常。这是异常处理机制的一部分，它允许创建自定义异常并在代码中引发它们。
throw语句的基本语法如下：
throw new ExceptionType(exceptionMessage);
其中：
ExceptionType是要引发的异常的类型。这可以是Java内置的异常类型，如RuntimeException，或者用户创建的自定义异常类型。
exceptionMessage是一个可选的字符串，提供有关异常的更多详细信息。
这是一个例子，展示了如何使用throw语句引发一个自定义异常：
public class Main {
public static void main(String[] args) {
try {
int result = divide(10, 0);
} catch (MyException e) {
System.out.println("Caught an exception: " + e.getMessage());
}
}
public static int divide(int a, int b) throws MyException {
if (b == 0) {
throw new MyException("Cannot divide by zero");
}
return a / b;
}
}
class MyException extends Exception {
public MyException(String message) {
super(message);
}
}在这个例子中，定义了一个自定义异常类型MyException。在divide方法中，如果第二个参数是0，使用throw语句引发一个MyException异常。然后在main方法中，使用try和catch语句来捕获并处理这个异常。
synchronized关键字用于控制对共享资源的并发访问，以防止线程安全问题。当一个线程访问一个synchronized修饰的共享资源时，其他试图访问该资源的线程将被阻塞，直到第一个线程执行完毕。
在Java中，synchronized关键字可以用于方法或代码块。当它用于方法时，它将锁定整个方法。当它用于代码块时，它将锁定指定的代码块。
以下是一个使用synchronized关键字的示例：
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized void decrement() {
count--;
}
public synchronized int getCount() {
return count;
}
}在上面的示例中，increment()、decrement()和getCount()方法都被声明为synchronized，这意味着在多线程环境中，只有一个线程可以同时访问这些方法。当一个线程调用这些方法之一时，其他线程将被阻塞，直到第一个线程完成执行。
还可以使用synchronized关键字来锁定特定的代码块，而不是整个方法。以下是一个使用synchronized代码块的示例：
public class Counter {
private int count = 0;
public void increment() {
synchronized (this) {
count++;
}
}
public void decrement() {
synchronized (this) {
count--;
}
}
public int getCount() {
synchronized (this) {
return count;
}
}
}在上面的示例中，synchronized关键字用于锁定特定的代码块，而不是整个方法。这可以提高性能，因为多个线程可以同时访问同一个对象的不同代码块。但是，需要注意的是，在使用synchronized代码块时，必须小心选择锁定的对象，以避免死锁等问题。
在Java编程语言中，return语句用于从当前的方法中返回，并且可以携带返回的值。
以下是return语句的一些基本用法：
1、从方法中返回一个值：当在方法中使用了return语句，这个方法就不再继续执行，而是返回你指定的值。
public int getDouble(int x) {
return 2 * x;
}在这个例子中，getDouble方法返回x的两倍。当调用这个方法并传递一个参数，它将返回那个参数的两倍。
2、从方法中返回void：如果方法的返回类型是void，那么return语句可以不返回任何值，或者可以不写return语句。
public void printHello() {
System.out.println("Hello, world!");
return;
}在这个例子中，printHello方法打印出"Hello, world!"，然后返回。因为这个方法的返回类型是void，所以return语句后面没有返回值。
3、从一个lambda表达式中返回：可以在lambda表达式中使用return语句来返回一个值。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
.map(x -> {
if (x % 2 == 0) {
return x * 2;
} else {
return x * 3;
}
})
.forEach(System.out::println);在这个例子中，使用了Java 8的流和lambda表达式。如果数字是偶数，返回它的两倍；如果数字是奇数，返回它的三倍。
4、 从switch语句中返回：可以在switch语句中使用return语句来返回一个值。
public int getNumber(int x) {
switch (x) {
case 1: return 10;
case 2: return 20;
default: return 30;
}
}在这个例子中，如果x等于1，方法返回10；如果x等于2，方法返回20；否则，方法返回30。
5、从try-catch语句中返回：可以在try或catch块中使用return语句来返回一个值。
public int divide(int x, int y) {
try {
return x / y;
} catch (ArithmeticException e) {
return -1; // 返回-1表示除法运算失败
}
}在这个例子中，尝试将x除以y。如果除法成功，返回结果；如果除法失败（例如，如果y等于0），捕获一个算术异常并返回-1。
Copyright © 2017-Now pnotes.cn. All Rights Reserved.
编程学习笔记 保留所有权利
MARK:3.0.0.20240214.P35
From 2017.2.6