JavaSE之流程控制结构

流程控制语句结构

一、顺序结构

public static void main(String[] args){
    //顺序执行，根据编写的顺序，从上到下运行
    System.out.println(1);
    System.out.println(2);
    System.out.println(3);
}

二、复合语句

Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“{”开始，闭括号“}”结束。
复合语句中的每一语句都是从上到下执行。复合语句以整个块为单位，并且在复合语句中可以嵌套复合语句。

class 类{
                 {       
                       //代码块
                 }
                方法签名{
                         //方法体
                 }
                内部类{
                       内部类体
                 }
         }

复合语句为变量创建了一个作用域。在该作用域中某个变量被创建并能够使用，如果在某个变量的作用域外使用该变量，则会发生错误。

三、分支结构

1、条件判断（if...else）

1.每个if或者else后面的{}不是必须的，但是如果没有{}，默认只能带一条语句。即if或else后面的语句块只有一条语句时，可以省略{}，但是可读性不够好。

2.最后的else不是必须的，可以缺省

3.当多个条件是互斥关系时，顺序无所谓

4.当多个条件是包含关系时，“小上大下/子上父下”

2、选择结构（switch...case）

1. 语法格式

switch(表达式){
         case 常量值1:
                   语句块1;
                   break;
         case 常量值2:
                   语句块2;
                   break;
         case 常量值3:
                   语句块3;
                   break;              
         ....
         default：
                   语句块n+1;
                    break;      
}

说明：

default的分支，可以在任意位置，只是习惯上我们写在最后，但是不管在哪里，都是先判断case的值，然后再去看default。

1. 执行特点

要求：

（1）case后面必须是常量

（2）case后面的常量值不能重复

（3）case后面的常量值必须与switch(表达式)的类型一致或兼容

（4）switch(表达式)的类型只能是如下几种类型

         四种基本数据类型：byte,short,int,char

         两种引用数据类型：JDK1.5枚举，JDK1.7String

1. 代码实现

/*
12      * default不是必须的，也可以不写
13      * 输出：case two
14      */
15     private static void defautTest() {
16         char ch = 'A';
17         switch (ch) {
18         case 'B':
19             System.out.println("case one");
20             break;
21         case 'A':
22             System.out.println("case two");
23             break;
24         case 'C':
25             System.out.println("case three");
26             break;
27         }
28     }
29
30     /*
31      * case语句中少写了break，编译不会报错
32      *     但是会一直执行之后所有case条件下的语句，并不再进行判断，直到default语句
33      *     下面的代码输出： case two
34      *                   case three
35      */
36     private static void breakTest() {
37         char ch = 'A';
38         switch (ch) {
39         case 'B':
40             System.out.println("case one");
41
42         case 'A':
43             System.out.println("case two");
44
45         case 'C':
46             System.out.println("case three");
47         default:
48             break;
49         }
50     }
51
52     /**
		*switch用于判断String类型
54      *     输出：It's OK!
55      */
56     private static void stringTest() {
57         String string = new String("hello");
58         switch (string) {
59         case "hello":
60             System.out.println("It's OK!");
61             break;
62
63         default:
64             System.out.println("ERROR!");
65             break;
66         }
67     }

四、循环结构

1、for循环

1. for循环第一种格式

	for(初始化语句①; 循环条件语句②; 迭代语句④){
    循环体语句③
	}

注意：

（1）循环条件必须是boolean类型

（2）如果循环条件语句②省略的话，就默认为循环条件成立

1. for循环第二种格式
   
   for（int i:a）解释是：先设置一个与a数组里的元素相同的变量，这个变量先等于a数组的第一个元素，然后进入循环体，第二次循环就等于a数组的第二个元素，进入循环体，以此类推。

		int[][] dirc = {{1,0},{0,1},{-1,0},{0,-1}};
        int lengthI = dirc.length;
        int lengthJ = dirc[0].length;
        System.out.println(lengthI); // 4
        System.out.println(lengthJ); // 2
        for (int[] dire: dirc) {
            int length = dire.length; // 每次从dirc[][]中取出一行元素放入dire[]中，因此length为dirc[][]的dirc.length
            							// dire[i] = dirc[i][]
            System.out.println(length); // 2
        }

2、while循环

1. while循环语句标准格式：

while (循环条件语句①) {
    循环体语句②；
}

1. while循环语句扩展格式：

初始化语句①；
while (循环条件语句②) {
    循环体语句③；
    迭代语句④；
}

do...while循环

1. do...while循环标准格式：

do {
    循环体语句①；
} while (循环条件语句②)；

1. do...while循环扩展格式：

初始化语句①
do {
    循环体语句②；
    迭代语句③；
} while (循环条件语句④)；

1. 注意：

（1）while(循环条件)中循环条件必须是boolean类型

（2）do{}while();最后有一个分号

（3）do...while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int positive = 0;
        int nagetive = 0;
        int num;
		// 注意，num = in.nextInt();不可定义在初始语句，会造成死循环
        do {
            System.out.println("请输入整数（0）结束：");
            num = in.nextInt();
            if (num > 0) {
                positive++;
            } else if (num < 0) {
                nagetive++;
            }
        } while (num != 0);
        System.out.println(positive);
        System.out.println(nagetive);
    }

4、循环语句的区别

1. 从循环次数角度分析：

do...while循环至少执行一次循环体语句

for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句

1. 从循环变量的生命周期角度分析

for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；

while和do...while循环的循环变量因为在外面声明的，所以while和do...while结束后可以被继续使用的；

1. 如何选择

遍历有明显的循环次数（范围）的需求，选择for循环

遍历没有明显的循环次数（范围）的需求，循环while循环

本质上：三种循环之间是可以互相转换的，都能实现循环的功能

1. 三种循环结构都具有四要素：

（1）循环变量的初始化表达式

（2）循环条件

（3）循环变量的修改的迭代表达式

（4）循环体语句块

5、控制语句区别

1. break

break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统将完全结束循环，开始执行循环之后的代码。 break不仅可以结束其所在的循环，还可结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标识一个外层循环。Java中的标签就是一个紧跟着英文冒号（:）的标识符。且它必须放在循环语句之前才有作用。

public static void main(String[] args) {
		// 外层循环，outer作为标识符
        outer:
        for (int i = 0; i < 2; i++) {
            System.out.println("外层循环第：" + i);
            for (int j = 0; j < 3; j++) {
                System.out.println("内层循环第：" + j);
                // 跳出outer标签所标识的循环
                break outer;
            }
        }
    }
    // 外层循环第：0
	// 内层循环第：0

1. continue

continue的功能和break有点类似，区别是continue只是中止本次循环，接着开始下一次循环。而break则是完全中止循环。

public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {
            System.out.println("循环第：" + i);
            if (i == 1){
　　　　　　　　　// 忽略本次循环的剩下语句
　　　　　　　　　continue;
　　　　　　　}
        }
    }
    // 循环第：0
	// 循环第：2
	// 循环第：3

1. return

return关键字并不是专门用于跳出循环的，return的功能是结束一个方法。 一旦在循环体内执行到一个return语句，return语句将会结束该方法，循环自然也随之结束。与continue和break不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

public static void main(String[] args){
　　　　// 一个简单的for循环
　　　　for (int i = 0; i < 3 ; i++ ){
　　　　　　System.out.println("i的值是" + i);
　　　　　　if (i == 1){
　　　　　　　　return;
　　　　　　}
　　　　　　System.out.println("return后的输出语句");
　　　　}
　　}
　　// i的值是0
	// return后的输出语句
	// i的值是1

部分内容参考：原文链接：https://blog.csdn.net/weixin_41043145/article/details/93780940