1.3 Java基本结构

怼烎@ 2023-06-19 11:06 7阅读 0赞

本文是课上资料的总结非原创没有转载地址

### 目录 ###

*  Java选择结构
 *   *  Scanner类
     *  1.基本if选择结构
     *   *  语法
         *  执行流程
         *  示例
     *  2.if else选择结构
     *   *  语法
         *  执行流程
         *  示例
     *  3.多重if选择结构
     *   *  语法
         *  执行流程
         *  示例
     *  4.嵌套if选择结构
     *   *  语法
         *  执行流程
         *  示例
     *  5.特殊的if语句
     *  6.switch分支结构
     *   *  语法
         *  可判断的类型
         *  执行流程
         *  示例
         *  case穿透
     *  7.局部变量
     *   *  概念
         *  作用范围
     *  总结
 *  Java循环结构
 *   *  1.循环概念
     *  2.while循环
     *   *  语法
         *  执行流程
         *  循环的组成
         *  初始与迭代
         *  特点
         *  练习
     *  3.do while循环
     *   *  语法：
         *  执行流程：
         *  特点：
         *  应用场景
         *  练习
     *  4.for循环
     *   *  语法
         *  执行流程
         *  练习
         *  for循环特殊形式
     *  while、do while、for区别
     *  5.流程控制关键字
     *   *  break
         *   *  分析：
             *  练习：
         *  continue
         *   *  分析：
             *  练习：
     *  嵌套循环
     *   *  概念分析
         *  练习
 *  作业题
 *  面试题

# Java选择结构 #

**程序中的三种基本结构：**  
**1. 顺序结构**  
程序默认顺序，从上而下执行，没有判断和中转  
**2. 选择结构**  
有选择性的执行或者跳过指定代码  
**3. 循环结构**  
重复执行一段代码，直到条件不成立

> 注意：个人理解，Java程序去除选择和循环默认按照顺序结构执行。

**选择结构**  
**概念**：根据已知条件进行判断，曼珠条件后执行相应操作。

## Scanner类 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String next()</td> 
   <td>返回控制台输入的字符串</td> 
  </tr> 
  <tr> 
   <td>int nextInt()</td> 
   <td>返回控制台输入的整数</td> 
  </tr> 
  <tr> 
   <td>double nextDouble()</td> 
   <td>返回控制台输入的double浮点数</td> 
  </tr> 
  <tr> 
   <td>char next().charAt(0)</td> 
   <td>返回控制台输入的第一个字符</td> 
  </tr> 
 </tbody> 
</table>

## 1.基本if选择结构 ##

### 语法 ###

if(布尔表达式) {
        
    	//	代码块
    }
    //	后续代码...

### 执行流程 ###

*  对布尔表达式进行判断。
 *  结果为true，则先执行代码块，再执行后续代码 。
 *  结果为false，则跳过代码块，直接执行后续代码。

### 示例 ###

*  **示例1**：键盘录入Java成绩，如果大于60，奖励一个键盘。

/*
    需求：如果Java成绩大于60，奖励一个键盘。
    */
    public class Example01 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		Syste,.out.println("请输入Java成绩：");
    		int score = sc.nextInt();
    		if (score > 60) {
        
    			System.out.println("奖励一个键盘。");
    		}
    		System.out.println("程序结束了");
    	}
    }

*  **示例2**：Java成绩大于98分，而且Html成绩大于80分，老师奖励他；或者Java成绩等于100分，Html成绩大于70分，老师也可以奖励他。

/*
    需求：Java成绩大于98分，而且Html成绩大于80分，老师奖励他；或者Java成绩等于100分，Html成绩大于70分，老师也可以奖励他。
    */
    public class Example02 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入Java成绩：");
    		int javaScore = sc.nextInt();
    		System.out.println("请输入Html成绩：");
    		int htmlScore = sc.nextInt();
    		if ((javaScore > 98 && htmlScore > 80) || (javaScore == 100 && htmlScore > 70)) {
        
    			System.out.println("老师奖励！");
    		}
    		System.out.println("程序结束了");
    	}
    }

## 2.if else选择结构 ##

### 语法 ###

if(布尔表达式) {
        
    	//	代码块1
    } else {
        
    	//	代码块2
    }
    //	后续代码...

### 执行流程 ###

*  对布尔表达式进行判断。
 *  结果为true，则先执行代码块1，再退出整个结构，执行后续代码。
 *  结果为false，则先执行代码块2，再退出整个结构，执行后续代码。

### 示例 ###

*  字符串比较使用`equals()`方法
 *  **示例3**：如果是男生送名牌手表，否则送lv包包。

/*
    需求：如果是男生送名牌手表，否则送lv包包。
    */
    public class Example03 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入性别：");
    		String sex = sc.next();
    		if (sex.equals("男生")) {
        
    			System.out.println("送名牌手表！");
    		} else {
        
    			System.out.println("送LV包包");
    		}
    	}
    }

*  **示例4**：如果体彩中了500万，我买车、买房、欧洲旅游
    
     *  要求控制台输入是否中奖
     *  字符串比较使用`equals()`方法

/*
    需求：如果体彩中了500万，我买车、买房、欧洲旅游
    （1）要求控制台输入是否中奖
    （2）字符串比较使用equals()方法
    */
    public class Example04 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("是否中了500万？y/n");
    		String answer = sc.next();
    		if (answer.equals("y")) {
        
    			System.out.println("中奖！");
    		} else {
        
    			System.out.println("未中奖！");
    		}
    	}
    }

*  **示例5**：输入四位数字的会员号的百位数字等于产生的随机数字几位幸运会员，提示恭喜您中奖了，否则没中奖。  
    `int random = (int)(Math.random()*10); // 功能产生一个一位正整数。后续讲到Math`

/*
    需求：输入四位数字的会员号的百位数字等于产生的随机数字几位幸运会员，提示恭喜您中奖了，否则没中奖。
    */
    public class Example05 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入四位会员号：");
    		int card = sc.nextInt();
    		int bai = card / 100 % 10;
    		// 获取随机数字 Math.random(); 返回 0-1 之间的小数
    		int ran = (int)(Math.random()*10);
    		if () {
        
    			System.out.println("中奖了！");
    		} else {
        
    			System.out.println("未中奖，谢谢惠顾！");
    		}
    	}
    }

## 3.多重if选择结构 ##

### 语法 ###

if(布尔表达式1) {
        
    	//	代码块1
    } else if(布尔表达式2) {
        
    	//	代码块2
    } else if(布尔表达式3){
        
    	//	代码块3
    }...{
        
    	...
    } else {
        
    	//	代码块n
    }

### 执行流程 ###

*  表达式1结果为true，则先执行代码块1，再退出整个结构，执行后续代码。
 *  表达式2结果为true，则先执行代码块2，再退出整个结构，执行后续代码。
 *  …
 *  以上结果均为false，则执行代码块n，再退出整个结构，执行后续代码。

> 注意：相互排斥，有一个为true，其他均不在执行，适用于区间判断。

### 示例 ###

*  **示例6**：某游戏对不同等级的积分玩家赋予不同的荣誉称号，其对应关系如下：  
    积分>=10000分为钻石玩家  
    积分>=5000并且<10000为白金玩家  
    积分>=1000并且<5000为青铜玩家  
    积分<1000为普通玩家。  
    小编现在是有7200分，请在代码编辑器中完善代码，看一下小编是什么级别的玩家。

/*
    需求：某游戏对不同等级的积分玩家赋予不同的荣誉称号，其对应关系如下：
    积分>=10000分为钻石玩家
    积分>=5000并且<10000为白金玩家
    积分>=1000并且<5000为青铜玩家
    积分<1000为普通玩家。
    小编现在是有7200分，请在代码编辑器中完善代码，看一下小编是什么级别的玩家。
    */
    public class Example06 {
        
    	public static void main(String[] args) {
        
    		// 创建变量保存积分
    		int score = 7200;
    		if (score >= 10000) {
        
    			System.out.println("钻石玩家");
    		} else if (score >= 5000) {
        
    			System.out.println("白金玩家");
    		} else if (score >= 1000) {
        
    			System.out.println("青铜玩家");
    		} else {
        
    			System.out.println("普通玩家");
    		}
    	}
    }

*  **示例7**：我想买车，买什么车决定于我在银行有多少存款  
    如果我的存款超过500万，我就买保时捷  
    否则，如果我的存款超过100万，我就买路虎  
    否则，如果我的存款超过50万，我就买宝马  
    否则，如果我的存款超过10万，我就买大众  
    否则，如果我的存款10万以下，我买捷安特。

/*
    需求：我想买车，买什么车决定于我在银行有多少存款
    如果我的存款超过500万，我就买保时捷
    否则，如果我的存款超过100万，我就买路虎
    否则，如果我的存款超过50万，我就买宝马
    否则，如果我的存款超过10万，我就买大众
    否则，如果我的存款10万以下，我买捷安特。
    */
    public class Example07 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入您的存款：万");
    		int money = sc.nextInt();
    		if (money >= 500) {
        
    			System.out.println("买保时捷");
    		} else if (money >= 100) {
        
    			System.out.println("买路虎");
    		} else if (money >= 50) {
        
    			System.out.println("买宝马");
    		} else if (money >= 10) {
        
    			System.out.println("买大众");
    		} else {
        
    			System.out.println("买捷安特");
    		}
    	}
    }

## 4.嵌套if选择结构 ##

### 语法 ###

if(外层表达式) {
        
    	if(内层表达式) {
        
    		//	内层代码块1
    	} else {
        
    		//	内层代码块2
    	}
    } else {
        
    	//	外层代码块
    }
    //	后续代码...

### 执行流程 ###

*  当外层条件满足时，在判断内层条件

> 注意：
> 
>  *  一个选择结构中，可嵌套另一个选择结构。
>  *  嵌套格式正确的情况下，支持任意组合。

### 示例 ###

*  **示例8**：如果成绩大于90，如果是个男生送个iPhone 11，如果是女生送化妆品

/*
    需求：如果成绩大于90，如果是个男生送个iPhone 11，如果是女生送化妆品
    */
    public class Example08 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入成绩：");
    		int score = sc.nextInt();
    		System.out.println("请输入性别：");
    		char sex = sc.next().charAt(0);
    		if (score >= 90) {
        
    			if (sex == '男') {
        
    				System.out.println("送iPhone 11");
    			} else {
        
    				System.out.println("送雅诗兰黛");
    			}
    		} else {
        
    			System.out.println("啥都没有！");
    		}
    	}
    }

## 5.特殊的if语句 ##

*  如果if或else中只有一条语句，可以省略 “\{ \}”

int score = 80;
    if(score)
    	System.out.println("有奖励！");
    else
    	System.out.println("啥都没有！");

## 6.switch分支结构 ##

### 语法 ###

switch(变量 | 表达式) {
        
    	case 值1:
    		逻辑代码1:
    		break;
    	case 值2:
    		逻辑代码2:
    		break;
    	case 值n:
    		逻辑代码n:
    		break;
    	default:
    		未满足时的逻辑代码:
    		break;
    }

### 可判断的类型 ###

byte、short、int、char、`String和枚举(JDK7+)`

### 执行流程 ###

*  如果变量中的值等于值1，则执行逻辑代码1。
 *  如果变量中的值等于值2，则执行逻辑代码2。
 *  如果变量中的值等于值n，则执行逻辑代码n。
 *  如果变量中的值没有匹配的case值时，执行default中的逻辑代码

> 注意：
> 
>  *  所有case的取值不可相同
>  *  break作业推出switch结构

### 示例 ###

*  **示例9**：根据不同输入名次显示不同奖励。  
    第一名：奖励 iPhone 11  
    第二名：奖励 电视  
    第三名：奖励 自行车  
    否则：奖励 彩票

/*
    需求：根据不同输入名次显示不同奖励。
    第一名：奖励	iPhone 11
    第二名：奖励	电视
    第三名：奖励	自行车
    否则：	奖励	彩票
    */
    public class Example09 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入名次：");
    		int ranking = sc.nextInt();
    		switch (ranking) {
        
    			case 1:
    				System.out.println("奖励iPhone 11");
    				break;
    			case 2:
    				System.out.println("奖励电视");
    				break;
    			case 3:
    				System.out.println("奖励自行车");
    				break;
    			default:
    				System.out.println("奖励彩票");
    				break;
    		}
    	}
    }

### case穿透 ###

![case穿透][case]

*  当匹配的case被执行后，并不会自动推出整个结构，而是继续向下执行。
 *  break关键字可以在匹配的case执行后，直接跳出整个结构。

## 7.局部变量 ##

### 概念 ###

声明在函数内部的变量，必须先复制再使用。

### 作用范围 ###

定义行开始到所在的代码块结束。

> 注意：多个变量，在重合的作用范围内，不可出现重名（命名冲突）。

## 总结 ##

*  **基本if选择结构**  
    \`if() \{\}\`\`\`
 *  **if else选择结构**  
    `if() {} else {}`
 *  **多重if选择结构**  
    `if() {} else if() {} else if() {} else {}`
 *  **嵌套if选择结构**  
    `if() { if() {} }`
 *  **switch分支结构**  
    `switch() {}`  
    case穿透
 *  **局部变量**

# Java循环结构 #

## 1.循环概念 ##

*概念*：通过某个条件，重复的执行一段逻辑代码。  
![程序中的循环结构][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy_size_16_color_FFFFFF_t_70_pic_center]

## 2.while循环 ##

### 语法 ###

while(布尔表达式) {
        
    	//	逻辑代码（循环操作）
    }

### 执行流程 ###

*  先对布尔表达式进行判断，结果为true，则执行逻辑代码。
 *  本次执行完毕后，再次进行判断，结果仍旧为true，则再次执行逻辑代码。
 *  直至布尔表达式的结果为false时，才会推出循环结构，执行后续代码。

### 循环的组成 ###

*  **需求**：打印100遍“HelloWorld”。  
    ![while循环][while]

> 注意：循环有四部分组成。

*  **循环四个部分**：
    
    1.  循环初始化部分
    2.  循环条件
    3.  循环操作
    4.  迭代部分

### 初始与迭代 ###

*  以下代码，哪一行是初始部分？哪一行是迭代部分？  
    ![while中的初始与迭代][while 1]

### 特点 ###

![while循环2][while_2]  
首次即有入口条件，先判断、在执行，适用于循环次数明确的情况。

### 练习 ###

*  练习一：计算 1 + 2 + 3 + 4 + 5 … + 98 + 99 + 100 的总和。

/*
    需求：计算 1 + 2 + 3 + 4 + 5 ... + 98 + 99 + 100 的总和。
    */
    public class Example01 {
        
    	public static void main(String[] args) {
        
    		int i = 0;	//	1.循环初始化
    		int sum = 0;	//	总和
    		while (i <= 100) {
        	//	2.循环条件
    			sum += i;	//	3.循环体
    			i++;	//	4.迭代
    		}
    		System.out.println("1~100的和是：" + sum);
    	}
    }

*  练习二：计算1~100之间，所有偶数的和。

/*
    需求：计算1~100之间，所有偶数的和。
    */
    public class Example02 {
        
    	public static void main(String[] args) {
        
    		int i = 0;	//	1.循环初始化
    		int sum = 0;	//	总和
    		while (i <= 100) {
        	//	2.循环条件
    			if (i %2 == 0) {
        	//	3.循环体
    				sum += i;
    			}
    			//i++;	//	4.迭代
    			i += 2;
    		}
    		System.out.println("1~100的偶数和是：" + sum);
    	}
    }

*  练习三：计算 1 到 10 的阶乘。

/*
    需求：计算 1 到 10 的阶乘。
    */
    public class Example03 {
        
    	public static void main(String[] args) {
        
    		int i = 0;
    		int sum = 0;
    		while (i <= 10) {
        
    			sum *= i;	//	sum = sum * i;
    			i++;
    		}
    		System.out.println("1~10的阶乘");
    	}
    }

## 3.do while循环 ##

### 语法： ###

do{
        
    	//	逻辑代码（循环操作）
    } while(布尔表达式);

### 执行流程： ###

*  先执行一次循环操作之后，在进行布尔表达式的判断。
 *  如果结果为`true`，则再执行循环操作。
 *  如果`false`，才会退出循环结构，执行后续代码。

### 特点： ###

*  需求：打印100遍“HelloWorld”  
    ![dowhile][]
 *  **特点**：首次没有入口条件，先执行，在判断。

### 应用场景 ###

*  需求：检查学生作业完成情况，输入教师评语，决定学生是否需要抄写代码。

/*
    需求：检查学生作业完成情况，输入教师评语，决定学生是否需要抄写代码。
    */
    public class TestDoWhile {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    
    		char answer;	//	记录老师当次的评语
    		do {
        
    			System.out.println("抄写一遍作业代码。。。");
    
    			System.out.println("请输入老师评语：");
    			answer = sc.next().charAt(0);	//	输入y，表示及格，退出循环，否则继续循环
    		} while (answer != 'y');
    
    		System.out.println("作业已完成");		
    	}
    }

*  **应用场景**：适用于循环次数不明确的情况。

### 练习 ###

*  练习四：使用do…while实现1到100的和。

/*
    需求：使用do...while实现1到100的和。
    */
    public class Example04 {
        
    	public static void main(String[] args) {
        
    		int i = 1;	// 循环初始化
    		int sum = 0;
    		do {
        
    			i++;
    			sum += i;
    		} while (i <= 100);
    		System.out.println("1-100的和是：" + sum);
    	}
    }

*  练习五：do…while 循环输出“做我女朋友好不好！”，直到对方答应退出循环。

/*
    需求：do...while 循环输出“做我女朋友好不好！”，直到对方答应退出循环。
    */
    public class Example05 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		String answer = null;	// 保存回答结果
    		do {
        
    			System.out.println("做我女朋友好不好！");
    			answer = sc.next();
    		} while (!answer.equals("是"));
    		System.out.println("恭喜你成功了。。。");
    	}
    }

## 4.for循环 ##

### 语法 ###

for (初始部分; 循环部分; 迭代部分) {
        
    	//	循环操作
    }

### 执行流程 ###

*  首次执行初始化部分（仅一次）。
 *  对布尔表达式进行判断，结果为`true`，则执行逻辑代码。
 *  本次执行完毕后，执行迭代部分，再次判断，结果仍旧为`true`，则再执行逻辑代码。
 *  直至布尔表达式的结果为`false`时，才会退出循环结构，执行后续代码。

### 练习 ###

*  练习六：控制台输入整数n，计算n的阶乘（!n）。例：1 \* 2 \* 3 … \* n

/*
    需求：控制台输入整数n，计算n的阶乘（!n）。例：1 * 2 * 3 ... * n
    */
    public class Example06 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个整数：");
    		int num = sc.nextInt();
    		int result = 0;
    		for (int i = 1; ) 
    	}
    }

*  练习七：现有1个班级的5名同学，请通过控制台输入5名同学的分数，并打算平均分。

/*
    需求：现有1个班级的5名同学，请通过控制台输入5名同学的分数，并打算平均分。
    */
    public class Example07 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		int sum = 0;
    		int avg = 0;
    		for (int i = 0; i < 5; i++) {
        
    			System.out.println("请输入第" + (i + 1) + "位学生的成绩：");
    			int sum += sc.nextInt();
    		}
    		double avg = (double) sum / 5;
    		System.out.println("平均分是：" + avg);
    	}
    }

*  练习八：输出加法表，输入一个数字，比如6  
    0 + 6 = 6、1 + 5 = 6 … 6 + 0 = 6

/*
    需求：输出加法表，输入一个数字，比如6
    0 + 6 = 6、1 + 5 = 6 ... 6 + 0 = 6
    */
    public class Example08 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个数字：");
    		int num = sc.nextInt();
    		for (int i = 0, j = num; i <= num; i++, j--) {
        
    			System.out.println(i + " + " + j + " = " + (i+j));
    		}
    	}
    }

### for循环特殊形式 ###

*  特殊形式1：省略循环条件，出现死循环
 *  特殊形式2：省略迭代部分，出现死循环
 *  特殊形式3：初始化、循环条件、迭代部分都省略，出现死循环

//	特殊形式1：省略循环条件，出现死循环
    /*for (int i = 0;; i++) {
    	System.out.println("特殊形式1");
    }*/
    //	特殊形式2：省略迭代部分，出现死循环
    /*for (int i = 0; i < 10;) {
    	System.out.println("特殊形式2");
    }*/
    //	特殊形式3：初始化、循环条件、迭代部分都省略，出现死循环
    /*for (;;) {	//	等同于while (true)
    	System.out.println("特殊形式1");
    }*/

## while、do while、for区别 ##

<table> 
 <thead> 
  <tr> 
   <th>区别</th> 
   <th>具体</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>语法不一样</td> 
   <td>while(循环条件) {…}<br>do {…} while (循环条件);<br>for (初始部分; 循环部分; 迭代部分) {…};</td> 
  </tr> 
  <tr> 
   <td>执行顺序</td> 
   <td><code>while</code>和<code>for</code>是先判断条件，然后再执行循环体。<br>do while是先执行循环题，再判断条件。</td> 
  </tr> 
  <tr> 
   <td>使用场合</td> 
   <td>循环次数确定时优先选用<code>for、while</code>循环。<br>循环次数不确定优先选用<code>do while</code>循环。</td> 
  </tr> 
 </tbody> 
</table>

## 5.流程控制关键字 ##

### break ###

*  **break**：终止、跳出switch、循环结构。

#### 分析： ####

![break][]

#### 练习： ####

*  练习九：小张参加长跑比赛5000米，一共10圈，如果小张坚持不下来，可以中途退出比赛，使用程序描述这个场景？

/*
    要求：小张参加长跑比赛5000米，一共10圈，如果小张坚持不下来，可以中途退出比赛，使用程序描述这个场景？
    */
    public class Example09 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		int count = 0;	// 跑了多少圈
    		String answer = null;
    		do {
        
    			count++;
    			System.out.println("开始跑第" + count + "圈！！！");
    			System.out.println("跑完了第" + count + "圈！！！");
    			System.out.println("能坚持不？y/n");
    			answer = sc.next();
    			if (!answer.equals("y")) {
        
    				break;	// 退出比赛
    			}
    		} while (count < 10);
    	}
    }

### continue ###

*  **continue**：结束本次、进入下次循环。

#### 分析： ####

![continue][]

#### 练习： ####

*  练习十：小张参加长跑比赛5000米，一共10圈，如果小张坚持不下来，可以中途退出比赛，使用程序描述这个场景？

/*
    要求：小张参加长跑比赛5000米，一共10圈，如果小张口渴了，喝水继续跑，使用程序描述这个场景？
    */
    public class Example10 {
        
    	public static void main(String[] args) {
        
    		Scanner sc = new Scanner(System.in);
    		int count = 0;
    		String answer = null;
    		do {
        
    			count++;
    			System.out.println("开始跑第" + count + "圈！！！");
    			System.out.println("跑完了第" + count + "圈！！！");
    			System.out.println("口渴了吗？y/n");
    			if (!answer.equals("y")) {
        
    				continue; // 继续
    			}
    			System.out.println("喝口水，抽根烟！！！");
    		} while (count < 10);
    		System.out.println("比赛结束了，共计跑了" + count + "圈！！！");
    	}
    }

## 嵌套循环 ##

### 概念分析 ###

*  **概念**：在一个完整的循环结构中，嵌套另一个完整的循环结构。
 *  分析：  
    需求1：打印3行5颗星。  
    ![需求1][1]  
    需求2：计算3个班，每个班5名同学的平均成绩。  
    ![需求2][2]
 *  **特点**：嵌套循环外层循环一次，内层循环执行一遍。

### 练习 ###

*  练习十一：打印九九乘法表

/*
    需求：打印九九乘法表
    */
    public class Example11 {
        
    	public static void main(String[] args) {
        
    		for (int i = 1; i <= 9; i++) {
        
    			for (int j = 1; j <= i; j++) {
        
    				System.out.print(i + " * " + j + " = " + (i * j) + "\t");
    			}
    			System.out.println();
    		}
    	}
    }

*  练习十二：打印等腰三角形

/*
    需求：打印等腰三角形
    */
    public class Example12 {
        
    	public static void main(String[] args) {
        
    		for (int i = 1; i <= 5; i++) {
        
    			// 输出空格
    			for (int k = 1; k <= 5-i; k++) {
        
    				System.out.print(" ");
    			}
    			// 输出*
    			for (int j = i; j <= 2*i-1; j++) {
        
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}
    }

*  练习十三：打印菱形

/*
    需求：打印菱形
    */
    public class Example13 {
        
    	public static void main(String[] args) {
        
    		// 上半部分
    		for (int i = 1; i <= 5; i++) {
        
    			// 输出空格
    			for (int k = 1; k <= 5-i; k++) {
        
    				System.out.print(" ");
    			}
    			// 输出*
    			for (int j = i; j <= 2*i-1; j++) {
        
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		// 下半部分
    		for (int i = 4; i <= 1; i--) {
        
    			// 输出空格
    			for (int k = 1; k <= 5-i; k++) {
        
    				System.out.print(" ");
    			}
    			// 输出*
    			for (int j = i; j <= 2*i-1; j++) {
        
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}
    }

# 作业题 #

1.  求1至1000之间满足“用3除余2；用5除余3；用7除余2”的数，且一行只打印5个数
2.  求1-3+5-7+ …… -99+101的值
3.  打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身
4.  百元百鸡问题：公鸡5元一只，母鸡3元一只，3只小鸡1元，如果用100元钱，买100只鸡，不佘不欠，可以买公鸡，母鸡，小鸡，各多少只。  
    公鸡x  
    母鸡y  
    小鸡 100-x-y
    
    5*x+y*3+(100-x-y)/3=100  
    15*x+9*y+100-x-y=300  
    14*x+8y=200  
    7*x+4\*y=100;
5.  打印2到1000的所有素数（质数），每行显示8个素数  
    50 53

# 面试题 #

1.  什么时候用for循环，什么时候用while循环  
    如果循环次数在执行循环体之前就已确定，一般用for语句；如果循环次数是根据循环体的执行情况确定的，一般用while语句或者do-while语句。
2.  while循环和do-while循环的区别
3.  break、continue区别  
    break:应用在switch和循环中，作用跳出（终止）语句块  
    continue:应用在循环中，作用结束本次循环，继续下一次循环。

[case]: https://img-blog.csdnimg.cn/20191206193459734.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20191206200242719.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[while]: https://img-blog.csdnimg.cn/20191206201004527.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[while 1]: https://img-blog.csdnimg.cn/2019120620155923.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[while_2]: https://img-blog.csdnimg.cn/20191223083126561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[dowhile]: https://img-blog.csdnimg.cn/20191224205953124.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[break]: https://img-blog.csdnimg.cn/20191224214640589.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[continue]: https://img-blog.csdnimg.cn/20191225193445553.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[1]: https://img-blog.csdnimg.cn/20191226105003405.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center
[2]: https://img-blog.csdnimg.cn/2019122610572285.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjQ2Njcy,size_16,color_FFFFFF,t_70#pic_center