第四章 流程控制
引入
【1】流程控制的作用：
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
【2】控制语句的分类：
控制语句分为三类：顺序、选择和循环。
“顺序结构”代表“先执行a，再执行b”的逻辑。
“条件判断结构”代表“如果…，则…”的逻辑。
“循环结构”代表“如果…，则再继续…”的逻辑。
三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。
【3】流程控制的流程：
分支结构(选择结构)
if
单分支
【1】语法结构:
|
if(布尔表达式){ 语句块 } |
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示：
【2】代码：
1. public class TestIf01{
2. public static void main(String[] args){
3. //实现一个功能：给出三个数（1-6），对三个数求和计算，根据和的大小来分配不同的奖品
4. //1.给出三个数：
5. int num1 = 6;
6. int num2 = 2;
7. int num3 = 3;
8. //2.求和
9. int sum = 0;
10. sum += num1;
11. sum += num2;
12. sum += num3;
13. System.out.println("和为："+sum);
14.
15. //3.根据和判断奖品：
16. //如果和大于等于14，那么就是一等奖
17. if(sum>=14){
18. System.out.println("一等奖");
19. System.out.println("恭喜你很幸运，中了一等奖");
20. }
21.
22. if(sum>=10&&sum<14){
23. System.out.println("二等奖");
24. }
25.
26. if(sum>=6&&sum<10){
27. System.out.println("三等奖");
28. }
29.
30. if(sum<6){
31. System.out.println("四等奖");
32. }
33.
34. /*
35. if-单分支：
36. （1）结构：
37. if(条件表达式，这个表达式的结果是布尔值：要么是false，要么是true){
38. //如果上面()中的表达式返回结果是true，那么执行{}中代码
39. //如果上面()中的表达式返回结果是false ，那么不执行{}中代码
40. //PS:{}中的代码是否执行，取决于()中表达式的返回结果
41. }
42. （2）上面的代码中，我用四个单分支拼凑出四个选择，每个选择是独立的，依次判断执行的
43. （3）if后面的()中的条件，要按照自己需求尽量完善
44. （4）{}可以省略不写,但是一旦省略，这个if就只负责后面的一句话，所以我们不建议初学者省略
45. */
46. }
47.}
多分支
【1】语法结构：
|
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部分。流程图如图所示：
【2】数轴分析：
【3】代码：
1. public class TestIf02{
2. public static void main(String[] args){
3. //实现一个功能：给出三个数（1-6），对三个数求和计算，根据和的大小来分配不同的奖品
4. //1.给出三个数：
5. int num1 = 6;
6. int num2 = 4;
7. int num3 = 2;
8. //2.求和
9. int sum = 0;
10. sum += num1;
11. sum += num2;
12. sum += num3;
13. System.out.println("和为："+sum);
14.
15. //3.根据和判断奖品：
16. /*
17. 利用一个多分支
18. 【1】结构：
19. if(){
20.
21. }else if(){
22.
23. }else if(){
24.
25. }...
26. else{
27.
28. }
29. 【2】else:隐藏了一个条件，跟上面分支条件表达式相反的功能 (详见数轴分析)
30. 【3】多分支：好处：只要满足一个 分支以后，后面的分支就不需要判断了 --》效率高
31. 【4】我们写代码的时候，尽量保证else的存在--》else分支相当于“兜底”“备胎”的作用，别的分支都不走，就会走这个分支了
32. */
33. if(sum>=14){
34. System.out.println("一等奖");
35. }else if(sum>=10){//隐藏了sum<14
36. System.out.println("二等奖");
37. }else if(sum>=6){//隐藏了sum<10
38. System.out.println("三等奖");
39. }else{//隐藏了sum<6
40. System.out.println("四等奖");
41. }
42.
43.
44.
45. }
46.}
双分支
【1】语法结构:
|
if(布尔表达式){ 语句块1 }else{ 语句块2 } |
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示：
随机数
随机数：这个数在生成之前我们不确定这个数是多少，不可知
在java中依靠一个类：Math类帮助我们生成，这个类中有一个方法专门用来生成随机数：
Math.random() -------> [0.0,1.0)
Math.random()*6 ----->[0.0,6.0)
(int)(Math.random()*6) ----->[0,5]
(int)(Math.random()*6) +1 ----->[1,6]
应用到程序中：
1. int num1 = (int)(Math.random()*6) +1; 2. int num2 = (int)(Math.random()*6) +1; 3. int num3 = (int)(Math.random()*6) +1;
练习：
[32,98] - [0,66]+32 - (int)(Math.random()*67) + 32
分支的嵌套使用
分支结构练习1
练习：
会员购物时，不同积分享受的折扣不同，规则如下：
计算会员购物时获得的折扣，效果如下：
本题主要考的是 程序的优化：
1. import java.util.Scanner;
2. public class TestIf04{
3. public static void main(String[] args){
4. //1.给出积分：
5. Scanner sc = new Scanner(System.in);
6. System.out.print("请输入会员积分：");
7.
8. //先判断键盘录入的数据是不是int类型的
9. if(sc.hasNextInt()==true){//是int类型数据：
10. //将这个int类型的数据接收：
11. int score = sc.nextInt();
12. //判断这个积分是否是正数：
13. if(score>=0){
14. String discount = "";
15. //2.根据积分判断折扣：
16. if(score>=8000){
17. discount = "0.6";
18. }else if(score>=4000){
19. discount = "0.7";
20. }else if(score>=2000){
21. discount = "0.8";
22. }else{
23. discount = "0.9";
24. }
25. System.out.println("该会员享受的折扣为："+discount);
26.
27. }else{//score<0
28. System.out.println("对不起，你录入的积分是负数！不符合需求！");
29. }
30. }else{//不是int类型的数据
31. System.out.println("你录入的积分不是整数！");
32. }
33.
34. }
35.}
分支结构练习2
练习：
小朋友搬桌子：
年龄大于7岁，可以搬桌子；
如果年龄大于5岁，性别是男，可以搬桌子；
否则不可以搬动桌子，提示：你还太小了
本题主要考的是：逻辑
方式1：性别用0或者1接收：
1. import java.util.Scanner;
2. public class TestIf05{
3. public static void main(String[] args){
4. //1.录入小朋友的年龄：
5. Scanner sc = new Scanner(System.in);
6. System.out.println("请录入小朋友的年龄：");
7. int age = sc.nextInt();
8.
9. //2.根据年龄判断：
10. if(age>=7){
11. System.out.println("yes");
12. }else if(age>=5){
13. //录入小朋友的性别；
14. System.out.println("请录入小朋友的性别：男：1 女 ：0");
15. int sex = sc.nextInt();
16. if(sex==1){//男生
17. System.out.println("yes");
18. }else{//女孩
19. System.out.println("no");
20. }
21. }else{//age<5
22. System.out.println("no");
23. }
24. }
25.}
方式2：性别用男或者女接收：
1. import java.util.Scanner;
2. public class TestIf06{
3. public static void main(String[] args){
4. //1.录入小朋友的年龄：
5. Scanner sc = new Scanner(System.in);
6. System.out.println("请录入小朋友的年龄：");
7. int age = sc.nextInt();
8.
9. //2.根据年龄判断：
10. if(age>=7){
11. System.out.println("yes");
12. }else if(age>=5){
13. //录入小朋友的性别；
14. System.out.println("请录入小朋友的性别：");
15. String str = sc.next();
16. char sex = str.charAt(0);
17. if(sex=='男'){
18. System.out.println("yes");
19. }else{
20. System.out.println("no");
21. }
22. }else{//age<5
23. System.out.println("no");
24. }
25. }
26.}
switch
【1】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多分支结构的流程图如图所示：
【2】练习
1. public class TestSwitch{
2. public static void main(String[] args){
3. /*
4. 实现一个功能：
5. 根据给出的学生分数，判断学生的等级：
6. >=90 -----A
7. >=80 -----B
8. >=70 -----C
9. >=60 -----D
10. <60 -----E
11.
12. 用if分支：
13. if(score>=90){
14.
15. }else if(score>=80){
16.
17. }
18. */
19. //1.给出学生的成绩：
20. int score = 167;
21. //2.根据成绩判断学生的等级：
22. switch(score/10){
23. case 10 :
24. case 9 : System.out.println("A级");break;
25. case 8 : System.out.println("B级");break;
26. case 7 : System.out.println("C级");break;
27. case 6 : System.out.println("D级");break;
28. default:System.out.println("成绩错误");break;
29. case 5 :
30. case 4 :
31. case 3 :
32. case 2 :
33. case 1 :
34. case 0 : System.out.println("E级");break;
35.
36. }
37. /*
38. 【1】语法结构：
39. switch(){
40. case * :
41. case * :
42. .......
43. }
44. 【2】switch后面是一个()，()中表达式返回的结果是一个等值，这个等值的类型可以为：
45. int,byte,short,char,String,枚举类型
46. 【3】这个()中的等值会依次跟case后面的值进行比较，如果匹配成功，就执行:后面的代码
47. 【4】为了防止代码的“穿透”效果：在每个分支后面加上一个关键词break，遇到break这个分支就结束了
48. 【5】类似else的“兜底”“备胎”的分支：default分支
49. 【6】default分支可以写在任意的位置上，但是如果没有在最后一行，后面必须加上break关键字，
50. 如果在最后一行的话，break可以省略
51. 【7】相邻分支逻辑是一样的，那么就可以只保留最后一个分支，上面的都可以省去不写了
52. 【8】switch分支和if分支区别：
53. 表达式是等值判断的话--》if ，switch都可以
54. 如果表达式是区间判断的情况---》if最好
55. 【9】switch应用场合：就是等值判断，等值的情况比较少的情况下
56. */
57. }
58.}
循环结构
while
【1】语法结构：
|
while (布尔表达式) { 循环体; } |
在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。
while循环结构流程图如图所示:
【2】练习：1+2+3+4+5
1 public class TestWhile{
2 public static void main(String[] args){
3 //功能：1+2+3+4+5
4 //1.定义变量：
5 int num1 = 1;
6 int num2 = 2;
7 int num3 = 3;
8 int num4 = 4;
9 int num5 = 5;
10 //2.定义一个求和变量，用来接收和：
11 int sum = 0;
12 sum += num1;
13 sum += num2;
14 sum += num3;
15 sum += num4;
16 sum += num5;
17
18 //3.输出和
19 System.out.println(sum);
20 }
21 }
上述代码缺点：变量的定义个数太多了
解决：
1 public class TestWhile{
2 public static void main(String[] args){
3 //功能：1+2+3+4+5
4 //1.定义变量：
5 int num = 1;
6 //2.定义一个求和变量，用来接收和：
7 int sum = 0;
8 sum += num;
9 num++;
10 sum += num;
11 num++;
12 sum += num;
13 num++;
14 sum += num;
15 num++;
16 sum += num;
17 num++;
18
19 //3.输出和
20 System.out.println(sum);
21 }
22 }
上述代码缺点：重复写的代码太多了
解决：---》引入java中循环结构：
1 public class TestWhile{
2 public static void main(String[] args){
3 //功能：1+2+3+4+5
4 //1.定义变量：
5 int num = 1;[1]条件初始化
6 //2.定义一个求和变量，用来接收和：
7 int sum = 0;
8 while(num<=5){[2]条件判断
9 sum += num;[3]循环体
10 num++;[4]迭代
11 }
12 //3.输出和
13 System.out.println(sum);
14 }
15 }
总结：
【1】循环作用：将部分代码重复执行。
循环只是提高了程序员编写代码的效率，但是底层执行的时候依然是重复执行。
【2】循环四要素：
初始化谁，就判断谁，判断谁，就迭代谁
执行过程：[1][2][3][4] [2][3][4] [2][3][4]。。。。
【3】循环的执行过程：
【4】验证循环的执行过程：
练习
【1】1+2+3+4+5+。。。。+100
【2】2+4+6+8+。。。。+998+1000
【3】5+10+15+20+。。。+100
【4】99+97+95+。。5+3+1
【5】1*3*5*7*9*11*13
1 public class TestWhile02{
2 public static void main(String[] args){
3 /*
4 【1】1+2+3+4+5+。。。。+100
5 int i = 1;
6 int sum = 0;
7 while(i<=100){
8 sum += i;
9 i++;
10 }
11 System.out.println(sum);
12 【2】2+4+6+8+。。。。+998+1000
13 int i = 2;
14 int sum = 0;
15 while(i<=1000){
16 sum += i;
17 i = i+2;
18 }
19 System.out.println(sum);
20 【3】5+10+15+20+。。。+100
21 int i = 5;
22 int sum = 0;
23 while(i<=100){
24 sum += i;
25 i = i+5;
26 }
27 System.out.println(sum);
28
29 【4】99+97+95+。。5+3+1
30 int i = 99;
31 int sum = 0;
32 while(i>=1){
33 sum += i;
34 i = i-2;
35 }
36 System.out.println(sum);
37 【5】1*3*5*7*9*11*13
38
39 */
40 int i = 1;
41 int result = 1;
42 while(i<=13){
43 result *= i;
44 i = i+2;
45 }
46 System.out.println(result);
47 }
48 }
do-while
【1】语法结构：
|
do { 循环体; } while(布尔表达式) ; |
do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示：
【2】代码：
1 public class TestDoWhile{
2 public static void main(String[] args){
3 //1+2+3+4+...100
4 //while方式:
5 /*
6 int i = 101;
7 int sum = 0;
8 while(i<=100){
9 sum += i;
10 i++;
11 }
12 System.out.println(i);//101
13 System.out.println(sum);//0
14 */
15 //do-while方式：
16
17 int i = 101;
18 int sum = 0;
19 do{
20 sum += i;
21 i++;
22 }while(i<=100);//一定要注意写这个分号，否则编译出错
23 System.out.println(i);//102
24 System.out.println(sum);//101
25 /*
26 【1】while和do-while的区别:
27 while:先判断，再执行
28 do-while:先执行，再判断---》至少被执行一次，从第二次开始才进行判断
29 【2】什么场合使用do-while:
30
31 while(考试是否通过){
32 考试；
33 }
34 ---》不合适
35 do{
36 考试；
37 }while(考试是否通过);
38 ---》合适
39 */
40
41 }
42 }
for
【1】语法结构：
|
for (初始表达式; 布尔表达式; 迭代因子) { 循环体; } |
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
- 初始化部分设置循环变量的初值
- 条件判断部分为任意布尔表达式
- 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如图所示：
【2】代码：
1 public class TestFor01{
2 public static void main(String[] args){
3 //1+2+3+..+100
4 //while:
5 /*int i = 1;
6 int sum = 0;
7 while(i<=100){
8 sum += i;
9 i++;
10 }
11 System.out.println(sum);
12 */
13
14 //for:
15 int sum = 0;
16 int i;
17 for(i = 1;i<=100;i++){
18 sum += i;
19 }
20 System.out.println(sum);
21 System.out.println(i);
22
23 /*
24 【1】for的结构：
25 for(条件初始化;条件判断;迭代){
26 循环体；
27 }
28
29 【2】i的作用域：作用范围：离变量最近{} --->可以自己去控制
30 【3】for循环格式特别灵活：格式虽然很灵活，但是我们自己写代码的时候不建议灵活着写。
31 for(;;){} -->死循环
32
33 int i = 1;
34 for(;i<=100;){
35 sum += i;
36 i++;
37 }
38
39 【4】死循环：
40 for(;;){}
41
42 while(true){}
43
44 do{
45
46 }while(true);
47
48 【5】循环分为两大类：
49 第一类：当型 while(){} for(;;){}
50 第二类：直到型 do{}while();
51
52 【6】以后常用：for循环
53 【7】do-while,while,for循环谁的效率高？ 一样高
54 */
55 }
56 }
关键字
在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
return的作用,结束当前所在方法的执行.
break
【1】通过练习感受break的作用：作用：停止循环：
1 public class TestFor02{
2 public static void main(String[] args){
3 //功能：求1-100的和，当和第一次超过300的时候，停止程序
4 int sum = 0;
5 for(int i=1;i<=100;i++){
6 sum += i;
7 if(sum>300){//当和第一次超过300的时候
8 //停止循环
9 break;//停止循环
10 }
11 System.out.println(sum);
12 }
13
14 }
15 }
【2】加深理解：
1 public class TestFor03{
2 public static void main(String[] args){
3 //break的作用：停止最近的循环
4 /*
5 for(int i=1;i<=100;i++){
6 System.out.println(i);
7 if(i==36){
8 break;//1-36
9 }
10 }
11 */
12 for(int i=1;i<=100;i++){
13 System.out.println(i);
14 while(i==36){
15 break; //1-100 ---》break停止的是while循环，而不是外面的for循环
16 }
17 }
18 }
19 }
【3】break带标签的使用：
1 public class TestFor04{
2 public static void main(String[] args){
3 outer: ----》定义标签结束的位置
4 for(int i=1;i<=100;i++){
5 System.out.println(i);
6 while(i==36){
7 break outer; ----》根据标签来结束循环
8 }
9 }
10 }
11 }
多层循环也可以使用标签，按照自己的需求去设定即可：
continue
【1】通过案例感受continue的作用：结束本次循环，继续下一次循环
1 public class TestFor05{
2 public static void main(String[] args){
3 //功能：输出1-100中被6整除的数：
4 //方式1：
5 /*
6 for(int i=1;i<=100;i++){
7 if(i%6==0){//被6整除
8 System.out.println(i);
9 }
10 }
11 */
12
13 //方式2：
14 for(int i=1;i<=100;i++){
15 if(i%6!=0){//不被6整除
16 continue;//停止本次循环，继续下一次循环
17 }
18 System.out.println(i);
19 }
20 }
21 }
【2】加深理解：
1 public class TestFor06{
2 public static void main(String[] args){
3 //continue:结束本次离它近的循环，继续下一次循环
4 /*
5 for(int i=1;i<=100;i++){
6 if(i==36){
7 continue;//1-100中间没有36
8 }
9 System.out.println(i);
10 }
11 */
12
13 for(int i=1;i<=100;i++){
14 while(i==36){
15 System.out.println("------");
16 continue; //1-35+死循环
17 }
18 System.out.println(i);
19 }
20 }
21 }
【3】continue带标签的使用：
1 public class TestFor07{
2 public static void main(String[] args){
3
4 outer:
5 for(int i=1;i<=100;i++){
6 while(i==36){
7 continue outer; //1-100没有36
8 }
9 System.out.println(i);
10 }
11 }
12 }
return
return的作用：跟循环无关，就是程序中遇到return那么return所在的那个方法就停止执行了：
1 public class TestFor08{
2 public static void main(String[] args){
3 //return:遇到return结束当前正在执行的方法
4 for(int i=1;i<=100;i++){
5 while(i==36){
6 return;
7 }
8 System.out.println(i);
9 }
10
11 System.out.println("-----");
12 }
13 }
循环练习
【1】练习1：
1 public class TestFor09{
2 public static void main(String[] args){
3 /* 输出1-100中被5整除的数,每行输出6个*/
4 //引入一个计数器：
5 int count = 0;//初始值为0
6 for(int i=1;i<=100;i++){
7 if(i%5==0){//被5整除的数
8 System.out.print(i+"\t");
9 count++;//每在控制台输出一个数，count就加1操作
10 if(count%6==0){
11 System.out.println();//换行
12 }
13 }
14 }
15 }
16 }
【2】练习2：
1 import java.util.Scanner;
2 public class TestFor10{
3 public static void main(String[] args){
4 /*
5 实现一个功能：
6 【1】请录入10个整数，当输入的数是666的时候，退出程序。
7 【2】判断其中录入正数的个数并输出。
8 【3】判断系统的退出状态：是正常退出还是被迫退出。
9 */
10 //引入一个计数器：
11 int count = 0;
12 //引入一个布尔类型的变量：
13 boolean flag = true; //---》理解为一个“开关”，默认情况下开关是开着的
14 Scanner sc = new Scanner(System.in);
15 for(int i=1;i<=10;i++){//i:循环次数
16 System.out.println("请录入第"+i+"个数：");
17 int num = sc.nextInt();
18 if(num>0){//录入的正数
19 count++;
20 }
21 if(num==666){
22 flag = false;//当遇到666的时候，“开关”被关上了
23 //退出循环：
24 break;
25 }
26
27 }
28
29 System.out.println("你录入的正数的个数为："+count);
30
31
32 if(flag){//flag==true
33 System.out.println("正常退出！");
34 }else{//flag==false
35 System.out.println("被迫退出！");
36 }
37
38
39
40 }
41 }
循环的嵌套使用
双重循环
乘法口诀
乘法口诀：
1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
代码：
1 public class TestFor11{
2 public static void main(String[] args){
3 //1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
4 /*
5 System.out.print("1*6=6"+"\t");
6 System.out.print("2*6=12"+"\t");
7 System.out.print("3*6=18"+"\t");
8 System.out.print("4*6=24"+"\t");
9 System.out.print("5*6=30"+"\t");
10 System.out.print("6*6=36"+"\t");
11
12 for(int i=1;i<=6;i++){
13 System.out.print(i+"*6="+i*6+"\t");
14 }
15 //换行
16 System.out.println();
17
18 //1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
19 for(int i=1;i<=7;i++){
20 System.out.print(i+"*7="+i*7+"\t");
21 }
22 //换行
23 System.out.println();
24
25 //1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
26 for(int i=1;i<=8;i++){
27 System.out.print(i+"*8="+i*8+"\t");
28 }
29 //换行
30 System.out.println();
31 */
32
33 for(int j=1;j<=9;j++){
34 for(int i=1;i<=j;i++){
35 System.out.print(i+"*"+j+"="+i*j+"\t");
36 }
37 //换行
38 System.out.println();
39 }
40 }
41 }
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*4=4 2*4=8 3*4=12 4*4=16 1*3=3 2*3=6 3*3=9 1*2=2 2*2=4 1*1=1
代码：
public class TestFor12{
public static void main(String[] args){
/*
//1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
for(int i=1;i<=8;i++){
System.out.print(i+"*8="+i*8+"\t");
}
//换行
System.out.println();
//1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
for(int i=1;i<=7;i++){
System.out.print(i+"*7="+i*7+"\t");
}
//换行
System.out.println();
//1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
for(int i=1;i<=6;i++){
System.out.print(i+"*6="+i*6+"\t");
}
//换行
System.out.println();
*/
for(int j=9;j>=1;j--){
for(int i=1;i<=j;i++){
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//换行
System.out.println();
}
}
}
打印各种形状
【1】长方形：
1 for(int j=1;j<=4;j++){//j:控制行数
2 //*********
3 for(int i=1;i<=9;i++){//i:控制*的个数
4 System.out.print("*");
5 }
6 //换行：
7
【2】距离前面有一定空隙的长方形：
1 for(int j=1;j<=4;j++){//j:控制行数
2 //加入空格：
3 for(int i=1;i<=5;i++){//i:控制空格的个数
4 System.out.print(" ");
5 }
6 //*********
7 for(int i=1;i<=9;i++){//i:控制*的个数
8 System.out.print("*");
9 }
10 //换行：
11 System.out.println();
12 }
【3】平行四边形：
1 for(int j=1;j<=4;j++){//j:控制行数
2 //加入空格：
3 for(int i=1;i<=(9-j);i++){//i:控制空格的个数
4 System.out.print(" ");
5 }
6 //*********
7 for(int i=1;i<=9;i++){//i:控制*的个数
8 System.out.print("*");
9 }
10 //换行：
11 System.out.println();
12 }
【4】三角形：
1 for(int j=1;j<=4;j++){//j:控制行数
2 //加入空格：
3 for(int i=1;i<=(9-j);i++){//i:控制空格的个数
4 System.out.print(" ");
5 }
6 //*********
7 for(int i=1;i<=(2*j-1);i++){//i:控制*的个数
8 System.out.print("*");
9 }
10 //换行：
11 System.out.println();
12 }
【5】菱形：
1 //上面三角形：
2 for(int j=1;j<=4;j++){//j:控制行数
3 //加入空格：
4 for(int i=1;i<=(9-j);i++){//i:控制空格的个数
5 System.out.print(" ");
6 }
7 //*********
8 for(int i=1;i<=(2*j-1);i++){//i:控制*的个数
9 System.out.print("*");
10 }
11 //换行：
12 System.out.println();
13 }
14
15 //下面三角形：
16 for(int j=1;j<=3;j++){//j:控制行数
17 //加入空格：
18 for(int i=1;i<=(j+5);i++){//i:控制空格的个数
19 System.out.print(" ");
20 }
21 //*********
22 for(int i=1;i<=(7-2*j);i++){//i:控制*的个数
23 System.out.print("*");
24 }
25 //换行：
26 System.out.println();
27 }
【6】空心菱形：
1 //上面三角形：
2 for(int j=1;j<=4;j++){//j:控制行数
3 //加入空格：
4 for(int i=1;i<=(9-j);i++){//i:控制空格的个数
5 System.out.print(" ");
6 }
7 //*********
8 for(int i=1;i<=(2*j-1);i++){//i:控制*的个数
9 if(i==1||i==(2*j-1)){
10 System.out.print("*");
11 }else{
12 System.out.print(" ");
13 }
14 }
15 //换行：
16 System.out.println();
17 }
18
19 //下面三角形：
20 for(int j=1;j<=3;j++){//j:控制行数
21 //加入空格：
22 for(int i=1;i<=(j+5);i++){//i:控制空格的个数
23 System.out.print(" ");
24 }
25 //*********
26 for(int i=1;i<=(7-2*j);i++){//i:控制*的个数
27 if(i==1||i==(7-2*j)){
28 System.out.print("*");
29 }else{
30 System.out.print(" ");
31 }
32 }
33 //换行：
34 System.out.println();
35 }
扩展：菱形打印方式2
【1】实心菱形：
1 public class TestFor14{
2 public static void main(String[] args){
3 //先打印出一个正方形，然后某些位置上打印* 某些位置上打印空格：
4 int size = 17;
5 int startNum = size/2+1;//起始列号
6 int endNum = size/2+1;//结束列号
7 //引入一个布尔类型的变量---》理解为“开关”
8 boolean flag = true;
9 for(int j=1;j<=size;j++){
10 //*****
11 for(int i=1;i<=size;i++){
12 if(i>=startNum&&i<=endNum){
13 System.out.print("*");
14 }else{
15 System.out.print(" ");
16 }
17 }
18 //换行
19 System.out.println();
20 if(endNum==size){
21 flag = false;
22 }
23
24 if(flag){//flag是true相当于在菱形的上半侧 flag是false相当于在菱形的下半侧
25 startNum--;
26 endNum++;
27 }else{
28 startNum++;
29 endNum--;
30 }
31 }
32 }
33 }
【2】空心菱形：
1 public class TestFor14{
2 public static void main(String[] args){
3 //先打印出一个正方形，然后某些位置上打印* 某些位置上打印空格：
4 int size = 17;
5 int startNum = size/2+1;//起始列号
6 int endNum = size/2+1;//结束列号
7 //引入一个布尔类型的变量---》理解为“开关”
8 boolean flag = true;
9 for(int j=1;j<=size;j++){
10 //*****
11 for(int i=1;i<=size;i++){
12 if(i==startNum||i==endNum){
13 System.out.print("*");
14 }else{
15 System.out.print(" ");
16 }
17 }
18 //换行
19 System.out.println();
20 if(endNum==size){
21 flag = false;
22 }
23
24 if(flag){//flag是true相当于在菱形的上半侧 flag是false相当于在菱形的下半侧
25 startNum--;
26 endNum++;
27 }else{
28 startNum++;
29 endNum--;
30 }
31 }
32 }
33 }
三重循环
百钱买百鸡
【1】二重循环可以帮我们解决：二元一次方程组的问题：
1 public class TestFor15{
2 public static void main(String[] args){
3 for(int a=1;a<=5;a++){
4 for(int b=3;b<=6;b++){
5 if(a+b==7){
6 System.out.println(a+"----"+b);
7 }
8 }
9 }
10 }
11 }
【2】三重循环可以帮我们解决：三元一次方程组的问题：
1 public class TestFor16{
2 public static void main(String[] args){
3 /*
4 百钱买百鸡：
5 公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，
6 用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱。
7 数学：
8 设未知数：
9 公鸡：x只
10 母鸡：y只
11 小鸡：z只
12 x+y+z=100只
13 5x+3y+z/3=100钱
14 麻烦方式：
15 for(int x=1;x<=100;x++){
16 for(int y=1;y<=100;y++){
17 for(int z=1;z<=100;z++){
18 if((x+y+z==100)&&(5*x+3*y+z/3==100)&&(z%3==0)){
19 System.out.println(x+"\t"+y+"\t"+z);
20 }
21 }
22 }
23 }
24 */
25 //优化：
26 for(int x=1;x<=19;x++){
27 for(int y=1;y<=31;y++){
28 int z = 100-x-y;
29 if((5*x+3*y+z/3==100)&&(z%3==0)){
30 System.out.println(x+"\t"+y+"\t"+z);
31 }
32 }
33 }
34 }
35 }
标签：控制,java,String,int,流程,System,sum,public,out From： https://www.cnblogs.com/lcs-LLH/p/17825307.html