【JAVA基础速过】第2章 Java 基本语法（下）流程控制

最新推荐文章于 2021-05-10 23:35:00 发布

是我，Zack

最新推荐文章于 2021-05-10 23:35:00 发布

阅读量332

点赞数 1

分类专栏： # Java SE Java 文章标签： java 流程控制 if else break 新星计划

本文链接：https://blog.csdn.net/weixin_44589991/article/details/116595917

版权

Java 同时被 2 个专栏收录

42 篇文章 7 订阅

订阅专栏

Java SE

15 篇文章 0 订阅

订阅专栏

文章目录

2. 5 程序流程控制

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

顺序结构

分支结构

循环结构

顺序结构：
程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构：
根据条件，选择性地执行某段代码。
有 if…else 和 switch case 两种分支语句。
循环结构：
根据循环条件，重复性的执行某段代码。
有 while 、 do…while 、 for 三种循环语句。
注 JDK1.5 提供了 foreach 循环，方便的遍历集合、数组元素。

2 .5.1 顺序结构

2.5.2 分支语句 1 if -else 结构

1.if语句三种格式：

2.分支结构： if else 使用说明

条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
语句块只有一条执行语句时，一对可以省略，但建议保留
if else 语句结构，根据需要可以嵌套使用
当 if else 结构是“多选一”时，最后的 else 是可选的，根据需要可以省略
当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
当多个条件是“包含”关系时，“小上大下 / 子上父下”

3.if else 语句应用举例

4.代码演示

/*
分支结构中的if-else（条件判断结构）


一、三种结构

第一种：
if(条件表达式){
	执行表达式
}

第二种：二选一
if(条件表达式){
	执行表达式1
}else{
	执行表达式2
}

第三种：n选一
if(条件表达式){
	执行表达式1
}else if(条件表达式){
	执行表达式2
}else if(条件表达式){
	执行表达式3
}
...
else{
	执行表达式n
}



*/
class IfTest {
	public static void main(String[] args) {
		
		//举例1
		int heartBeats = 79;
		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("需要做进一步检查");
		}

		System.out.println("检查结束");
		
		//举例2
		int age = 23;
		if(age < 18){
			System.out.println("你还可以看动画片");
		}else{
			System.out.println("你可以看成人电影了");
		}

		//举例3
		if(age < 0){
			System.out.println("您输入的数据非法");
		}else if(age < 18){
			System.out.println("青少年时期");
		}else if(age < 35){
			System.out.println("青壮年时期");
		}else if(age < 60){
			System.out.println("中年时期");
		}else if(age < 120){
			System.out.println("老年时期");
		}else{
			System.out.println("你是要成仙啊~~");
		}
	}
}

5.if 语句例题

拓展：Scanner类

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化:Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：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);
		
		//3.调用Scanner类的相关方法
		System.out.println("请输入你的姓名：");
		String name = scan.next();
		System.out.println(name);

		System.out.println("请输入你的芳龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.println("请输入你的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);

		System.out.println("你是否相中我了呢？(true/false)");
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);

		//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();//"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);
		

	}

}
/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

说明：
1. else 结构是可选的。
2. 针对于条件表达式：
   > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
   > 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
   > 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
*/

import java.util.Scanner;
class IfTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入岳小鹏期末成绩：(0-100)");
		int score = scan.nextInt();

		if(score == 100){
			System.out.println("奖励一辆BMW");//be my wife!  BMW <---> MSN
		}else if(score > 80 &&  score <= 99){
			System.out.println("奖励一台iphone xs max");
		}else if(score >= 60 && score <= 80){
			System.out.println("奖励一个 iPad");
		}else{
			System.out.println("什么奖励也没有");
		}
	}
}

/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。

说明：
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
*/
import java.util.Scanner;
class IfTest2 {
	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);

		System.out.println("请输入第一个整数：");
		int num1 = scanner.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scanner.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scanner.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);
			
		}

	}
}

6.if 语句练习

class IfExer {
	public static void main(String[] args) {
		int x = 4;
		int y = 1;
		if (x > 2) 
			if (y > 2) 
                System.out.println(x + y);
				//System.out.println("atguigu");
			else //就近原则，默认找最近的进行配对
				System.out.println("x is " + x);
    }
}

import java.util.Scanner;

class IfExer3{
    public static void main(String[] args){
    	Scanner scanner=new Scanner(System.in);
        int dogAge=scanner.nextInt();
        if(dogAge<=2 && dogAge>=0){
            System.out.println("相当于人的年龄"+dogAge * 10.5);
        }else if(dogAge > 2){
        	System.out.println("相当于人的年龄"+ (2 * 10.5+ (dogAge-2)*4));
        }else{
            System.out.println("狗狗还没出生呢");
        }
    }
}

//课后练习4：如何获取一个随机数：10 - 99
		int value = (int)(Math.random() * 90 + 10);// [0.0,1.0) --> [0.0,90.0) --->[10.0, 100.0) -->[10,99]
		System.out.println(value);
		//公式：[a,b]  :  (int)(Math.random() * (b - a + 1) )+ a

import java.util.Scanner;

class TestCaiPiao{
	public static void main(String[] args){
		//1、随机产生一个两位数
		//System.out.println(Math.random());//产生[0,1)
		int number = (int)(Math.random()*90 + 10);//得到[10,99]，即[10,100)
		//System.out.println(number);
		
		int numberShi = number/10;
		int numberGe = number%10;
		
		//2、用户输入一个两位数
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一个两位数：");
		int guess = input.nextInt();
		
		int guessShi = guess/10;
		int guessGe = guess%10;
		
		if(number == guess){
			System.out.println("奖金10 000美元");
		}else if(numberShi == guessGe && numberGe == guessShi){
			System.out.println("奖金3 000美元");
		}else if(numberShi==guessShi || numberGe == guessGe){
			System.out.println("奖金1 000美元");
		}else if(numberShi==guessGe || numberGe == guessShi){
			System.out.println("奖金500美元");
		}else{
			System.out.println("没中奖");
		}
		
		System.out.println("中奖号码是：" + number);
	}
}

/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”

*/
import java.util.Scanner;

class IfExer1 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入你的身高：(cm)");
		int height = scan.nextInt();
		System.out.println("请输入你的财富：(千万)");
		double wealth = scan.nextDouble();

		/*
		方式一：
		System.out.println("请输入你是否帅：(true/false)");
		boolean isHandsome = scan.nextBoolean();

		if(height >= 180 && wealth >= 1 && isHandsome){
			System.out.println("我一定要嫁给他!!!");
		}else if(height >= 180 || wealth >= 1 || isHandsome){
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
		*/

		//方式二：
		System.out.println("请输入你是否帅：(是/否)");
		String isHandsome = scan.next();

		
		if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){
			System.out.println("我一定要嫁给他!!!");
		}else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
	}
}

但是！必须弘扬一下正确的价值观

什么是真正的白富美？

身为女子，洁身自好为白，经济独立为富，内外兼修为美。

何谓真正的高富帅？

生为男子，大智若愚宠辱不惊是为高，大爱于心福泽天下是为富，大略宏才智勇双全是为帅！

2.5.3 分支语句 2 switch case 结构

1.基本定义

2.代码演示：

/*
分支结构之二：switch-case

1.格式
switch(表达式){
case 常量1:
	执行语句1;
	//break;
case 常量2:
	执行语句2;
	//break;
...

default:
	执行语句n;
	//break;

}

2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
  当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
  末尾结束为止。

② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

③ switch结构中的表达式，只能是如下的6种数据类型之一：
   byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)

④ case 之后只能声明常量。不能声明范围。

⑤ break关键字是可选的。

⑥ default:相当于if-else结构中的else.  
  default结构是可选的，而且位置是灵活的。
*/

class SwitchCaseTest {
	public static void main(String[] args) {
		
		int number = 5;
		switch(number){
		
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;
		case 3:
			System.out.println("three");
			break;
		default:
			System.out.println("other");
			//break;
		}


		String season = "summer";
		switch (season) {
		case "spring":
			System.out.println("春暖花开");
			break;
		case "summer":
			System.out.println("夏日炎炎");
			break;
		case "autumn":
			System.out.println("秋高气爽");
			break;
		case "winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break;
		}



		//**************如下的两种情况都编译不通过*********************
		//情况一
		/*
		boolean isHandsome = true;
		switch(isHandsome){
		
		case true:
			System.out.println("我好帅啊~~~");
			break;
		case false:
			System.out.println("我好丑啊~~~");
			break;
		default:
			System.out.println("输入有误~~~");
		}
		*/
		//情况二
		/*
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
		}
		*/
	}
}

3.switch语句应用举例

4.switch 语句有关规则

switch( 表达式中表达式的值必须是下述几种类型之一： byte short char int 枚举 (jdk String (jdk 7.0)
case 子句中的值必须是常量，不能是变量名或不确定的表达式值
同一个 switch 语句，所有 case 子句中的常量值互不相同；
break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；如果没有 break ，程序会顺序执行到 switch 结尾
default 子句是可任选的。同时，位置也是灵活的。当没有匹配的 case 时，执行 default

5.例题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qMceWm0r-1620629251394)(https://cdn.nlark.com/yuque/0/2021/png/2196885/1620567622280-63332bbf-73a7-4abc-b078-0d5fb58c840d.png)]

/*
例题2：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
*/
class SwitchCaseTest1 {
	public static void main(String[] args) {
		
		/*
		int score = 78;
		switch(score){
		case 0:
		case 1:
		case 2:
			...
		case 100:
		
		}
		*/

		/*
		int score = 78;
		if(score >= 60){
		
		}else{
		
		}
		*/
		
		int score = 78;
		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("及格");
			break;

		}
		
		//更优的解决方案：
		switch(score / 60){
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;
		}
	
	}
}
/*
编写程序4：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。

2  15:  31 + 15

5 7: 31 + 28 + 31 + 30 + 7 

....

说明:break在switch-case中是可选的
*/
import java.util.Scanner;
class SwitchCaseTest2 {
	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;

		//方式一：冗余
		/*
		
		if(month == 1){
			sumDays = day;
		}else if(month == 2){
			sumDays = 31 + day;
		}else if(month == 3){
			sumDays = 31 + 28 + day;
		}else if(month == 4){
			sumDays = 31 + 28 + 31 + day;
		}
		//...
		else{//month == 12
			//sumDays = ..... + day;
		}

		*/

		//方式二：冗余
		/*
		switch(month){
		case 1:
			sumDays = day;
			break;
		case 2:
			sumDays = 31 + day;
			break;
		case 3:
			sumDays = 31 + 28 + day;
			break;
		...
		}
		*/

		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 + "天");
	}
}

6.练习题（拓展题目）

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
 
   注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
	或
       2）可以被400整除


说明：
1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
  又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

*/
import java.util.Scanner;
class SwitchCaseExer {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year：");
		int year = scan.nextInt();
		System.out.println("请输入month：");
		int month = scan.nextInt();
		System.out.println("请输入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;
			//判断year是否是闰年
			if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
				sumDays += 29;
			}else{
				sumDays += 28;
			}

		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

7.switch 和 if 语句的对比

if 和 switch 语句很像，具体什么场景下，应用哪个语句呢？

如果判断的具体数值不多，而且符合 byte 、 short 、 char 、 int 、 String 、枚举等几种类型。虽然两个语句都可以使用，建议使用 swtich 语句。因为 效率稍高 。
其他情况：对区间判断，对结果为 boolean 类型判断，使用 if， if 的使用范围更广。也就是说，使用 switch case 的，都可以改写为 if else 。反之不成立。

8.练习题4

import java.util.Scanner;

class ShengXiaoTest{
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		System.out.print("请输入年份：");
		int year = input.nextInt();
		
		switch(year%12){
			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("马年");
				break;
			case 11:
				System.out.println("羊年");
				break;
			
		}
	}
}

2.5.4 循环结构

1.基本定义和组成部分

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

循环语句分类

for 循环
while 循环
do while 循环

2.代码演示

/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、for循环的结构

for(①;②;④){
	③
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

*/
class ForTest {
	public static void main(String[] args) {

		/*
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		*/

		for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
			System.out.println("Hello World!");
		}
		//i:在for循环内有效。出了for循环就失效了。
		//System.out.println(i);
		
		//练习：
		int num = 1;
		for(System.out.print('a');num <= 3;System.out.print('c'),num++){
			System.out.print('b');
		}
		//输出结果：abcbcbc

		System.out.println();

		//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		int sum = 0;//记录所有偶数的和
		int count = 0;//记录偶数的个数
		for(int i = 1;i <= 100;i++){
			
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
			//System.out.println("总和为：" + sum);
		}

		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);

	}
}

3.语法格式

for （① 初始化部分 ② 循环条件部分 ④ 迭代部分）{

③ 循环体部分

｝

执行过程：

① ② ③ ④ ② ③ ④ ② ③ ④ ②

说明：

②循环条件部分为 boolean 类型表达式，当值为 false 时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔

4.执行演示

5.应用举例

6.for 语句例题 1

/*
编写程序从1循环到150，并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,
在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”。

*/

class ForTest1 {
	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();

		}

	}
}

for 语句例题 2

/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。

说明：break关键字的使用：一旦在循环中执行到break，就跳出循环

*/

import java.util.Scanner;
class ForTest{

	public static void main(String[] args){
	
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入第一个正整数：");
		int m = scan.nextInt();
		
		System.out.println("请输入第二个正整数：");
		int n = scan.nextInt();
		
		//获取最大公约数
		//1.获取两个数中的较小值
		int min = (m <= n)? m : n;
		//2.遍历
		for(int i = min;i >= 1 ;i--){
			if(m % i == 0 && n % i == 0){
				System.out.println("最大公约数为：" + i);
				break;//一旦在循环中执行到break，就跳出循环
			}
		}
		
		//获取最小公倍数
		//1.获取两个数中的较大值
		int max = (m >= n)? m : n;
		//2.遍历
		for(int i = max;i <= m * n;i++){
			if(i % m == 0 && i % n == 0){
				System.out.println("最小公倍数：" + i);
				break;
			}
		}
	}
}

7.for 语句练习-水仙花数

class ShuiXianHua {
	public static void main(String[] args) {
		for (int i = 100; i < 1000; i++) {// 实现所有的三位数的一个遍历
			int j1 = 0;
			int j2 = 0;
			int j3 = 0;
			j1 = i / 100;// 百位
			j2 = (i - 100 * j1) / 10;// 十位
			j3 = i - 100 * j1 - 10 * j2;// 个位

			if (i == j1 * j1 * j1 + j2 * j2 * j2 + j3 * j3 * j3) {
				System.out.println("此数值为满足条件的水仙花数:" + i);
			}
		}
	}
}

2.5.5 循环结构 2 while 循环

1.基本定义

语法格式

① 初始化部分

while(② 循环条件部分）{

③ 循环体部分；

④ 迭代部分；

}

执行过程：

① ② ③ ④ ② ③ ④ ② ③ ④ ②

说明：

注意不要忘记声明 ④ 迭代部分。否则循环将不能结束变成死循环。
for 循环和 while 循环可以相互转换

2.应用举例

3.代码实操

/*
While 循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、while循环的结构

①
while(②){
	③;
	④;
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！ 
  区别：for循环和while循环的初始化条件部分的作用范围不同。


算法：有限性。

*/
class  WhileTest{
	public static void main(String[] args) {
		
		//遍历100以内的所有偶数
		int i = 1;
		while(i <= 100){
			
			if(i % 2 == 0){
				System.out.println(i);
			}
			
			i++;
		}
		//出了while循环以后，仍可以调用。
		System.out.println(i);//101

	}
}

2.5.6 循环结构3：do while 循环

1.基本定义

语法格式

① 初始化部分

do{

③ 循环体部分

④ 迭代部分

}while( ② 循环条件部分

执行过程：

① ③ ④ ② ③ ④ ② ③ ④ ②

说明：

do while 循环至少执行一次循环体。

2.应用举例

3.代码实操

/*
do-while循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、do-while循环结构：

①
do{
	③;
	④;

}while(②);

执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while

*/
class DoWhileTest {
	public static void main(String[] args) {
		
		//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
		int num = 1;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			
			if(num % 2 == 0){
				System.out.println(num);
				sum += num;
				count++;
			}
			num++;
		}while(num <= 100);
		
		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);
        
		//*************体会do-while至少执行一次循环体***************
		int number1 = 10;
		while(number1 > 10){
			System.out.println("hello:while");
			number1--;		}

		int number2 = 10;
		do{
			System.out.println("hello:do-while");
			number2--;
		}while(number2 > 10);

	}
}

4.循环语句综合例题题

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
     方式一：循环条件部分返回false
	 方式二：在循环体中，执行break
*/

import java.util.Scanner;

class ForWhileTest {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		int positiveNumber = 0;//记录正数的个数
		int negativeNumber = 0;//记录负数的个数

		for(;;){//while(true){
			
			int number = scan.nextInt();

			//判断number的正负情况
			if(number > 0){
				positiveNumber++;
			}else if(number < 0){
				negativeNumber++;
			}else{
				//一旦执行break，跳出循环
				break;
			}
		}
		System.out.println("输入的正数个数为：" + positiveNumber);
		System.out.println("输入的负数个数为：" + negativeNumber);
	
	}
}

2.5.7 嵌套循环

1.嵌套循环多重循环

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，

for ,while ,do…while 均可以作为 外层循环 或 内层循环 。

实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

2.代码实操

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

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

4. 技巧：
   外层循环控制行数，内层循环控制列数
*/
class ForForTest {
	public static void main(String[] args) {
		
		//******
		//System.out.println("******");
		for(int i = 1;i <= 6;i++){
			System.out.print('*');
		}

		System.out.println("\n");

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

		/*			i(行号)		j(*的个数)
		*			1			1
		**			2			2
		***			3			3
		****		4			4
		*****		5			5
		*/

		for(int i = 1;i <= 5;i++){//控制行数
			for(int j = 1;j <= i;j++){//控制列数
				System.out.print("*");
			
			}
			System.out.println();
		}
		
		/*			i(行号)		j(*的个数)   规律：i + j = 5 换句话说：j = 5 - i;
		****		1			4
		***			2			3
		**			3			2
		*			4			1
		*/	

		for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= 5 - i;j++){
				System.out.print("*");	
			}
			System.out.println();
		}

		/*
		*
		**
		***
		****
		*****
		****
		***
		**
		*
		*/

		//略

/*
----* 
---* * 
--* * * 
-* * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    * 
*/

	//上半部分


	//下半部分
		
	}
}

3.例题1：九九乘法表

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

4.例题2：100 以内的所有质数

/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

最小的质数是：2
*/
class PrimeNumberTest {
	public static void main(String[] args) {		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		for(int i = 2;i <= 100;i++){//遍历100以内的自然数
			for(int j = 2;j < i;j++){//j:被i去除		
				if(i % j == 0){ //i被j除尽
					isFlag = false;
				}		
			}
			//
			if(isFlag == true){
				System.out.println(i);
			}
			//重置isFlag
			isFlag = true;		
		}
	}
}

算法优化

/*
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest1 {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			//优化二：对本身是质数的自然数是有效的。
			//for(int j = 2;j < i;j++){
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
					break;//优化一：只对本身非质数的自然数是有效的。
				}
				
			}
			//
			if(isFlag == true){
				//System.out.println(i);
				count++;
			}
			//重置isFlag
			isFlag = true;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}
}

另外一种实现方式（需要先学下面的contine label）

/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					continue label;
				}
				
			}
			//能执行到此步骤的，都是质数
			count++;
		}
		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13
	}
}

2.5.8 特殊关键字的使用： break 、 continue

1.特殊流程控制语句 1

2.特殊流程控制语句 2 continue 语句

continue 只能使用在循环结构中
continue 语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

/*
break和continue关键字的使用
				使用范围			循环中使用的作用(不同点)		相同点
break:			switch-case			
				循环结构中			结束当前循环					关键字后面不能声明执行语句	

continue:		循环结构中			结束当次循环					关键字后面不能声明执行语句



*/
class BreakContinueTest {
	public static void main(String[] args) {

		for(int i = 1;i <= 10;i++){
		
			if(i % 4 == 0){
				break;//123
				//continue;//123567910
				//System.out.println("今晚迪丽热巴要约我！！！");
			}
			System.out.print(i);
		}

		System.out.println("\n");
		//******************************
		
		label:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;//默认跳出包裹此关键字最近的一层循环。
					//continue;

					//break label;//结束指定标识的一层循环结构
					continue label;//结束指定标识的一层循环结构当次循环
				}
				
				System.out.print(j);
			}
			
			System.out.println();
		}
	}
}

3.附加：特殊流程控制语句3 return

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

4.特殊流程控制语句说明

break 只能用于 switch 语句和循环语句中。
continue 只能用于循环语句中。
二者功能类似，但 continue 是终止本次循环， break 是终止本层循环。
b reak 、 continue 之后不能有其他的语句，因为程序永远不会执行其后的语句。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
很多语言都有 goto 语句， goto 语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。 Java 中的 break 和 continue 是不同于 goto 的。

每日一考Day4

1.switch后面使用的表达式可以是哪些数据类型的。

byte 、 short 、char 、int 、枚举类型变量、String类型。

2. 使用switch语句改写下列if语句：

 	 int a = 3;
 	 int x = 100;
 	 if(a==1)
		x+=5;
 	 else if(a==2)
		x+=10;
 	 else if(a==3)
		x+=16;
 	 else		
		x+=34;

int a = 3;
int x = 100;
switch(a){
case 1:
	x+=5;
	break;
case 2:
	x+=10;
	break;
case 3:
	x+=16;
	break;
default:
	x+=34;
	//break;
}

3. 谈谈你对三元运算符、if-else和switch-case结构使用场景的理解

int c;
if(a != b){
	c = a;
}else{
	c = b;
}

int c = (a != b)? a : b;

int c = a;

4. 如何从控制台获取String和int型的变量，并输出？使用代码实现

1.import java.util.Scanner;

\2. Scanner scan = new Scanner(System.in);

\3. String info = scan.next();

int id = scan.nextInt();

5. 使用for循环遍历100以内的奇数，并计算所有的奇数的和并输出。

int sum = 0;
for(int i = 1;i <= 100;i++){
	if(i % 2 != 0){
		System.out.println(i);
		sum += i;
	}
}
System.out.println(sum);

每日一考 Day05

1. 循环结构是如何最后退出循环的，有哪些不同的情况请说明。

① 循环条件返回false

② 在循环体内，一旦执行到break，跳出循环

continue；return

2.指出如下程序输出的结果：

label: for (inti = 1; i <= 4; i++) {
    for (intj = 1; j <= 10; j++) {
        if (j % 4 == 0) {
        	continue label;
   		}
    	System.out.print(j);
    }
    System.out.println();
}

正确结果：123123123123

3.一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3。编程找出1000以内的所有完数。（因子：除去这个数本身的其它约数）

//int factor = 0;
for(int i = 1;i <= 1000;i++){
	int factor = 0;	
	for(int j = 1;j <= i/2;j++){
		if(i % j == 0){
			factor += j;
		}
	}
	if(i == factor){
		System.out.println(i);
	}
	//重置factor
	//factor = 0;
}

4. 说明break和continue使用上的相同点和不同点

break:s witch-case 和循环结构（结束当前循环），其后不可以声明执行语句

continue: 循环结构（结束当次循环），其后不可以声明执行语句

5.从控制台输出如下结构：

//外层循环控制行数
//内层循环控制列数

for(int i = 1;i <= 6;i++){
	for(int j = 1;j <= 7 - i;j++){
		System.out.print("*");
	}
	System.out.println();
}

//或
for(int i = 0;i < 6;i++){
	
	for(int j = 0;j < 6 - i;j++){
		System.out.print("*");
	}

	System.out.println();
}