第二章 程序逻辑控制

第二章 程序逻辑控制

2.1 程序逻辑

顺序结构

程序自上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾

选择(分支)结构

选择（分支）结构是根据判断条件的成立与否再决定要执行哪些语句的一种结构，

循环结构

选择（分支）结构是根据判断条件的成立与否再决定要执行哪些语句的一种结构，2.

2.2 分支结构

分支结构主要是根据布尔表达式的判断结果来决定是否去执行某段程序代码，在Java中，一共提供有两类分支结构：if分支结构和switch开关语句。

2.2.1 if分支结构

if分支结构主要是针对于逻辑运算的处理结果来判断是否执行某段代码，在Java中可以使用if与else两个关键字实现此类结构，一共有以下3种组合形式。

if 判断	if…else 判断	多条件判断
if (布尔表达式) { 条件满足时执行; }	if (布尔表达式) { 条件满足时执行; } else{ 条件不满足时执行; }	if (布尔表达式) { 条件满足时执行; } else if (布尔表达式){ 条件满足时执行; } else if (布尔表达式){ 条件满足时执行; }[else { 条件不满足时执行; }]

使用if语句结构

public class JavaDemo {
    public static void main(String[] args) {
        int age = 20;
        if (age >= 18 && age <= 22) {
            System.out.println("我是大学生");
        }
        System.out.println("开始");
    }
}

使用if…else…语句结构

public class JavaDemo {
    public static void main(String[] args) {
        double money = 20.00;
        if (money >= 19.8) {
            System.out.println("钱够了");
        } else {
            System.out.println("钱不够");
        }
        System.out.println("......");
    }
}

多条件判断

public class JavaDemo {
    public static void main(String[] args) {
        double score = 90.00;
        if (score >= 90.00 && score <= 100) {
            System.out.println("优等生");
        } else if (score >= 60 && score < 90) {
            System.out.println("良等生");
        } else {
            System.out.println("差等生");
        }
    }
}

2.2.2 switch开关语句

switch是一个开关语句，它主要根据内容进行判断。需要注意的是，switch语句只能判断数据（int、char、枚举、String），而不能使用布尔表达式进行判断。

switch语法格式如下：

switch(整数 | 字符 | 枚举 | String) {
	case内容 : {
		内容满足时执行;
		[break;]
	}
	case内容: {
		内容满足时执行;
		[break;]
	}
	case内容: {
		内容满足时执行;
		[break;]
	} ...
	[default: {
		内容不满足时执行;
		[break;]
	}]
}

注意：if可以判断布尔表达式，而switch只能够判断内容。

在每一个case里面出现的break语句，表示的是停止case的执行，因为switch语句默认情况下会从第一个满足的case语句开始执行全部的语句代码，一直到整个switch执行完毕或者遇见了break语句。

使用switch语句

public class JavaDemo {
    public static void main(String[] args) {
        int ch = 1;
        switch (ch) {
            case 2:
                System.out.println("www.baidu.com");
            case 1: {
                System.out.println("www.taobao.com");
            }
            default: {
                System.out.println("百度");
            }
        }
    }
}

本程序只使用了switch语句，由于没有在每一个case语句中定义break，所以会在第一个满足条件处一直执行，直到switch执行完毕。如果现在不希望影响到其他的case语句执行，则可以在每一个case语句中使用break。

使用break语句中断其余case执行

public class JavaDemo {
    public static void main(String[] args) {
        int ch = 1;
        switch (ch) {
            case 2:
                System.out.println("www.baidu.com");
                break;
            case 1: {
                System.out.println("www.taobao.com");
                break;
            }
            default: {
                System.out.println("百度");
                break;
            }
        }
    }
}

本程序由于在case语句里面定义了break语句，所以执行时将不会执行其他的case语句内容。另外，需要注意的是，从JDK 1.7开始，switch语句支持了对String类型内容的判断。

使用switch判断字符串内容

public class JavaDemo {
    public static void main(String[] args) {
       String str = "www";
       switch (str) {
           case "www" : {
               System.out.println("www.baidu.com");
               break;
           }
           case "http": {
               System.out.println("http://www.taobao.com");
               break;
           }
           default: {
               System.out.println("ssss");
           }
       }
    }
}

本程序使用了switch语句判断字符串的内容，需要注意的是，该判断会区分大小写，即只有大小写完全匹配后才会执行相应的case语句。

2.3 循环结构

循环结构的主要特点是可以根据某些判断条件来重复执行某段程序代码的处理结构，Java语言的循环结构一共分为两种类型：while循环结构和for循环结构。

2.3.1 while循环结构

while循环是一种较为常见的循环结构，利用while语句可以实现循环条件的判断，当判断条件满足时则执行循环体的内容，Java中while循环结构有以下两类。

while 循环	do … while 循环
while (循环判断) { 循环语句; 修改循环结束条件; }	do { 循环语句; 修改循环结束条件; } while (循环判断);

通过两类语法结构可以发现，while循环需要先判断循环条件后才可以执行程序代码，do…while循环可以先执行一次循环体，而后再进行后续循环的判断。所以如果循环条件都不满足的情况下，do…while至少执行一次，而while一次都不会执行。

所有的循环语句里面都必须有循环的初始化条件。每次循环的时候都要去修改这个条件，以判断循环是否结束。

范例：使用while循环实现1~100数字累加

public class JavaDemo {
    public static void main(String[] args) {
        int i = 1;
        int count = 0;
        while (i <= 100) {
            count += i;
            i++;
        }
        System.out.println(count);
    }
}

范例：使用do…while循环实现1~100数字累加

public class JavaDemo {
    public static void main(String[] args) {
        int i = 1;
        int count = 0;
        do {
            count += i;
            i++;
        }while (i <= 100);
        System.out.println(count);
    }
}

2.3.2 for循环结构

在明确知道了循环次数的情况下，可以利用for循环结构来实现循环控制，for循环的语法如下。

for (循环初始条件; 循环判断; 循环条件变更) {
	循环语句;
}

例子：使用for循环实现1~100累加

public class JavaDemo {
    public static void main(String[] args) {
      int sum = 0;
      for (int i = 1; i <= 100; i++) {
          sum += i;
      }
        System.out.println(sum);
    }
}

循环使用条件：

• while循环：在不确定循环次数，但是确定循环结束条件的情况下使用。
• for循环：在确定循环次数的情况下使用。

3.3.3 循环控制语句

在循环结构中只要循环条件满足，循环体的代码就会一直执行，但是在程序之中也提供有两个循环停止的控制语句：continue（退出本次循环）、break（退出整个循环）。循环控制语句在使用时往往要结合分支语句进行判断。

范例：使用continue控制循环

public class JavaDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 10; x++) {
            if (x == 3) {
                continue;
            }
            System.out.print(x + "、");
        }
    }
}
输出结果：
0、1、2、4、5、6、7、8、9

此时的程序中使用了continue语句，而结果中可以发现缺少了3的内容打印，这是因为使用了continue语句，当x=3时结束当次循环，而直接进行下一次循环的操作。

范例：使用break控制循环

public class JavaDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 10; x++) {
            if (x == 3) {
                break;
            }
            System.out.print(x + "、");
        }
    }
}
输出结果：
0、1、2

本程序在for循环中使用了一个分支语句（x==3）判断是否需要结束循环，而通过运行结果也可以发现，当x的内容为3后，循环不再执行了。

3.3.4 循环嵌套

循环结构可以在内部嵌入若干个子的循环结构，这样可以实现更加复杂的循环控制结构，但是需要注意的是，这类循环结构有可能会导致程序复杂度的提升。

范例：打印乘法口诀表

public class JavaDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 9; x++) {
            for (int y = 0; y < x; y++) {
                System.out.print(y + "*" + x + "=" + (x*y) + "\t");
            }
            System.out.println();
        }
    }
}

本程序使用了两层循环控制输出，其中第一层循环是控制输出行和乘法口诀表中左边的数字（7 * 3=21，x控制的是数字7，而y控制的是数字3），而另外一层循环是控制输出列，并且为了防止不出现重复数据（例如，“1 * 2”和“2 * 1”计算结果重复），让y每次的循环次数受到x的限制，每次里面的循环执行完毕后就输出一个换行。

范例：打印三角形

public class JavaDemo {
    public static void main(String[] args) {
        int line = 5;
        for (int i = 0; i < line; i++) {
            for (int y = 0; y < line - i; y++) {
                System.out.print(" ");
            }
            for (int y = 0; y <= i; y++) {
                System.out.print("* ");
            }
            System.out.println();

        }
    }
}

在本程序中利用外层for循环进行了三角形行数的控制，并且在每行输出完毕后都会输出换行，在内层for循环进行了“空格”与“”的输出，随着输出行数的增加，“空格”数量逐步减少，而“”数量逐步增加。

提示：关于continue与循环嵌套的使用问题。

范例：使用continue进行跳出处理

public class JavaDemo {
    public static void main(String[] args) {
        point: for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                if ( x == y) {
                    continue point;
                }
                System.out.print(x + "、");
            }
            System.out.println();
        }
    }
}