流程控制语句是用来控制程序中各语句执行顺序 的语句，可以把语句组合成能完成一定功能的小逻辑模块。
控制语句分为三类：顺序、选择 和循环。“顺序结构”代表“先执行 a，再执行 b”的逻辑。
比如，先找个女朋友，再给女朋友 打电话；先订婚，再结婚； “条件判断结构”代表“如果…，则…”的逻辑。
比如，如果女朋友来电，则迅速接电 话；如果看到红灯，则停车； “循环结构”代表“如果…，则重复执行…”的逻辑。
比如，如果没打通女朋友电话， 则再继续打一次； 如果没找到喜欢的人，则再继续找。 顺序结构即按照书写顺序执行每一条语句，比较简单，不是我们的重点。
本章研究的重 点是“选择结构”和“循环结构”。 很神奇的是，三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的 各种事情。
实际上，任何软件和程序，小到一个练习，大到一个操作系统，本质上都是由“变 量、选择语句、循环语句”组成。
这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的 逻辑结构，都可以通过它们来表达。上述两种结构组成的程序可以解决全部的问题，所以任 何一种高级语言都具备上述两种结构。
因此，本章是大家真正跨入编程界的“门槛”，是成为“程序猿”的“门票”。 本章后面会附加大量的练习，供大家提升自我。

1.1 条件判断结构

在还没有知道 Java 选择结构的时候，我们编写的程序总是从程序入口开始，顺序执行 每一条语句直到执行完最后一条语句结束，但是生活中经常需要进行条件判断，根据判断结 果决定是否做一件事情，这就需要选择结构。
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。主要的条件判 断结构有：if 结构和 switch 结构。而 if 结构又可以分为 if 单分支结构、if-else 双分支结构、 if-else if-else 多分支结构。

1.1.1 if 单分支结构

语法结构:

  if(布尔表达式){语句块 }

if 语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语 句块。流程图所示。

1. if 单分支结构（掷骰子游戏）的代码如下：

package com.txw;/*** 掷骰子游戏* @author Adair* @qq:1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class DiceGame {public static void main(String[] args) {// 通过掷三个骰子看看今天的手气如何// 通过Math.random()产生随机数int i = (int) ((6 * Math.random()) + 1);int j = (int) ((6 * Math.random()) + 1);int k = (int) ((6 * Math.random()) + 1);int count = i + j + k;// 如果三个骰子之和大于 15，则手气不错if (count > 15){System.out.println("今天手气不错");}// 如果三个骰子之和在 10 到 15 之间，则手气一般if (count >= 10 && count <= 15){  // 错误写法：10<=count<=15System.out.println("今天手气一般");}// 如果三个骰子之和小于 10，则手气不怎么样if (count < 10){System.out.println("今天手气不怎么样");}System.out.println("第一个骰子："+ i + "，第二个骰子："+ j +"，第三个骰子："+ k +"，一共得了："+ count + "分。");}
}

如图所示：

Math 类的使用：
1.java.lang 包中的 Math 类提供了一些用于数学计算的方法。 
2. Math.random()该方法用于产生 0 到 1 区间的 double 类型的随机数，但是不包括 1。 int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数

新手雷区：
1.如果 if 语句不写{}，则只能作用于后面的第一条语句。
2. 强烈建议，任何时候都写上{}，即使里面只有一句话！

1.1.2 if-else 双分支结构

语法结构:

if(布尔表达式){ 语句块 1 }else{ 语句块 2}

当布尔表达式为真时，执行语句块1，否则，执行语句块 2。也就是else部分。流程图所示：
1.if-else 双分支结构的代码如下：

package com.txw;/*** 圆面积* @author Adair* @qq:1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Circle {public static void main(String[] args) {// 随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长double r = 4 * Math.random();// Math.pow(r, 2)求半径r的平方double area = 3.14 * r;double circle = 2 * Math.PI * r;System.out.println("半径为： " + r);System.out.println("面积为： " + area);System.out.println("周长为： " + circle);// 如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积if(area >= circle) {System.out.println("面积大于等于周长");} else {System.out.println("周长大于面积");}}
}

如图所示：
2.if-else 与条件运算符的比较：使用 if-else的代码如下:

package com.txw;/*** if-else 与条件运算符的比较：使用 if-else* @author Adair* @date 2022/1/12 0012下午 2:32* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test01 {public static void main(String[] args) {int a = 3;int b = 4;int c2 = 0;if (a < b ){c2 = b;}else {c2 = a;}System.out.println(c2);}
}

如图所示：
3.if-else 与条件运算符的比较：使用条件运算符的代码如下:

package com.txw;/*** if-else 与条件运算符的比较：使用条件运算符* @author Adair* @date 2022/1/12 下午 2:40* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test02 {public static void main(String[] args) {int a = 3;int b = 4;// 返回a和b的最大值int c = a < b ? b : a;System.out.println(c);}
}

如图所示：

1.1.3 if-else if-else 多分支结构

语法结构：
if(布尔表达式 1) {语句块 1; } else if(布尔表达式 2) {语句块 2; }…… else if(布尔表达式 n){ 语句块 n; } else { 语句块 n+1; 
}

当布尔表达式 1 为真时，执行语句块 1；否则，判断布尔表达式 2，当布尔表达式 2 为 真时，执行语句块 2；否则，继续判断布尔表达式 3······；如果 1~n 个布尔表达式均判定为 假时，则执行语句块 n+1，也就是 else 部分。流程图如图所示。

1.if-else if-else 多分支结构的代码如下：

package com.txw;/*** if-else if-else 多分支结构* @author Adair* @date 2022/1/12 0012下午 3:14* @email 1578533828@qq.com*/
@SuppressWarnings("all")    // 注解警告信息
public class Test03 {public static void main(String[] args) {int age = (int) (100 * Math.random());System.out.print("年龄是" + age + "， 属于");// 15 岁以下儿童；15-24 青年；25-44 中年；45-64 中老年；65-84 老年；85 以上老 寿星if (age < 15) {System.out.println("儿童， 喜欢玩！");} else if (age < 25) {System.out.println("青年， 要学习！");} else if (age < 45) {System.out.println("中年， 要工作！");} else if (age < 65) {System.out.println("中老年， 要补钙！");} else if (age < 85) {System.out.println("老年， 多运动！");} else {System.out.println("老寿星， 古来稀！");}}
}

如图所示：

1.2 switch 语句

语法结构： 
switch (表达式) { case 值 1: 语句序列 1; [break];case 值 2: 语句序列 2; [break]; … … … … … [default: 默认语句;]
}

switch 语句会根据表达式的值从相匹配的 case 标签处开始执行，一直执行到 break 语句处或者是 switch 语句的末尾。如果表达式的值与任一 case 值不匹配，则进入 default 语句（如果存在 default 语句的情况）。
根据表达式值的不同可以执行许多不同的操作。switch 语句中 case 标签在 JDK1.5 之前必须是整数（long 类型除外）或者枚举，不能是字符串，在 JDK1.7 之后允许使用字 符串(String)。
大家要注意，当布尔表达式是等值判断的情况，可以使用 if-else if-else 多分支结构或 者 switch 结构，如果布尔表达式区间判断的情况，则只能使用 if-else if-else 多分支结构。
switch 多分支结构的流程图如图所示:

练习一的代码如下：

package com.txw.witch;/*** 练习一* @author Adair* @date 2022/1/12 下午 4:02* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test01 {public static void main(String[] args) {// grade 表示大学年级int grade = 1 ;if (grade == 1){System.out.println("大学一年级，可以放松一下，学着谈谈恋 爱");}else if (grade == 2){System.out.println("大学二年级，少玩点游戏，不空虚，不慌 嘛？");}else  if (grade == 3){System.out.println("大学三年级，专业课开始了，好好学，找 份好工作");}else{System.out.println("大四了，要毕业了。因为跟着大佬学习， 好工作搞定！");}switch (grade){case 1:System.out.println("大学一年级");break;case 2:System.out.println("大学二年级");break;case 3:System.out.println("大学三年级");break;default:System.out.println("大四了，要毕业了");break;}}
}

如图所示：
练习二的代码如下：

package com.txw.witch;/*** 练习二* @author Adair* @date 2022/1/12 下午 4:15* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test02 {public static void main(String[] args){int month = 2;  // 1 表示 1 月，2 表示 2 月，....if(month == 1 || month == 2 || month == 3){System.out.println("春季");}else if( month == 4 || month == 5 || month == 6){System.out.println("夏季");}else if( month == 7 || month == 8 || month == 9){System.out.println("秋季");}else{System.out.println("冬季");}System.out.println("========使用 switch 改造上面的代码，switch 特别适合多值判断 =============");switch (month){case 1:case 2:case 3:System.out.println("春季");break;case 4:case 5:case 6:System.out.println("夏季");break;case 7:case 8:case 9:System.out.println("秋季");break;default:System.out.println("冬季");}}
}

如图所示：
练习三的代码如下：

package com.txw.witch;/*** 练习三* @author Adair* @date 2022/1/12 下午 4:32* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test03 {public static void main(String[] args) {String str = "audi";switch (str){case "audi":System.out.println("我买了个奥迪车");break;case "benz":System.out.println("我买了个奔驰车");break;default:System.out.println("比亚迪，挺好！");}}
}

如图所示：

1.3 循环结构(while)

循环结构分两大类，一类是当型，一类是直到型。
1.当型： 当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才 停止循环，比如：while 与 for 循环。 2.直到型： 先执行某语句， 再判断布尔表达式，如果为 true，再执行某语句，如此反复，直 到布尔表达式条件为 false 时才停止循环，比如 do-while 循环。

1.3.1 while 循环

语法结构：

while (布尔表达式) { 循环体;
}

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于 后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。 while 循环结构流程图如图所示:
while 循环结构：求 1 到 100 之间的累加和的代码如下：

package com.txw.hile;/*** 练习一* @author Adair* @date 2022/1/13 下午 8:52* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test01 {public static void main(String[] args) {int i = 1;int sum = 0;// 1+2+3+...+100while (i <= 100){sum += i;   // 相当于 sum = sum + i;i ++;}System.out.println(sum);}
}

如图所示：

1.3.2 do-while 循环

语法结构：

do {循环体;
} while(布尔表达式) ;

do-while 循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行 循环体，当条件为假时结束循环。do-while 循环的循环体至少执行一次。do-while 循环结 构流程图如图所示：
do-while 循环结构：求 1-100 之间的累加和的代码如下：

package com.txw.hile;/*** do-while 循环结构：求 1-100 之间的累加和* @author Adair* @date 2022/1/13 上午 9:02* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test02 {public static void main(String[] args) {int i = 1;int sum = 0;do{sum += i;i ++;}while (i <= 100);   // 此处的；不能省略System.out.println("sum= " + sum);}
}

如图所示：
while 与 do-while 的区别的代码如下：

package com.txw.hile;/*** while 与 do-while 的区别* @author Adair* @date 2022/1/13 上午 9:06* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test03 {public static void main(String[] args) {// while 循环：先判断再执行int i = 0;while (i < 0){System.out.println(i);i ++;}System.out.println("-----");// do-while 循环：先执行再判断i = 0;do {System.out.println(i);i ++;}while (i < 0);}
}

如图所示：
练习一的代码如下：

package com.txw.hile;/*** 练习题* @author Adair* @date 2022/1/13 下午 2:50* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class test18 {public static void main(String[] args) {/*** 1.使用while循环：计算1-100之间所有数字的和，所有偶数的和，所有奇数的和。*/int i = 0;int sun = 0;// 奇数的和int sunOld = 0;// 偶数的和int sunEven = 0;while (i <= 100){sun =  sun + i;if (i % 2 ==0){sunOld +=sun;}else{sunEven += sun;}i ++;}System.out.println("1-100的和是" + sun);System.out.println("1-100偶数的和是" + sunEven);System.out.println("1-100奇数的和是" + sunOld);}
}

如图所示：
练习二的代码如下：

package com.txw.hile;/*** @author Adair* @date 2022/1/13 上午 11:33* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test15 {public static void main(String[] args) {/*** 2.使用while循环0-120之间的数字，打印出能被5整除的数字。*/int i = 0;while (i <= 120){if (i % 5 ==0){System.out.println("能被5整除的数字是"+ i);}i ++;}}
}

如图所示：
练习三的代码如下：

package com.txw.hile;/*** @author Adair* @date 2022/1/13 下午 1:44* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test16 {public static void main(String[] args) {/*** 3.使用while循环0-130之间的数字，每行显示7个数字。*/int i = 0;while (i <= 130){System.out.print(i + "\t");if ((i + 1) % 7 == 0){System.out.println();}i ++;}}
}

如图所示：

1.4 循环结构(for)

语法结构：

for (初始表达式; 布尔表达式; 迭代因子) { 循环体;
}

第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定 结果为 true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式 的“步进”，即执行迭代因子。
1.初始化部分设置循环变量的初值。
2.条件判断部分为任意布尔表达式。
3.迭代因子控制循环变量的增减 for 循环在执行条件判定后，先执行的循环体部分，再执行步进。
for 循环结构的流程图如图所示：
for 循环的代码如下：

package com.txw.hile;/*** for循环* @author Adair* @date 2022/1/13 上午 9:15* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class test04 {public static void main(String[] args) {int sum = 0;// 1.求 1-100 之间的累加和for (int i = 0; i <= 100; i ++) {sum += i;}System.out.println("Sum= " + sum);// 2.循环输出9-1之间的数for(int i = 9;i > 0;i --){System.out.print(i + "、");}System.out.println();// 3.输出90-1之间能被3整除的数for( int i = 90;i > 0;i -= 3){System.out.print(i + "、");}System.out.println();}
}

如图所示：

Java 里能用到逗号运算符的地方屈指可数，其中一处就是 for 循环的控制表达式。在 控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些 表达式均会独立执行。
逗号运算符的代码如下：

package com.txw.hile;/*** 逗号运算符* @author Adair* @date 2022/1/13 上午 9:21* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class test05 {public static void main(String[] args) {for (int i = 1, j = i + 10; i < 5; i ++, j = i * 2){System.out.println("i= " + i + " j= " + j);}}
}

如图所示：
1.无论在初始化还是在步进部分，语句都是顺序执行的。
2.尽管初始化部分可设置任意数量的定义，但都属于同一类型。
3.约定:只在 for 语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相 关的表达式。
初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开。
无限循环的代码如下:

package com.txw.hile;/*** 无限循环* @author Adair* @date 2022/1/13 上午 9:25* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test06 {public static void main(String[] args) {for (;;){   // 死循环 相当于 while(true)System.out.println("学无止路");}}
}

如图所示：
编译器将 while(true)与 for(;;)看作同一回事，都指的是无限循环。
在 for 语句的初始化部分声明的变量，其作用域为整个 for 循环体，不能在循环外部使 用该变量。
初始化变量的作用域的代码如下：

package com.txw.hile;/*** 初始化变量的作用域* @author Adair* @date 2022/1/13 上午 9:28* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test07 {public static void main(String[] args) {for (int i = 0; i < 10; i ++) {System.out.println(i + "、");}// System.out.println(i);  // 编译错误，无法访问在 for 循环中定义的变量 i}
}

如图所示：
练习题的代码如下：

package com.txw.hile;/*** 1.使用for循环，倒序打印出1-100之间的数字* 2.使用for循环，打印出从a-z的26个字母。* @author Adair* @date 2022/1/13 0013下午 3:33* @email 1578533828@qq.com*/
public class Test19 {public static void main(String[] args) {for (int i = 100; i >= 1; i--) {System.out.println(i);}char cc='a';for(int i = 0; i < 26; i ++) {// 强制类型转化char dd=(char)(cc + i);System.out.println(dd +"\t");}}
}

如图所示：

1.5 嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while 与 for 循环可以任意嵌套多层。一般工作中多见的就是两层。
嵌套循环的代码如下：

package com.txw.hile;/*** 嵌套循环* @author Adair* @date 2022/1/13 上午 9:33* @email 1578533828@qq.com*/
@SuppressWarnings("all") // 注解警告信息
public class Test08 {public static void main(String[] args) {for (int i = 0; i < 5; i++) {for (int j = 0; j < 5; j++) {System.out.print(i + " ");}System.out.println();}}
}

如图所示：
使用嵌套循环实现九九乘法表的代码如下：

package com.txw.hile;/*** 使用嵌套循环实现九九乘法表* @author Adair* @date 2022/1/13 上午 9:36* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test09 {public static void main(String[] args) {for (int i = 1; i < 10; i ++) {for (int j = 1; j <= i; j ++){System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");}System.out.println();}}
}

如图所示：

1.6 break 语句和 continue 语句

在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循 环，不执行循环中剩余的语句。
break 语句的代码如下：

package com.txw.hile;/*** 产生100以内的随机数，直到随机数为88时终止循环* @author Adair* @date 2022/1/13 上午 9:41* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test10 {public static void main(String[] args) {// 定义计数器int total = 0;System.out.println("Begin");while (true) {total ++;   // 每循环一次计数器加1int i = (int) Math.round(100 * Math.random());// 当i等于88时，退出循环if (i == 88) {break;}}// 输出循环的次数System.out.println("Game over， used " + total + " times.");}
}

如图所示：
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行 的语句，接着进行下一次是否执行循环的判定。

注意事项：
1.continue 用在 while，do-while 中，continue 语句立刻跳到循环首部，越过了当前循 环的其余部分。 
2.continue 用在 for 循环中，跳到 for 循环的迭代因子部分。

continue 语句的代码如下：

package com.txw.hile;/*** 把100~150之间不能被3整除的数输出，并且每行输出5个* @author Adair* @date 2022/1/13 上午 9:48* @email 1578533828@qq.com*/
@SuppressWarnings("all")  // 注解警告信息
public class Test11 {public static void main(String[] args) {// 定义计算器int count = 0;for (int i = 100; i < 150; i++) {// 如果是3的倍数，则跳过本次循环，继续进行下一次循环if (i % 3 == 0){continue;}// 否则（不是3的倍数），输出该数System.out.print(i + "、");count++; // 没输出一个数，计数器加1// 根据计数器判断每行是否已经输出了5个数if (count % 5 == 0) {System.out.println();}}}
}

如图所示：
带标签的 break 语句和 continue 语句 goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并 未在 Java 语言中得到正式使用；Java 没有 goto 语句。然而，在 break 和 continue 这两 个关键字的身上，我们仍然能看出一些 goto 的影子—带标签的 break 和 continue。 “
标签”是指后面跟一个冒号的标识符，例如：“label:”。对 Java 来说唯一用到标 签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另 一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们 就会中断到存在标签的地方。
在 “goto 有害”论中，最有问题的就是标签，而非 goto， 随着标签在一个程序里 数量的增多，产生错误的机会也越来越多。 但 Java 标签不会造成这方面的问题，因为它们 的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣 的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
带标签的 break 和 continue的代码如下：

package com.txw.hile;/*** 控制嵌套循环跳转(打印101-150之间所有的质数)* @author Adair* @date 2022/1/13 上午 9:54* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test12 {public static void main(String[] args) {outer: for (int i = 101; i < 150; i ++) {for (int j = 2; j < i / 2; j ++) {if (i % j == 0){continue outer;}}System.out.print(i + " ");}}
}

如图所示：
练习一的代码如下：

package com.txw.hile;import java.util.Scanner;
/*** 1.薪水计算器（学会思考，学会如何百度：尽量将上下文中相关的关键词都输入）：* (1) 通过键盘输入用户的月薪，每年是几个月薪水。* (2) 输出用户的年薪* (3) 输出一行字“如果年薪超过10万，恭喜你超越90%的国人”，“如果年薪超过20万，恭喜你超越98%的国人”。* (4) 直到键盘输入”exit”（也可以用数字 88 代替），则退出程序（使用 break 退出 循环）* (5) 输入中途，键盘输入“next”（也可以用数字 66 代替），则这个用户退出计算不 显示“恭喜..”，直接显示“重新开始计算...”，然后算下一个用户的年薪。* @author Adair* @date 2022/1/13 下午 4:24* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test20 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("我的年薪计算器小软件");System.out.println("exit[88]退出程序;next[66]计算下一个年薪");while (true){System.out.println("请输入月薪：");int monthSalary = scanner.nextInt();System.out.println("请输入一年多少个月薪资：");int months = scanner.nextInt();int yearSalary = monthSalary*months;System.out.println("请输入命令(exit[88],next[66]. 其他任意数字表示 继续执行):");int commondNum = scanner.nextInt();if(88 == commondNum){System.out.println("退出软件");break;}if(66 == commondNum){System.out.println("重新输入新的数据...");continue;}if(yearSalary > 100000 && yearSalary < 200000){System.out.println("恭喜你，超过了 90%的国人！");}if(yearSalary >= 200000){System.out.println("恭喜你，超过了 98%的国人！");}System.out.println("年薪是："+yearSalary);}}
}

如图所示：
练习二的代码如下：

package com.txw.hile;import java.util.Scanner;
/*** 2.个税计算器：* (1) 通过键盘输入用户的月薪。* (2)百度搜索个税计算的方式，计算出应缴纳的税款。* (3)直到键盘输入“exit”，则退出程序（使用 break 退出循环）* @author Adair* @date 2022/1/13 下午 4:36* @email 1578533828@qq.com*/
@SuppressWarnings("all")    // 注解警告信息
public class Test21 {public static void main(String[] args) {/*应纳税所得额=工资收入金额－各项社会保险费－起征点(5000 元)应纳税额=应纳税所得额x税率－速算扣除数级数        应纳税所得额                                税率(%) 速算扣除数1       不超过3,000元的部分                              3       02       超过3,000元至12,000元的部分                      10      2103       超过12,000元至 25,000元的部分                    20      14104       超过25,000元至 35,000元的部分                    25      26605       超过35,000元至 55,000元的部分                    30      44106       超过55,000元至 80,000元的部分                    35      71607       超过80,000元的部分                              45      15160*/Scanner scanner = new Scanner(System.in);while (true) {System.out.println("请输入月薪：");double slary = scanner.nextInt();    // 月薪double jiao = slary-5000;   // 应纳税所得额（各项社会保险费=0）double shui = 0;  // 应纳税额if (jiao < 0){System.out.println("个税起征点为 5000 元，不需要纳税");}else if(jiao <= 3000){shui = jiao * 0.03;slary -= shui;}else if (jiao <= 12000){shui= jiao * 0.1-210;slary -= shui;}else if (jiao <= 25000){shui = jiao * 0.2 - 1410;slary -= shui;}else if (jiao <= 35000){shui = jiao * 0.25 - 2660;slary -= shui;}else if (jiao <= 55000){shui = jiao * 0.3 - 4410;slary -= shui;} else if (jiao <= 80000){shui = jiao * 0.35 - 7160;slary -= shui;}else {shui = jiao * 0.45 - 15160;slary -= shui;}System.out.println(" 应 纳 税 所 得 额 ： "+jiao+" 元 \t"+" 纳 税 税 额 "+shui+"元\t"+"实发工资"+slary+"元");System.out.println("输入 exit 退出程序！其他继续计算！");String cmd =scanner.next();if(cmd.equals("exit")){System.out.println("程序结束，退出！");break;}else{continue;}}}
}

如图所示：

1.7 方法

语句块（有时叫做复合语句），是用花括号扩起的任意数量的简单 Java 语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套 在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量， 而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
语句块的代码如下：

package com.txw.hile;/*** 语句块* @author Adair* @date 2022/1/13 上午 9:59* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test13 {public static void main(String[] args) {int n; int a; {int k;// int n; // 编译错误：不能重复定义变量n} // 变量k的作用域到此为止}
}

如图所示：
方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数 (function)。
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的 抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个 个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法声明格式：

[修饰符 1 修饰符 2 …] 返回值类型 方法名(形式参数列表){ Java 语句；… … … 
}

方法的调用方式：

对象名.方法名(实参列表)

方法的详细说明：
1.形式参数：在方法声明时用于接收外界传入的数据。
2.实参：调用方法时实际传给方法的数据。
3.返回值：方法在执行完毕后返还给调用它的环境的数据。
4.返回值类型：事先约定的返回值的数据类型，如无返回值，必须指定为void。
方法的声明及调用的代码如下：

package com.txw.hile;/*** 方法的声明及调用* @author Adair* @date 2022/1/13 上午 10:04* @email 1578533828@qq.com*/
@SuppressWarnings("all")  // 注解警告信息
public class Test14 {/*** main方法：程序的入口*/public static void main(String[] args) {int num1 = 10; int num2 = 20;// 调用求和的方法：将num1与num2的值传给add方法中的n1与n2// 求完和后将结果返回，用sum接收结果int sum = add(num1, num2);System.out.println("sum = " + sum);     // 输出：sum = 30// 调用打印的方法：该方法没有返回值print();}/** * 求和的方法*/public static int add(int n1, int n2) {int sum = n1 + n2;return sum;   // 使用return返回计算的结果}/** * 打印的方法 */public static void print() {System.out.println("学无止路...");}
}

如图所示：

注意事项：
1.实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。 
2.return 语句终止方法的运行并指定要返回的数据。 
3.Java 中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)： 
3.1基本类型传递的是该数据值的copy值。
3.3引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。

方法的重载(overload)
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会 根据不同的参数自动匹配对应的方法。

 新手雷区：重载的方法，实际是完全不同的方法，只是名称相同而已！

构成方法重载的条件：

1. 不同的含义：形参类型、形参个数、形参顺序不同 。
2. 只有返回值不同不构成方法的重载 如：int a(String str){}与 void a(String str){}不构成方法重载 。
3. 只有形参的名称不同，不构成方法的重载 如：int a(String str){}与 int a(String s){}不构成方法重载。
   方法重载的代码如下：

package com.txw.hile;/*** 方法重载* @author Adair* @date 2022/1/13 上午 11:33* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test15 {public static void main(String[] args) {System.out.println(add(3, 5));      // 8System.out.println(add(3, 5, 10));       // 18System.out.println(add(3.0, 5));        // 8.0System.out.println(add(3, 5.0));        // 8.0// 我们已经见过的方法的重载System.out.println();       // 0个参数System.out.println(1);      // 参数是1个intSystem.out.println(3.0);    // 参数是1个double}/*** 求和的方法*/public static int add(int n1, int n2) {int sum = n1 + n2;return sum;}// 方法名相同，参数个数不同，构成重载public static int add(int n1, int n2, int n3) {int sum = n1 + n2 + n3;return sum;}// 方法名相同，参数类型不同，构成重载public static double add(double n1, int n2) {double sum = n1 + n2;return sum;}// 方法名相同，参数顺序不同，构成重载public static double add(int n1, double n2) {double sum = n1 + n2;return sum;}// 编译错误：只有返回值不同，不构成方法的重载/*  public static double add(int n1, int n2) {double sum = n1 + n2;return sum;}*/// 编译错误：只有参数名称不同，不构成方法的重载/* public static int add(int n2, int n1) {double sum = n1 + n2;return sum;}*/
}

如图所示：
练习一的代码如下：

package com.txw.hile;/*** 练习题* @author Adair* @date 2022/1/14 上午 9:36* @email 1578533828@qq.com*/
@SuppressWarnings("all")  // 注解警告信息
public class Test22 {public static void main(String[] args) {late(45,42000);}/*** (1)输入参数：迟到时间，月薪。* (2)处理逻辑： * ①迟到1-10分钟，警告。* ②迟到11-20分钟，罚款100元。* ③迟到21分钟-30分钟，罚款200元。* ④迟到30分钟以上，扣除半日工资。* ⑤迟到1小时以上，按照旷工计算，扣除3日工资。* (3)输出罚款金额。*/public static int late(int lateMinute,double salary) {int fakuan = 0;             // 罚款if(lateMinute < 11){System.out.println("警告！！不能迟到！！");}else if(lateMinute < 21){fakuan = 100;}else if(lateMinute < 31){fakuan = 200;}else if(lateMinute < 61){fakuan = (int)(salary / (21.75 * 2)); // 21.75指的是月平均工作日}else{fakuan = (int)(salary * 3 / (21.75));}System.out.println("迟到时间："+lateMinute+",罚款： "+fakuan);return fakuan;}
}

如图所示：

1.8 递归结构

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己 调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺 塔、快排等问题。
递归结构包括两个部分：
1 . 定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就 是递归的结束条件。
2.递归体。解答：什么时候需要调用自身方法。
使用递归求n!的代码如下：

package com.txw.hile;/*** 使用递归求n!* @author Adair* @date 2022/1/13 下午 1:44* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test16 {public static void main(String[] args) {long d1 = System.currentTimeMillis();System.out.printf("%d 阶乘的结果:%s%n", 10, factorial(10));long d2 = System.currentTimeMillis();System.out.printf("递归费时：%s%n", d2-d1);  // 耗时：32ms}/*** 求阶乘的方法*/public static int factorial(int n){if(n == 1) {      // 递归头return  1;}else{return n * factorial(n - 1);        // n! = n * (n-1)!}}
}

如图所示：
执行结果如图所示：
递归的缺陷 简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递 归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
使用循环求 n!的代码如下：

package com.txw.hile;/*** 使用循环求n!* @author Adair* @date 2022/1/13 下午 1:44* @email 1578533828@qq.com*/
@SuppressWarnings("all")   // 注解警告信息
public class Test16 {public static void main(String[] args) {long d1 = System.currentTimeMillis();int a = 10;int result = 1;while (a > 1) {result *= a * (a - 1);a -= 2;}long d2 = System.currentTimeMillis();System.out.println(result);System.out.printf("普通循环费时：%s%n", d2 - d1);}
}

如图所示：

注意事项：
1任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并 且易于理解和调试，并且不强调效率问题时，可以采用递归。 
2.在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。