Contents hide
1. 条件判断
1.1. if 条件判断
1.2. 条件判断类型
1.3. switch条件判断
2. 循环 Loop
2.1. while循环
2.2. for循环
2.3. 嵌套循环
2.4. break, continue
3. 实践练习

条件判断

if 条件判断

计算机之所以能做很多自动化的任务，是因为它自己可以做条件判断。比如，根据用户的分数，打印出不同的奖励值。在Java中可以使用 if 语句实现条件判断：

int score = 70;
int reward;
if(score >= 60) {
    reward = score * 2;
} else {
    reward = 0;
}
System.out.println("Reward: " + reward); // 140

在以上的代码中，我们给 score 赋值 70，然后我们创建了一个 reward 变量。紧接着我们进入条件判断，如果 score 大于 60 ，那么 reward 就等于 score的2倍，不然 reward 就是0。

以下是 if 语句的语法：

if(condition1) { 
    // code statements
} else if(condition2) {
   // code statements 
} else {
   // code statements
}

在 if 之后必须紧跟着一个条件判断，然后加上做尖括号 { 紧跟着要执行的代码，之后以 } 结束一个条件的执行内容。如果判断的内容简单，比如以上score的例子，我们则不需要 else if 语句，直接紧跟着 else 语句即可，当 if 判断的条件不为真时，else 中的内容会自动执行。

如果我们需要判断多个条件，那么我们就需要加上 else if 语句，我们来看以下的例子：

int score = 70, reward = 0;
if(score >= 90) {
    reward = score * 2;
} else if(score >= 80) {
    reward = score * 3 / 2;
} else if (score >= 60) {
    reward = score;
} else {
    reward = 0;
}
System.out.println("Reward: " + reward); // 70

在这个例子中，我们有三个条件需要判断。第一个条件判断score是否大于等于90，如果为真，reward则是score的两倍，不为真的话，我们进入第二个条件判断：score是否大于80，为真，reward则是score的1.5倍，如果还不为真，那么就进入第三个条件判断：score是否大于60，如果为真，reward则会被赋予score一样的数值。最后的else只有在前三个条件都不满足的时候，才会被执行。

在我们的代码中，score为70，所以前两个条件判断都无法满足，但是能满足第三个判断，所以最后reward则是70。

在 if 语句中，只有第一个条件判断必须以 if 为开头，其他的都是 else if，else if的判断数量不限，最后再使用 else 来处理所有条件都不满足的情况。

上一期运算符章节中提到了一个特殊的运算符，就是条件判断中的三元判断符，它会根据布尔表达式的判断，来决定将哪个值赋给变量，其中只包含三个操作数：

variable = (condition) ? expressionTrue: expressionFalse;

用三元判断符实现条件判断十分简易，比如以下的例子：

int reward = score >= 60 ? score * 2 : 0;

上面的代码根据score变量的数值，来赋值reward变量。如果score大于或等于60，那么reward就是score的两倍，不然就是0。

条件判断类型

除了基本的数值条件判断外，java中还有其他的条件判断类型：

  • 布尔语句：true
  • 查询是否相等或不能：age == 18
  • 区分大小写：Character.isUpperCase(letterA)
  • 数值比较：age >= 21
  • 字符串比较：car == “BMW”
  • 多个条件判断：score >= 60 && score <= 80

以下是布尔语句的简单使用：

boolean gameOver = true;
if (gameOver) {
    System.out.println("You are dead :(");
} else {
    System.out.println("Do you want to continue?");
}

这个例子中，我们的条件就是 gameOver这个变量，如果为真输出游戏结束的信息，不然就询问玩家是否要继续。

假设我们要给一个餐厅写一个程序，来根据会员的类型来决定用餐价格，我们可以使用多个条件判断：

enum Membership { NORMAL, SILVER, GOLD, DIAMOND };

public static void mealCalculation() {
    Membership memberType = Membership.GOLD;
    int mealPrice = 1000, payment = 0;
    if (memberType == Membership.GOLD || memberType == Membership.DIAMOND) {
        payment = mealPrice * 8 / 10;
    } else if (memberType == Membership.SILVER) {
        payment = mealPrice * 9 / 10;
    } else {
        payment = mealPrice;
    }
    System.out.printf("You should pay $%s for the meal.\n", payment);
}

上面的例子中，第一个 if 判断使用多个条件判断，如果用户是GOLD或者DIAMOND级别，那么打8折，如果是SILVER级别，打9折，不然不打折。灵活使用条件判断，可以让我们的程序更容易理解。

switch条件判断

另一个能够进行条件判断的就是switch语句，它会根据不同条件执行不同的代码块，以下是它的基本语法：

switch(expression) { 
    case x:
        // code block 1
        break;
    case y:
        // code block 2
        break;
    case z: 
        // code block 3
        break;
    default:
        // code block 4
}

switch语句中的变量类型可以是：byte、short、int、char或者String。switch语句可以使用多个case语句，每个case后面跟着一个要比较的数值和冒号。在case语句中，如果出现 break 关键词，那么switch语句就会终止，beak 关键词不是必须的，如果没有的话，程序就会继续执行下一个case语句，知道出现break为止。如果所有的case都不满足，那么switch就会执行default中的语句。

下面我们来看一个根据成绩的等级，打印不同信息的程序。

char grade = 'A';
switch (grade) {
    case 'A':
        System.out.println("Great job!");
        break;
    case 'B': 
    case 'C':
        System.out.println("Good job.");
        break;
    case 'D': 
    case 'F': 
        System.out.println("You can do better.");
        break;
    default:
        System.out.println("Unknown grade");
}

在上面的例子中，我们根据grade打印出不同的信息，如果成绩是’A’就称赞，如果是’B’或者‘C’，也夸奖一下，如果是’D’或者’F’就鼓励对方，不然就是未知成绩。

循环 Loop

循环可以帮助我们执行一些重复的任务，让我们的程序更加智能化。在Java中用来控制循环的主要有两个语句，while和for语句。

while循环

以下是 while 的语法：

while(condition) {
    // code block to be executed
}

在下面的例子中，只有变量 i 小于等于 5，循环就会不断执行，最后会隔行打印出0~4：

int i = 0;
while(i < 5) {
    System.out.println(i);
    i++;
}

另一个与while相关的循环就是do…while语句，这个循环里的代码至少会被执行一次，然后再根据循环条件判断是否需要再次继续：

do {
    // code block to be executed
} while (condition);

使用do…while，不管循环条件是否为真，循环至少会被执行一次。我们可以将上面的例子，用do…while来重写：

int i = 0;
do {
    System.out.println(i);
    i++;
} while(i < 5);

for循环

当你知道循环确切的次数，可以使用 for 循环来代替 while 循环：

for(statement 1; statement2; statement3) {
    // code block to be executed
}

statement1 会在执行循环代码块之前有且只执行一次；statement2 定义了是否执行循环代码块的判断条件；statement3 会在每次循环代码块执行完之后执行。以下的例子使用 for loop 打印了数字 0 到 4：

for(int i = 0; i < 5; i++) {
    System.out.println(i);
}

statement1定义了变量 i，并初始化为数值1。statement2定义了判断条件：i 是否小于5，如果条件为真，继续执行循环代码块，否则结束循环。每次执行完循环代码块后，statement3让变量 i 增加1 。循环代码块的作用则是打印出 i 的数值。

下面的例子也是使用 for 循环，打印出 0 到 10 之间的偶数：

for(int i = 0; i <= 10; i = i + 2) {
    System.out.println(i);
}

for 也可以用来遍历数组，它的语法更加简洁：

for(type variableName: arrayName) {
    // code block to be executed
}

其中 type 是数值元素的类型，vairableName是你给元素的自定义名字，arrayName则是数组变量的名字。在下面的例子中，我们使用 for 循环遍历了 cars 数组，并将每个车的品牌打印出来：

String[] cars = {"Ford", "BMV", "Porsche", "Ferrari"};
for(String car: cars) {
    System.out.println(car);
}

嵌套循环

嵌套循环就是在一个循环中再套用另一个循环。我们可以嵌套循环来实现复杂的操作，比如要打印出o~99，我们可以使用以下的嵌套循环：

for(int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        System.out.println(i * 10 + j);
    }
}

嵌套循环很经常用来遍历多维矩阵，我们可以使用以下的遍历方式将多维数组中的数据完整地打印出来：

int[][] numMatrix = { {1, 2, 3, 4}, {5, 6, 7}, {8, 9, 10, 11, 12}};
for(int i = 0; i < numMatrix.length; i++) {
    for(int j = 0; j < numMatrix[i].length; j++) {
        System.out.print(numMatrix[i][j] + " ");
    }
    System.out.println();
}

以下是打印结果：

1 2 3 4
5 6 7
8 9 10 11 12

循环是非常强大的语法特性，不仅仅可以重复单一任务，还能帮助我们更方便地遍历数组。

break, continue

在循环中，有两个很重要的关键词我们需要掌握。一个是break，另一个是continue。break可以用在switch语句中，也可以用在循环中，用来跳出整个循环语句块，如果是多层循环语句嵌套的时候，break跳出的就是最里层的循环，跳出后继续执行下面的语句。来看一个例子：

int[] nums = new int[]{3, 7, 4, 2, 9, 13, 22};
for(int x: nums) {
    if(x >= 10) {
        break;
    }
    System.out.print(x + " ");
}

在这个循环块中，只要 x 大于等于10，整个循环语句就结束，所以以下就是打印的结果：

3 7 4 2 9

continue用于循环语句，作用是让当前循环块结束，然后跳转到下一次循环的迭代。在 for 循环中，continue会让程序跳转到下一个循环判断语句，在while中也是如此。来看一个例子：

for(int i = 0; i <= 10; i++) {
    if(i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

在这个例子中，只要 i 能够被2整除那么就跳到下一个循环，不然打印出 i，所以这个程序会把 0 ~ 10 之间的奇数全部打印出来。

再来看一个将break和continue结合的例子：程序提示用户不断输入数值，只要输入的是偶数，程序就会将数值相加，并打印出当前所输入偶数相加的结果。否则程序就提醒用户是否要继续，如果用户输入n，那么循环终止，打印出输入偶数之和：

Scanner scanner = new Scanner(System.in);
int sum = 0;
while(true) {
    System.out.print("Please enter a number: ");
    int num = scanner.nextInt();
    if (num % 2 == 0) {
        sum += num;
        System.out.println("sum = " + sum);
        continue;
    }
    scanner.nextLine();
    System.out.print("Do you want to continue?(Y/N): ");
    String response = scanner.nextLine();
    if(response.toLowerCase().charAt(0) == 'n') {
        break;
    }
}
System.out.println("Total sum = " + sum);

实践练习

请创建一个永久循环，在循环中，提示用户输入两个数字，并打印出两个数字区间内的所有奇数。如果用户输入1和5，就打印出1，3，5。如果用户输入的第一个数字大于第二个数字，就结束循环。