程序流程控制

程序流程控制

一.顺序结构

概念

程序从上到下逐行地执行，中间没有任何判断和跳转。

二.分支结构

概念

• 根据条件，选择性地执行某段代码。

• 有if…else和switch两种分支语句。

分支机构1：if语句

三种格式

1. if (条件表达式) {

执行代码块；

}

2. if (条件表达式) {

执行代码块；

  } else {

执行代码块；

}

3. if (条件表达式1) {

    执行代码块1；
​
 } else if (条件表达式2) {

执行代码块2；

} else if (条件表达式3) {

    执行代码块3；
​
  }
​
 …… else {
​
    执行代码块n；

}

if-else语句应用实例

if (布尔条件) {
​
•   语句块; // 如果布尔条件 为true, 才执行此语句块.
​
}
​
```java
class IfTest5 {
    
    public static void main(String[] args) {
        int n = 5;
        
        if (n == 1) {0
            System.out.println("n == 1"); 
        } else if (n == 5) { // 入口条件 , 先外后内
            System.out.println("n == 5");
            if (n >= 2) { // 进一步条件
                System.out.println("n >= 2"); // 如果入口条件 和 进一步条件  都为true才执行.
            } 
        } else if (n == 3) {
            System.out.println("n == 3");
        } else if (n == 10) {
            System.out.println("n == 10");
        } else {
            System.out.println("else");
        }
        
        System.out.println("after if else if else.....");
    }
}
​
class IfTest4 {
    
    public static void main(String[] args) {
        int n = 5;
        
        if (n == 1) {
            System.out.println("n == 1"); 
        } else if (n == 5) {
            System.out.println("n == 5");
        } else if (n >= 2) {
            System.out.println("n >= 2");
        } else if (n == 3) {
            System.out.println("n == 3");
        } else if (n == 10) {
            System.out.println("n == 10");
        } else {
            System.out.println("else");
        }
        
        System.out.println("after if else if else.....");
    }
}
​
class IfTest3 {
    
    public static void main(String[] args) {
        /*
        // 多选1, 条件布尔的顺序性也非常重要, 把更看重的条件的往前放.
        if (布尔条件1) {
            语句块1; // 如果条件1为true执行
        } else if (布尔条件2) {
            语句块2; // 如果条件1为false并且布尔条件2为true时执行
        } else if (布尔条件3) {
            语句块3; // 如果条件1为false,并且条件2也为false,并且条件3为true
        } .... {
            
        } else if (布尔条件n...) {
            语句块n;;前面的所有条件 都为false, 并且条件 n为true时执行
        } else {
            语句块m; 前面的所有的所有条件都为false. 防止逻辑漏洞.
        }
        多个语句块之间互斥
        */
        int n = 20;
        
        if (n == 1) {
            System.out.println("n == 1"); 
        } else if (n == 2) {
            System.out.println("n == 2");
        } else if (n == 3) {
            System.out.println("n == 3");
        } else if (n == 5) {
            System.out.println("n == 5");
        } else if (n == 10) {
            System.out.println("n == 10");
        } else {
            System.out.println("else");
        }
        
        System.out.println("after if else if else.....");
    }
}
​
class IfTest2 {
    
    public static void main(String[] args) {
/*
if (布尔表达式) {
语句块1; // 如果布尔表达式为true时执行.
} else { 
语句块2; // 如果布尔表达式为false时执行
}
语句块1和语句块2是互斥关系 .
*/
int n = 20;

if (n == 10) {
System.out.println("n == 10");
    } else {
System.out.println("else");
    }

// 无条件执行语句
System.out.println("after if else");
    }
}
​
public class IfTest {

public static void main(String[] args) {
/*
if (布尔表达式) {
语句块;
}
*/
int n = 20;

// 有条件执行
if (n == 10) {
System.out.println("n == 10"); // 有条件.
    }

// 无条件执行语句 
System.out.println("after if");
    }
}
```
​
​

判断:

1. if else if else if else 语句中, 如果同时有多个条件都为true, 那么将会有多个语句块被执行

2. switch case case default 语句中, 如果同时有多个条件都为true, 那么将会有多个语句块被执行

1) 不对, 只有最上面的为true的块才能执行.

2) case 后面的常量 不可以重复. 不可能有多个条件都为true

分支结构2：switch语句

格式

switch(变量){

case 常量1:

语句1;

break;

case 常量2:

语句2;

    break;

… …

case 常量N:

语句N;

break;

default:

语句;

break;

}

switch语句语句有关规则

• switch(表达式)中表达式的返回值必须是下述几种类型之一：byte，short，char，int（非long整型），String, 枚举；

• case子句中的值必须是常量，且所有case子句中的值应是不同的；

• default子句是可任选的，当没有匹配的case时，执行default

• break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到后面第一个break语句或直接执行到switch结尾(这种现象称为穿透)

switch语句实例

class SwitchTest2 {
    
    public static void main(String[] args) {
        // 如果没有break语句, 一旦某个case进入, 会导致后面的case不起作用, 相当于无条件的执行所有case中的语句都要执行
        // 如果在执行中又遇到了break, 也会中断.
        
        // fall through, 称为穿透, 这样的分支就是复杂分支...
        // 如果完全没有break, 它就不是分支, 但是如果还有一些break, 它也是分支.
        int n = Integer.parseInt(args[0]);
        switch (n) {
            case 1 :
                System.out.println("n == 1");
                //break;
            case 2 :
                System.out.println("n == 2");
                //break;
            case 3 :
                System.out.println("n == 3");
                break;
            case 5 :
                System.out.println("n == 5");
                //break;
            case 10 :
                System.out.println("n == 10");
                break;
            default :
                System.out.println("else");
                //break;
        }
    }
}
​
public class SwitchTest {
    
    public static void main(String[] args) {
        /*
        int n = 2;
        
        if (n == 1) {
            System.out.println("n == 1"); 
        } else if (n == 2) {
            System.out.println("n == 2");
        } else if (n == 3) {
            System.out.println("n == 3");
        } else if (n == 5) {
            System.out.println("n == 5");
        } else if (n == 10) {
            System.out.println("n == 10");
        } else {
            System.out.println("else");
        }
        */
        int n = 3;
        switch (n) {
            case 1 :
                System.out.println("n == 1");
                break;
            case 2 :
                System.out.println("n == 2");
                break;
            //case 2 :
            //  System.out.println("n == 2.... 2");
            //  break;
            case 3 :
                System.out.println("n == 3");
                break;
            case 5 :
                System.out.println("n == 5");
                break;
            case 10 :
                System.out.println("n == 10");
                break;
            default :
                System.out.println("else");
                break;
        }
        /* switch用于某个变量的等值判断.
        内在逻辑 就是对变量的值的可能性进行列举或穷举.
        switch (变量) { 括号中必须是变量. 数据类型是 非long整数, String, 枚举.
            case 常量1 :  // if (变量 == 常量1)
                语句块1;
                break; // break的作用是中断switch结构, 结束它.
            case 常量2 : // else if (变量 == 常量2)
                语句块2;
                break;
            case 常量3 : 
                语句块3;
                break;
            case ....
            default : 
                语句块n;
        }
        switch 括号中必须是变量
case 后面必须跟常量, 100, 200, 'a', 字面量和被final修饰的量.
case 标签值不可以重复. 原因是它要生成goto语句会出问题.
*/
    }
}

 

三.循环结构

概念

• 根据循环条件，重复性的执行某段代码。

• 有while、do…while、for三种循环语句。

• 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

功能

在条件满足的情况下，反复执行特定代码的功能

组成成分

• 初始化部分（init_statement）

• 循环条件部分（test_exp）

• 循环体部分（body_statement）

• 迭代部分（alter_statement）

while 循环语句

语法格式

[初始化语句]

while( 布尔值测试表达式)｛

语句或语句块;

         [更改语句;]

}

应用举例

public class LoopTest {
    
    public static void main(String[] args) {
        /*
        循环初始化语句 
        while (循环条件) {
            循环体;
            迭代语句;
        }
        */
        int result = 0; // 不是初始化语句
        
        int i = 1; // i在循环中称为循环因子. 它是初始化语句 
// 循环次数 : 条件右面的值-初始值, 如果有=, 再加1 
        while (i <= 5) { // 循环条件
            result += i; // 循环体 
            i++; // 迭代语句 
        }
        System.out.println("result : " + result);
        System.out.println("i : " + i);
    }
}

死循环、无限循环

class LoopTest7 {
	
	public static void main(String[] args) {
		/*
		while (true) { // 死循环
			System.out.println("helllo");
		}*/
		boolean flag = true;
		while (flag) { // 无限循环
			System.out.println("hello");
			// ..... 
		}
		System.out.println("after while...");
	}
}

class DeadLoopTest {
	
	public static void main(String[] args) {
		boolean flag = true;
		//while (true) {} 这是死循环
		//while (flag) {} 这是无限循环
		//while (1 != 2) {} 这是死循环
		//do {} while (true);这是死循环
		//do {} while (flag); //这是无限循环
		//for (;;) {} // for循环的死循环写法
		//for (int i = 0; true; i++) {} // for循环的死循环写法
		//for (int i = 0; i < 10;) {} // 不是死循环
		//for (int i = 0; i < 10; i--) {} 是有限循环.
		//for (int i = 0; ; i++) {} 是死循环
		
		System.out.println("after loop"); 
	}
}

 

do-while 循环语句

语法格式

[初始化语句]

do｛

语句或语句块;

  [更改语句;]

｝while(布尔值测试表达式);

应用举例

class LoopTest4 {
	
	public static void main(String[] args) {
		/*
		初始化语句 
		do {
			循环体;
			迭代语句;
		} while (循环条件);
		*/
		int result = 0;
		int i = 1;
		do {
			result += i;
			i++;
		} while (i <= 5);
		
		System.out.println("result : " + result);
		System.out.println("i : " + i);
	}
}

class LoopTest6 {
	
	public static void main(String[] args) {
		int n = Integer.parseInt(args[0]); // 控制循环次数的变量
		
		int result = 0; // 求和的变量
		int i = 0; // 循环因子
		int count = 0; // 计数器
		do {
			result += i;
			count++;
			
			i++;
		} while (i < n); // 循环次数 : 条件右面的值
		
		System.out.println("result : " + result);
		System.out.println("i : " + i);
		System.out.println("count : " + count);
	}
}

 

for 循环语句

语法格式

for (初始化表达式①; 布尔值测试表达式②⑤⑦; 更改表达式)｛

语句或语句块③⑥ ；

｝

 

 

应用举例

class LoopTest8 {
	
	public static void main(String[] args) {
		/*
		for (初始化语句A; 循环条件B; 迭代语句C) {
			循环体D;
		}
		A B D C B D C B D C B D .... C B D... B 
		迭代语句C, 是每次循环的开始!!!! begin
		*/
		int result = 0;
		for (int i = 1; i <= 5; i++) {
			result += i;
		}
		System.out.println("result : " + result);
	}
}

class LoopTest9 {
	
	public static void main(String[] args) {
		int result = 0;
		//i = 3;
		// 循环因子的声明最好放在for中. 
		for (int i = 1; i <= 5; i++) { // 循环次数 : 条件右面的值-初始值,如果有=再加1 
			result += i;
		}
		System.out.println("result : " + result);
		//System.out.println("i : " + i); // 找不到符号? 不打印了
		
	}
}

 

过滤

class LoopTest11 {
	
	public static void main(String[] args) {
		// 求100以内所有的能被7整除的数的平均值
		int sum = 0; // 求和 
		int count = 0;
		for (int i = 0; i < 100; i++) {
			if (i % 7 == 0) { // 筛选过滤
				System.out.println("i : " + i); // 有条件执行语句
				sum += i; // 有条件的求和
				count++; // 有条件计数!!!
			}
		}
		System.out.println("sum : " + sum);
		System.out.println("count : " + count);
		int avg = sum / count;
		System.out.println("avg : " + avg);
	}
}

 

嵌套

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。

• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

class LoopTest12 {
	
	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) { // 外循环
			for (int j = 0; j < 3; j++) { // 内循环
				System.out.println("j : " + j); // 执行次数 : 外循环次数*内循环次数
			}
			System.out.println("i : " + i); // 执行次数 : 外循环次数
		}
	}
}

class LoopTest13 {
	
	public static void main(String[] args) {
		for (int i = 0; i < 15; i++) { // 外循环 : 控制行数
			for (int j = 0; j < 9; j++) { // 内循环 : 控制列数
				System.out.print("j : " + j + "          "); // print语句没有换行效果, 就在一行打印
			}
			System.out.println(); // 输出一个纯换行 
		}
	}
}

class LoopTest14 {
	
	public static void main(String[] args) {
		int n = Integer.parseInt(args[0]); //控制它为n行
		int m = Integer.parseInt(args[1]); //控制它为m列
		for (int i = 0; i < n; i++) { // 外循环 : 控制行数
			for (int j = 0; j < m; j++) { // 内循环 : 控制列数
				System.out.print("j : " + j + "    "); // print语句没有换行效果, 就在一行打印
			}
			System.out.println(); // 输出一个纯换行 
		}
	}
}

 

内循环次数 和外循环关系

y = kx + b; // k是斜率, 如果k是正数, 内循环次数会越来越多, 如果k是负数, 内循环次数越来越少

class LoopTest16 {
	
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < -2 * i + 20; j++) { // -2 * i + 20 ,  斜率是-2, 是负数, 下降趋势
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

class LoopTest15 {
	
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 2 * i + 3; j++) { // 2 * i + 3, 斜率是2, 是正数, 是上升趋势
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

 

while 循环适用于循环次数不确定的循环, 结束取决于外部条件. for 循环适用于循环次数确定的循环.

循环进阶：质数处理

基本语句

public class LoopTest {
	
	public static void main(String[] args) {
		// 判断一个数n是否是质数
		int n = Integer.parseInt(args[0]); // 质数 : 只能被1和自身整除的数.
		boolean flag = true; // 假定n是质数
		// 从2 ~ n - 1 中任意找到一个反例就能推翻假设.
		for (int i = 2; i < n; i++) {
			if (n % i == 0) { // 如果n能被某个i整除了, 说明n不是质数
				flag = false; // 推翻假设
			}
		}
		
		if (flag) { // 如果flag为true, 说明在上面的循环中, if一直没有为true的情况. 就是没有反倒, 它就是质数
			System.out.println(n + "是质数");
		}
		
	}
}

多敲多练

class LoopTest2 {
	
	public static void main(String[] args) {
		// 列出100以内的所有质数
		for (int j = 2; j < 100; j++) {
			// 判断j是否是质数,  质数 : 只能被1和自身整除的数.
			boolean flag = true; // 假定j是质数
			// 从2 ~ j - 1 中任意找到一个反例就能推翻假设.
			for (int i = 2; i < j; i++) {
				if (j % i == 0) { // 如果j能被某个i整除了, 说明j不是质数
					flag = false; // 推翻假设
				}
			}
			
			if (flag) { // 如果flag为true, 说明在上面的循环中, if一直没有为true的情况. 就是没有反倒, 它就是质数
				System.out.println(j + "是质数");
			}
		}
	}
}

 

class LoopExer {
	
	public static void main(String[] args) {
		// 练习 : 列出100~200之间所有的质数. 要求, 必须加上注释.
		for (int i = 100; i < 200; i++) {
			// i就是100~200之间的所有数
			// 判断i是否是质数, 质数:只能被1和自身整除的数, 认证这个过程
			boolean flag = true; // 假定i是质数.
			// 它不一定是, 需要尝试推翻它, 从2~i-1中找反例
			for (int j = 2; j < i; j++) { // 这是推翻的过程
				// 如果i可以被某个j整除了, 说明i不是质数
				if (i % j == 0) {
					flag = false; // 推翻假设
				}
			}
			// 一定要在论证过程结束后出结论, 而且结论已经通过flag表达
			if (flag) {
				System.out.println(i + "是质数");
			}
		}
	}
}

break和continue型

//1. 1000以内的所有质数的平均值.(应用break), 扩展: 应用continue.
public class Homework01{
	public static void main(String[] args) {
		
		int primeTotal = 0;//变量质数总和初始值为零
		int count = 0;//计数器
		for(int i = 2;i < 1000; i ++) {//i是1000以内所有的整数,判断i是否为质数
			boolean flag = true;//假定i是质数，i不一定是，需要尝试推翻它
			for(int j = 2;j < i; j ++) {//推翻的过程
				if(i % j == 0){//如果i可以被某个j整除，说明i不是质数
					flag = false;//推翻假设
					break;//中断循环
				}
			}
			if(flag) {
				count ++;//每有一个质数，计数器加一
				primeTotal += i;//质数求和
			}
		}
			System.out.println("1000以内的所有质数的平均值" + (primeTotal / count));
	}
}

class Homework001{
	public static void main(String[] args) {
		
		int primeTotal = 0;//变量质数总和初始值为零
		int count = 0;//计数器
		l1: for(int i = 2;i < 1000; i ++) {//i是1000以内所有的整数,判断i是否为质数
			boolean flag = true;//假定i是质数，i不一定是，需要尝试推翻它
			for(int j = 2;j < i; j ++) {//推翻的过程
				if(i % j == 0){//如果i可以被某个j整除，说明i不是质数
					continue l1;//i不是质数, 制造意外, 并直接进行下一个数的判断
				}
			}
				count ++;//每有一个质数，计数器加一
				primeTotal += i;//质数求和
		}
			System.out.println("1000以内的所有质数的平均值" + (primeTotal / count));
	}
}
	

四.特殊流程控制语句

break语句

语法格式

break语句用于终止某个语句块的执行

{ ……

break;

……

}

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

label1: { ……

label2: { ……

label3: { ……

break label2;

……

}

}

}

应用实例

class LoopTest3 {
	
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			System.out.println("i : " + i);
			if (i == 3) {
				break; // 中断循环,
			}
		}
		System.out.println("after for ");
	}
}//循环进行了四次

class LoopTest4 {
	
	public static void main(String[] args) {
		l1 : for (int i = 0; i < 5; i++) {
			l2 : for (int j = 0; j < 3; j++) {
				System.out.println("j : " + j);
				if (j == 0) {
					//break; // 中断的是离我最近的循环, 称为就近原则.
					break l1; // 中断的是标签指示的循环
				}
			}
			System.out.println("i : " + i);
		}
	}
}

class LoopTest5 {
	
	public static void main(String[] args) {
		// 列出100以内的所有质数
		for (int i = 2; i < 100; i++) {
			boolean flag = true; // 假设是质数
			for (int j = 2; j < i; j++) { // 从2~i-1中找反例
				if (i % j == 0) {
					flag = false;
					break; // 只需要一个反例即可, 然后直接结束了论证过程
				}
			}
			if (flag) {
				System.out.println(i + "是质数");
			}
		}
	}
}

continue型

continue语句用于跳过某个循环语句块的一次执行

continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

class LoopTest7 {
	
	public static void main(String[] args) {
		l1 : for (int i = 0; i < 5; i++) {
			l2 : for (int j = 0; j < 3; j++) {
				if (j % 2 != 0) {
					//continue; // 中断的是离我最近的循环的当次循环, 直接进入离我最近的循环的下一次循环的开始, (就是j++)
					continue l1;// 中断的是标签指示的循环的当次循环, 直接进入标签指示的循环的下一次循环的开始, (就是i++)
				}
				System.out.println("j : " + j);
			}
			System.out.println("i : " + i);
		}
	}
}

class LoopTest8 {
	
	public static void main(String[] args) {
		// 列出100以内的所有质数
		l1 : for (int i = 2; i < 100; i++) {
			for (int j = 2; j < i; j++) {
				if (i % j == 0) {
					continue l1; // i不是质数, 制造意外, 并直接进行下一个数的判断
				}
			}
			System.out.println(i + "是质数");
		}
	}
}

break & continue 区别

/*
	break 是中断, 破坏的意思, 可以中断语句块的执行, 包括循环, 和 switch
	break 可以让循环提前结束. 破坏力度大, 像大事故!!!
	可以适用于switch和循环
	
	continue 是继续的意思 可以中断循环的某些次执行, 继续进入下一次(迭代语句 )
	continue 的中断力度小, 像小意外. 暗含的逻辑的本来应该执行的语句 , 因为一些小问题没执行成.
	只适用于循环.
	
	break和continue后面都不可以直接跟语句, 因为执行不到, 因为break, 会导致跳到循环外, continue会跳到迭代语句 .
	
	死循环 : 编译器发现后面如果有语句会出错.
	
*/

return型

• return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。

• 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

特殊流程控制语句说明

• break只能用于switch语句和循环语句中。

• continue 只能用于循环语句中。

• 二者功能类似，但continue是终止本次循环，break是终止本层循环。

• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

• 标号语句必须紧接在循环的头部。