Java基本语法2——程序流程控制

1. 流程控制语句：用来控制程序中各语句执行顺序的语句，可以把语句组合成能够完成一定功能的小逻辑模块。
2. 其流程控制方式采用结构化程序设计中规定的三种基本流程结构:

• 顺序结构
• 分支结构
• 循环结构
  

1. 顺序结构

按顺序执行，没啥说的。

2. 分支结构

2.1 if-else语句(条件判断结构)

三种结构
第一种：无
第二种：二选一

第三种：多选一

if-else使用说明

举例1：结构1
int heartBeats = 80;
if ( heartBeats< 60 || heartBeats > 100){
    
    
	System.out.println("还需再做进一步检查")；
} 
	System.out.println("检查结束！");
	
举例2：结构2
int age =23;
	if ( age < 18){
    
    
	System.out,println("你还是个孩子");
}else{
    
    
	System.out.println("你是成年人了");
}

举例3：结构3
int age =23;
	if (age < 0){
    
    
System.out.println("非法输入");
}else if ( age < 18){
    
    
	System.out,println("你还是个孩子");
}else if ( age < 60){
    
    
	System.out,println("你是中年人了");
}else{
    
    
	System.out.println("你是老年人了");
}

练习：

输出三个数中的最大值！
法一：三元运算符
class MaxTest{
    
    
	public static void main(String[] args){
    
    
	int num1 = 29,num2 = 23,num3 =-20,max1,max2;
	max1=(num1 > num2)?num1 : num2;
	max2 = (max1 > num3)? max1 : num3;
	System.out.println(max2);
	}
}

法二：if-else语句
class MaxTest{
    
    
	public static void main(String[] args){
    
    
	int num1 = 29,num2 = 23,num3 =-20;
		if(num1 >= num2 && num1 >= num3){
    
    
			System.out.println(num1);
		}else if(num2 >= num1 && num2 >= num3){
    
    
		System.out.println(num2);
		}else if(num3 >= num1 && num3 >= num2){
    
    
		System.out.println(num3);
		}
	}
}
2、声明两个double型变量并赋值，判断第一个数大于10.0，
且第二个数小于20.0，打印两数之和，否则，打印两数之差。
class MaxTest{
    
    
	public static void main(String[] args){
    
    
		double d1 = 13.8,d2 = 20.3;
		if(d1 > 10.0 && d2 < 20.0){
    
    
			System.out.println(d1 + d2);
		}else {
    
    
			System.out.println(d1 - d2);
		}
	}
}

如何从键盘获取不同类型的变量：需要使用 Scanner 类
具体实现步骤：

 1. 导包：import java.util.Scanner;
 2. Scanner的实例化：Scanner scan = new Scanner(System.in);
 3. 调用Scanner类的相关方法，来获取指定类型的变量
 4. 需要根据相应的方法，来输入指定类型的值，如果输入的数据类型与要求的
    数据类型不匹配时，会报异常：InputMismatchException，导致程序终止。


 //1. 导包：import java.util.Scanner;
import java.util.Scanner;
class ScannerTest{
    
    
	public static void main(String[] args){
    
    
	 //2. Scanner的实例化：Scanner scan = new Scanner(System.in);
		Scanner scan = new Scanner(System.in);
	 //3. 调用Scanner类的相关方法，来获取指定类型的变量
		System.out.println("请输入你的姓名:");
		String name = scan.next();
		System.out.println(name);
		
		System.out.println("请输入你的年龄:");
		int age = scan.nextInt();
		System.out.println(age);
		
		//对于char类型的获取，Scanner没有提供相关的方法，只能获取一个字符串
		System.our.println("请输入你的性别：（男/女）");
		string gender = scan.next();//"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
				
	}
}

练习：

说明：
 if-else可以嵌套使用
 如果if-else结构中的执行语句只有一行时，对应的一对{
    
    }可以省略，但不建议省略

1、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用if-else if-else)，并且从小到大输出。(嵌套)
import java.util.Scanner;
class IntTest{
    
    
	public static void main(String[] args){
    
    
	Scanner scan = new Scanner(System.in);
		System.out.println("请输入第一个整数：");
		int num1 = scan.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scan.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scan.nextInt();
		if(num1 >= num2){
    
    
			if(num3 >= num1){
    
    
			System.out.println(num2 + "," + num1 + "," + num3);
			}else if(num3 <= num2){
    
    
			System.out.println(num3 + "," + num2 + "," + num1);
			}else{
    
    
			System.out.println(num2 + "," + num3 + "," + num1);
			}
		}else{
    
    
		if(num3 >= num2){
    
    
			System.out.println(num1 + "," + num2 + "," + num3);
			}else if(num3 <= num1){
    
    
			System.out.println(num3 + "," + num1 + "," + num2);
			}else{
    
    
			System.out.println(num1 + "," + num3 + "," + num2);
			}
		
		}
	}
}

2、我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前2年每一年相当于人类的10.5岁，之后每增加一年就增加4岁，那么5岁的狗相当于人类多少年龄呢？应该是：10.5+10.5+4+4+4=33岁。编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄，如果用户输入负数，请提示错误。

import java.util.Scanner;
class DogAge{
    
    
	public static void main(String[] args){
    
    
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入狗的年龄:");
		double dogage = scan.nextDouble();
	
		if(dogage < 0){
    
    
		System.out.println("不合法的输入");
		}else if(dogage <= 2.0){
    
    
		System.out.println("你家狗狗的年龄相当于人类的" + dogage*10.5 + "岁了");
		}else{
    
    
		System.out.println("你家狗狗的年龄相当于人类的" + (2*10.5+(dogage-2)*4) + "岁了");
		}
	}
	
}

3、如何获取一个随机数：

int value = (int)(Math.random()*90 + 10);//[0.0,1.0)-->[10,99]
System.out.println(value);
//公式：[a,b]:(int)(Math.random()*(b-a+1) +a)

2.2 switch-case语句

说明：

• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句，当调用完执行语句后，仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构结束为止。
• break关键字可以使用在switch-case结构中，是可选的，一旦执行到此关键字，则跳出此switch-case结构。
• switch结构中的表达式只能是如下的六种数据类型之一：

1. byte
2. short
3. char
4. int
5. String类型(JDK 7.0新增)
6. 枚举类型( JDK 5.0新增)

• case之后只能声明常量，不能声明范围
• 如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
• default相当于if-else结构中的else，default也是可选的，而且位置是灵活的。

练习：
1、编写程序：对学生成绩大于60分的，输出“合格”，低于60分的，输出“不合格”。

import java.util.Scanner;
class Score{
    
    
	public static void main(String[] args){
    
    
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入学生成绩：");
		int score = scan.nextInt();
		//方法一
			switch(score/10){
    
    
			case 0:
			System.out.println("不及格");
			break;
			case 1:
			System.out.println("不及格");
			break;
			case 2:
			System.out.println("不及格");
			break;
			case 3:
			System.out.println("不及格");
			break;
			case 4:
			System.out.println("不及格");
			break;
			case 5:
			System.out.println("不及格");
			break;
			case 6:
			System.out.println("及格");
			break;
			case 7:
			System.out.println("及格");
			break;
			case 8:
			System.out.println("及格");
			break;
			case 9:
			System.out.println("及格");
			break;
			case 10:
			System.out.println("及格");
			}
	}
}
			//方法二：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
			switch(score/10){
    
    
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
			System.out.println("不及格");
			break;
			case 6:
			case 7:
			case 8:
			case 9:
			case 10:
			System.out.println("及格");
			}
			
			//方法三：
			switch(score/60){
    
    
			case 0:
			System.out.println("不及格");
			break;
			case 1:
			System.out.println("及格");
			}
	}
	
}

编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。

import java.util.Scanner;
class DateTest{
    
    
	public static void main(String[] args){
    
    
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入2019年的month：");
		int month = scan.nextInt();
		System.out.println("请输入2019年的day：");
		int day = scan.nextInt();
		int sumDays = 0;
		switch(month){
    
    
			case 12:
				sumDays += 30;
			case 11:
				sumDays += 31;
			case 10:
				sumDays += 30;
			case 9:
				sumDays += 31;
			case 8:
				sumDays +=  31;
			case 7:
				sumDays +=  30;
			case 6:
				sumDays +=  31;
			case 5:
				sumDays +=  30;
			case 4:
				sumDays +=  31;
			case 3:
				sumDays +=  28;
			case 2:
				sumDays +=  31;
			case 1:
				sumDays +=  day;
		}
		System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
	
}

3. 循环结构

循环结构：在某些条件满足的情况下，反复执行特定代码的功能。

• 循环语句分类：

1. for循环
2. while循环
3. do-while循环

• 循环语句的四个组成部分

1. 初始化
2. 循环条件 —>结果是boolean类型
3. 循环体
4. 迭代

for循环

 循环语句的四个组成部分
 1. 初始化
 2.  循环条件 --->结果是boolean类型
 3. 循环体
 4. 迭代
for循环的结构：
for（1;2;4）{
    
    
	3；
}
执行过程：1 - 2 - 3 - 4 - 2 - 3 - 4 - ..... -2   

练习一：
编写程序，在屏幕上输出5个hello world!
class ForTest{
    
    
	public static void main(String[] args){
    
    
		for(int i = 1 ; i <= 5 ; i++ ){
    
     //此处的i只在该for循环内有效，出了for循环就失效了。
		System.out.println("hello world!");
		}
}
}

练习二：
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
    
    
	System.out.print('b');
}
输出结果：abcbcbc

练习三：
遍历100以内的偶数
法一：
for(int i = 2;i <= 100; i+=2){
    
    
	System.out.print(i);
}
法二：
for(int i = 1;i <= 100; i++){
    
    
	if(i % 2 == 0)
	System.out.print(i);
}

练习四：
编写程序：从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出
“foo”，在每个5的倍数上打印“biz”，在每个7的倍数行上打印输出“baz”。
class ForTest4{
    
    
	public static void main(String[] args){
    
    
		for(int i = 1 ; i <= 150 ; i++ ){
    
    
			System.out.print(i + " ");
			if (i % 3 == 0)
				System.out.print("foo ");
			if (i % 5 == 0)
				System.out.print("biz ");
			if (i % 7 == 0)
				System.out.print("baz ");
			System.out.println();
		}
}
}

练习五：
编写程序：输入两个正整数m和n，求其最大公约数和最小公倍数。
import java.util.Scanner;
class ForTest5{
    
    
	public static void main(String[] args){
    
    
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入正整数m：");
		int m = scan.nextInt();
		System.out.println("请输入正整数n：");
		int n = scan.nextInt();
		//获取最大公约数
		//1.获取两个书中的较小值
		int min = (n >= m) ? m : n;
		//2.i从能取的最大值(m和n中的较小值)开始遍历,只要有一个满足条件的，即退出循环
		for(int i = min ; i >= 1 ; i-- ){
    
    
			if (m % i ==0 && n % i ==0){
    
    
			System.out.println("m和n的最大公约数为：" + i);	
			break;//一旦在循环中执行到break，就跳出循环
			}
		}
		//获取最小公倍数
		int max = (n >= m) ? n : m;
		for (int i = max ; i <= m * n ; i++){
    
    
			if (i % m == 0 && i % n ==0){
    
    
				System.out.println("m和n的最小公倍数为：" + i);	
				break;
				}	
		}
		}

}

while循环

循环语句的四个组成部分
 1. 初始化
 2.  循环条件 --->结果是boolean类型
 3. 循环体
 4. 迭代

while循环的结构：
1;
while(2){
    
    
3;
4;
}
执行过程：1 - 2 - 3 - 4 - 2 - 3 - 4 - ... -2  （与for循环相同） 

说明：写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环，
写程序要避免死循环，程序=算法+数据结构，算法的特点之一是有限性。
练习一：遍历100以内的所有偶数
class WhileTest1{
    
    
	public static void main(String[] args){
    
    
		int i = 1;
		while( i <= 100){
    
    
			if(i % 2 == 0){
    
    
			System.out.println(i);
			}
			i++;
		}
	}
}//while 循环的i定义在外面，出了循环以后仍然可以调用

说明：

• for循环和while循环可以相互转换
• 区别：for循环和while循环的初始化条件部分的作用范围不同（i的作用域不同）。

do-while循环

循环语句的四个组成部分
 1. 初始化
 2.  循环条件 --->结果是boolean类型
 3. 循环体
 4. 迭代

do-while循环的结构：
1;
do{
    
    
	3；
	4;
}while(2)

执行过程：1 -  3 - 4 - 2 - 3 - 4 - 2  ... -2   

练习：遍历100以内的偶数,并输出偶数的个数以及所有偶数的和
class DoWhileTest1{
    
    
	public static void main(String[] args){
    
    
		int i = 1,num = 0,sum = 0;
		do{
    
    
				if(i % 2 == 0){
    
    
					System.out.println(i);
					num++;
					sum += i;
				}
				i++;
		}while(i <= 100);
		System.out.println("偶数的个数为：" + num);
		System.out.println("所有偶数的和为：" + sum);
	}
}

说明：

• do-while至少会执行一次循环体
  练习：

题目：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，
输入为0时程序结束。
说明：
1.不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2.结束循环有两种方式：
	方式一：循环条件部分返回false
	方式二：在循环体中，执行break
	
import java.util.Scanner;
class Test{
    
    
	public static void main(String[] args){
    
    
		Scanner scan = new Scanner(System.in);
		int positive = 0 ;
		int negative = 0;
		while(true)//(for(;;)){
    
    
				System.out.println("请输入整数:");
				int num = scan.nextInt();
				if(num > 0){
    
    
					positive++ ;
				}else if(num < 0){
    
    
					negative++ ;
				}else(num == 0){
    
    
					break;
				}
		}
		System.out.println("正数个数为：" + positive);
		System.out.println("负数个数为：" + negative);
	}
}

嵌套循环

说明：

1. 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
2. 假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m*n次。

练习：

1.编写程序：输出4行6列的*，如下：
******
******
******
******

for(int j = 1;j <= 4; j++){
    
    
	for(int i=1;i <= 6; i++){
    
    
		System.out.println('*');
	}
	System.out.println();
}

2.编写程序，输出以下的图案：
*
**
***
****
*****
******

for(int j = 1;j <= 6; j++){
    
    
	for(int i = 1;i <= j; i++){
    
    
		System.out.println('*');
	}
	System.out.println();
}

3.输出9*9乘法表
1*1=1
2*1=2 2*2=4
。。。。。。

class NineNineTest{
    
    
	public static void main(String[] args){
    
    
		for(int j = 1;j <= 9; j++){
    
    
			for(int i = 1;i <= j; i++){
    
    
				System.out.print(i + "*" + j + "=" +  i*j + " ");
			}
			System.out.println();
			}
	}
}

4.输出100以内的所有质数。
质数：也即素数，只能被1和它本身整除的自然数。
class PrimeNumber{
    
    
	public static void main(String[] args){
    
    
		boolean isFlag = true;//标识i是否被n除尽，一旦除尽，修改其值
	
		for(int i = 2;i <= 100;i++){
    
    //遍历100以内的自然数
			//for(int n = 2; n <= Math.sqrt(i); n++)优化二：对本身是质数的自然数更有效，n<=i的开方
			for(int n = 2; n < i; n++){
    
    
				if(i % n == 0){
    
    
					isFlag = false;
					break;//优化一：只对非质数的自然数有效
				}else{
    
    
					break;
				}
				while(isFlage == true){
    
    
						System.out.println(i);
				}
				isFlag = true;//重置isFlag
			}
		}	
		}
}

break和continue关键字的使用

	break	continue
使用范围	switch-case，循环	循环
循环中使用时的作用	结束当前循环	结束当次循环
相同点	关键字后面不能声明执行语句	关键字后面不能声明执行语句

class BreakContinueTest1()
	public static void main(String[] args){
    
    
	for(int i = 1;i <= 10;i++){
    
    
		if(i % 4 == 0)
			break;//结果输出1 2 3，若此处为continue，结果输出1 2 3 5 6 7 9 10
			System.out.println("我今晚要去约会");//编译程序会报错
	}
	System.out.println(i +" ");
}	
嵌套循环中：
class BreakContinueTest2()
	public static void main(String[] args){
    
    
	for(int i = 1;i <= 4;i++){
    
    
		for(int j = 1; j<=10; j++){
    
    
			if(i % 4 == 0)
			break;//默认跳出包裹此关键字最近的一层循环，continue同理
		}
			System.out.println(j);
	}
}
若想要跳出外层循环，需要加标签，如下：
class BreakContinueTest3()
	public static void main(String[] args){
    
     
		label for(int i = 1;i <= 4;i++){
    
    
			for(int j = 1; j<=10; j++){
    
    
				if(j % 4 == 0)
				break label;//跳出带有标签的那层循环，continue同理
		}
		System.out.println(j);
	}
}

输出100以内所有的质数优解

class PrimeNumber{
    
    
	public static void main(String[] args){
    
    
		
		long start = System.currentTimeMillis();//获取当前时间距离1970-01-01 00:00:00的毫秒数
		label for(int i = 2;i <= 100;i++){
    
    //遍历100以内的自然数
			for(int n = 2; n <=Math.sqrt(i); n++){
    
    
				if(i % n == 0){
    
    
					continue label;
				}
			}
			System.out.println(i);
		}
		long end = System.currentTimeMillis();//获取当前时间距离1970-01-01 00:00:00的毫秒数
		System.out.println("所花费的时间为：" + (end - start));
	}	
}

return的使用：
return并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。与break与continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

编程实现：找出1000以内的所有完数。
完数：一个数如果恰好等于它的因子(除去这个数本身的其他约数)之和，
这个数就称为“完数”，例如：6=1+2+3

class PrefectNumber{
    
    
	public static void main(String[] args){
    
    
		for(int i = 1;i <= 1000;i++){
    
    
			int num = 0;
			for(int n = 1; n <= i/2; n++){
    
    
				if(i % n == 0){
    
    
				num += n;	
				}
				if(num == i){
    
    
					System.out.println(i);
				}
			}
	}	
}