目录

程序控制结构

程序流程控制介绍

顺序控制介绍

顺序控制举例和注意事项

分支控制if-else

分支控制if-else介绍

单分支

双分支

单分支和双分支练习题

多分支基本语法

多分支的流程图

案例演示

嵌套分支

基本介绍

基本语法

应用案例

switch分支结构

基本语法

解读switch

switch分支流程图

快速入门

 switch注意事项和细节讨论

switch练习

switch和if的比较

for循环控制

基本介绍

基本语法

说明

for循环执行流程分析

 注意事项和细节说明

 for循环练习

while循环控制

基本语法

说明

while循环执行流程分析​编辑

 演示

 注意事项和细节说明

while循环练习题

do..while循环控制

基本语法

说明:

do...while循环执行流程分析​编辑

演示

 注意事项和细节说明

do..while循环练习题

多重循环控制（难点!重点!)

介绍

案例

应用实例：

1、统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。

2、统计三个班及格人数,每个班有5名同学。

经典的打印金字塔

跳转控制语句-break

随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次；

思路分析

基本介绍

基本语法

break示意图

break快速入门

break注意事项和细节说明

解读

break练习题

跳转控制语句-continue

continue基本介绍

continue基本语法

continue示意图

continue快速入门

continue细节案例分析和说明

跳转控制语句-return

return介绍

---

程序控制结构

顺序控制

分支控制(if ,else, switch)

循环控制(for, while , dowhile,多重循环)

break

continue

return

程序流程控制介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌的，主要有三大流程控制语句。

1、顺序控制

2、分支控制

3、循环控制

顺序控制介绍

程序从上到下逐行地执行，中间没有任何判断和跳车转。

顺序控制举例和注意事项

Java中定义成员变量时采用合法的前向引用。如：

public class Test{
    int num1 = 12;
    int num2 = num1 + 2;
}

//错误形式:
public class Test{
    int num2 = num1 + 2;//错误
    int num1 = 12;
}

分支控制if-else

分支控制if-else介绍

让程序有选择的的执行,分支控制有三种

1、单分支

2、双分支

3、多分支

单分支

基本语法

if(条件表达式){

执行代码块;(可以有多条语句.)

}

说明：当条件表达式为ture时，就会执行{ }的代码。如果为false，就不执行。

特别说明：如果中只有一条语句，则可以不用{ }建议写上{ }

双分支

基本语法

if(条件表达式){
执行代码块1;}
else {
执行代码块2;
}

说明：当条件表达式成立，即执行代码块1，否则执行代码块2。

如果执行代码块只有一条语句，则可以省略，否则，不能省略。
 

单分支和双分支练习题

1、编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个
数小于20.0，打印两数之和。
2、定义两个变量int,判断二者的和，是否能被3又能被5整除，打印提示信息
3、判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整
除，但不能被100整除;(2)能被400整除
 

//单分支和双分支练习
public class IfExercise {
    //编写一个main方法
    public static void main(String[] args) {

        //编写程序，声明2个double型变量并赋值。
        //判断第一个数大于10.0，且第2个数小于20.0，打印两数之和
        //思路分析
        double d1 = 34.5;
        double d2 = 2.6;
        if (d1 > 10.0 && d2 < 20.0) {
            System.out.println("连个数的和=" + (d1 + d2));
        }

        //定义两个变量int,判断二者的和，
        // 是否能被3又能被5整除，打印提示信息
        //
        //思路分析
        //1.定义两个变量int num1, num2
        //2.定义一个变量int sum = num1 + num2;
        //3.sum % 3 ,5后等于0说明可以整除
        //4.使用if - else来提示对应信息
        //走代码
        int num1 = 10;
        int num2 = 1;
        int sum = num1 + num2;
        if (sum % 3 == 0 && sum % 5 == 0) {
            System.out.println(sum + "可以被3又能被5整除");
        } else {
            System.out.println(sum + "不能被3又能被5整除..");
        }

        //判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
        //(1)年份能被4整除，但不能被100整除；(2)能被400整除
        //
        //思路分析
        //1.定义int year保存年
        //2.年份能被4整除,但不能被100整除,
        //=> year % 4 == 0 && year %100 != 0
        //3．能被400整除 => year % 400== 0
        //4.上面的2和3是或的关系
        //代码实现
        int year = 2024;
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            System.out.println(year + "是 闰年");
        } else {
            System.out.println(year + "不是 闰年");
        }
    }
}

运行结果

多分支基本语法

if(条件表达式1){
执行代码块1;}
else if(条件表达式2){
执行代码块2;
}
......
else{
执行代码块n;
}

特别说明：

(1)多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有

(2)如果有else ，如果所有的条件表达式都不成立，则默认执行else代码块
 

多分支的流程图

说明：

1、当条件表达式1成立时，即执行代码块1

2、如果表达式1不成立，才去判断表达式2是否成立

3、如果表达式2成立，就执行代码块2

4、以此类推,如果所有的表达式都不成立

5、则执行else的代码块，注意，只能有一个执行入口。
 

案例演示

输入保国同志的芝麻信用分

如果：

1、信用分为100分时，输出信用极好;

2、信用分为(80，99]时，输出信用优秀;

3、信用分为[60,80]时，输出信用一般;

4、其它情况，输出信用不及格

5、请从键盘输入保国的芝麻信用分，并加以判断

import java.util.Scanner;

//单分支和双分支练习
public class IfExercise {
    //编写一个main方法
    public static void main(String[] args) {
//        输入保国同志的芝麻信用分
//        如果：
//        1、信用分为100分时，输出信用极好;
//        2、信用分为(80，99]时，输出信用优秀;
//        3、信用分为[60,80]时，输出信用一般;
//        4、其它情况，输出信用不及格
//        5、请从键盘输入保国的芝麻信用分，并加以判断
        Scanner myScanner = new Scanner(System.in);
        //接收用户输入
        System.out.println("请输入信用分(1-100)：");
        int grade = myScanner.nextInt();
        //先对输入的信用分，进行一个范围的有效判断 1-100，否则提示输入错误
        if (grade >= 1 && grade <= 100) {
            //因为有4种情况，所以使用多分支
            if (grade == 100) {
                System.out.println("信用极好");
            } else if (grade > 80 && grade <= 99) {
                System.out.println("信用优秀");
            } else if (grade > 60 && grade <= 80) {
                System.out.println("信用一般");
            } else {
                System.out.println("信用不及格");
            }
        }else {
            System.out.println("输入错误!!!!!!");
        }
    }
}

运行结果

嵌套分支

基本介绍

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议：不要超过3层(可读性不好)

基本语法

if( ){
        if( ){
            //if-else....
        }else{
            //if-else
        }
}

应用案例

参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。

提示：double score; char gender;

接收字符：char gender = scanner.next).charAt(O)

import java.util.Scanner;

public class NestedIf {
    //编写一个main方法
    public static void main(String[] args) {
//        参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。
//        并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。
//        提示：double score; char gender;
//        接收字符：char gender = scanner.next).charAt(O)
        //思路分析
        //1.创建Scanner对象,接收用户输入
        //2.接收成绩保存到double score
        //3.使用if-else 判断如果初赛成绩大于8.0进入决赛，否则提示淘汰
        //4.如果进入到决赛，再接收char gender，使用if-else 输出信息
        //代码实现=>思路-->java代码
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入该歌手的成绩");
        double score = myScanner.nextDouble();
        if (score > 8.0) {
            System.out.println("请输入性别");
            char gender = myScanner.next().charAt(0);
            if (gender == '男') {
                System.out.println("进入男子组");
            } else if (gender == '女') {
                System.out.println("进入女子组");
            } else {
                System.out.println("你的性别有误，不能参加决赛~");
            }
        } else {
            System.out.println("sorry ,你被淘汰了~");
        }

    }
}

运行结果

switch分支结构

基本语法

switch(表达式){
    case常量1:
    语句块1;
    break;
    case常量2:
    语句块2;
    break;…
    case常量n:
    语句块n;
    break;
    default:
    default语句块;
    break;
}

解读switch

1、switch关键字，表示swtich分支

2、表达式对应一个值

3、case常量1:当表达式的值等于常量1，就执行语句块1

4、break;表示退出swtich

5、如果和case常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case常量2

6、如果一个都没有匹配上，执行default

switch分支流程图

快速入门

案例

1、请编写一个程序，该程序可以接收一个字符，比如：a，b，c，d，e，f，g

2、a表示星期一，b表示星期二...

3、根据用户的输入显示相依的信息.要求使用switch语句完成

import java.util.Scanner;

public class Switch {
    //编写一个main方法
    public static void main(String[] args) {
//        1、请编写一个程序，该程序可以接收一个字符，比如：a，b，c，d，e，f，g
//        2、a表示星期一，b表示星期二...
//        3、根据用户的输入显示相依的信息.要求使用switch语句完成
        //思路分析
        //1.创建Scanner对象，接收用户输入
        //2.接收成绩保存到double score
        //3.使用if-else判断如果初赛成绩大于8.0进入决赛，否则提示淘汰
        //4.如果进入到决赛，再接收char gender，使用if-else 输出信息
        // 代码实现=〉思路-->java代码
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入一个字符(a-g)");
        char c1 = myScanner.next().charAt(0);
        //在java中,只要是有值返回，就是一个表达式
        switch (c1) {
            case 'a':
                System.out.println("今天星期一,猴子穿新衣");
                break;
            case 'b':
                System.out.println("今天星期二,猴子当小二");
                break;
            case 'c':
                System.out.println("今天星期三,猴子爬雪山..");
                break;
                //.....
            default:
                System.out.println("你输入的字符不正确,没有匹配的");
        }
        System.out.println("退出了switch，继续执行程序");
    }
}

运行结果

 switch注意事项和细节讨论

1、表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int

2、switch(表达式)中表达式的返回值必须是：(byte，short，int，char，enum，String)

double c = 1.1;
switch(c){//错误
    case 1.1 ://错误
    System.out.print1n( "ok3");
    break;
}

3、case子句中的值必须是常量，而不能是变量

4、default子句是可选的，当没有匹配的case时，执行default

5、break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾
 

switch练习

1、使用switch 把小写类型的char型转为大写(键盘输入)。只转换a，b，c，d，e。其它的输出"other"。

import java.util.Scanner;

public class SwitchExercise {
    //编写一个main方法
    public static void main(String[] args) {
//        使用switch 把小写类型的char型转为大写(键盘输入)。
//        只转换a，b，c，d，e。其它的输出"other"。
        //创建Scanner对象
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入a-e");
        char c1 = myScanner.next().charAt(0);
        switch (c1) {
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            case 'd':
                System.out.println("D");
                break;
            case 'e':
                System.out.println("E");
                break;
            default:
                System.out.println("other");
        }
    }
}

运行结果

 2、对学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。(注：输入的成绩不能大于100)，提示成绩/60

import java.util.Scanner;

public class SwitchExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        //对学生成绩大于60分的,输出"合格"。低于60分的,
        //输出"不合格"。(注:输入的成绩不能大于100)，提示成绩/60
        // 思路分析
        //1.这道题，可以使用分支来完成,但是要求使用switch
        //2.这里我们需要进行一个转换,编程思路∶
        //  如果成绩在[60,100] , (int)(成绩/60）=1
        //  如果成绩在[0,60) , (int)(成绩/60)=0
        //代码实现
        double score = myScanner.nextDouble();
        //使用if-else 保证输入的成绩有有效的0-100
        if (score >= 0 && score <= 100) {
            switch ((int) (score / 60)) {
                case 0:
                    System.out.println("不合格");
                    break;
                case 1:
                    System.out.println("合格");
                    break;
//                default:
//                    System.out.println("输入有误");
            }
        } else {
            System.out.println("输入成绩在0-100");
        }
    }
}

运行结果

 3、根据用于指定月份，打印该月份所属的季节。3，4，5春季6，7，8夏季9，10，11秋季12，1，2冬季[提示使用穿透]

import java.util.Scanner;

public class SwitchExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入月份");

        int month = myScanner.nextInt();
        //使用if-else 保证输入的成绩有有效的0-12
        if (month >= 0 && month <= 12) {
            switch (month) {
                case 3:
                case 4:
                case 5:
                    System.out.println("春天");
                    break;
                case 6:
                case 7:
                case 8:
                    System.out.println("夏天");
                    break;
                case 9:
                case 10:
                case 11:
                    System.out.println("秋天");
                    break;
                case 12:
                case 1:
                case 2:
                    System.out.println("冬天");
                    break;
                default:
                    System.out.println("输入有误");
            }
        } else {
            System.out.println("输入成绩在0-12");
        }
    }
}

运行结果

switch和if的比较

1、如果判断的具体数值不多，而且符合byte、short、int、char、enum[枚举]、String这6种类型。虽然两个语句都可以使用，建议使用swtich语句。

2、其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

for循环控制

基本介绍

让代码可以循环执行

基本语法

for(循环变量初始化;循环条件;循环变量迭代){
循环操作(可以多条语句);
}

说明

1、for关键字，表示循环控制

2、for有四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代

3、循环操作，这里可以有多条语句，也就是我们要循环执行的代码

4、如果循环操作(语句)只有一条语句，可以省略建议不要省略
 

for循环执行流程分析

public class ForTest {
    //编写一个main方法
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("hello world!!!" + i);
        }
    }
}

运行结果

 注意事项和细节说明

1、循环条件是返回一个布尔值的表达式

2、for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

3、循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

4、使用内存分析法，分析输出下面代码输出什么?

public class ForDetail {
    //编写一个main方法
    public static void main(String[] args) {
        int count = 3;
        for (int i = 0, j = 0; i <= count; i++, j += 2) {
            System.out.println("i=" + i + "j=" + j);
        }
    }
}

运行结果

 for循环练习

1、打印1~100之间所有是9的倍数的整数，统计个数及总和。[化繁为简,先死后活]

2、完成下面的表达式输出

public class ForExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //打印1~100之间所有是9的倍数的整数，统计个数 及总和·[化繁为简,先死后活]
        //老韩的两个编程思想(技巧)
        //1、化繁为简：即将复杂的需求，拆解成简单的需求，逐步完成
        //2、先死后活：先考虑固定的值，然后转成可以灵活变化的值
        //
        //思路分析
        //打印1~100之间所有是9的倍数的整数，统计个数及总和
        // 化繁为简
        //(1）完成输出1-100的值
        int count = 0;//统计9的倍数个数 变量
        int sum = 0;//总和
        int start = 0;
        int end = 100;
        int t = 9;//倍数
        for (int i = start; i <= end; i++) {
            if (i % t == 0) {
                System.out.println("i=" + i);
                count++;
                sum += i;
            }
        }
        System.out.println("count=" + count);
        System.out.println("sum=" + sum);
    }
}

 运行结果

public class ForExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //完成下面表达式的输出
        int num = 5;
        for (int i = 0; i <= num; i++) {
            System.out.println(i + "+" + (num - i) + "=" + num);
        }
    }
}

运行结果

while循环控制

基本语法

循环变量初始化;
while(循环条件){
    
    循环体(语句);
    循环变量迭代;
}

说明

1、 while循环也有四要素

2、只是四要素放的位置，不一样。

while循环执行流程分析

 演示

public class While {
    //编写一个main方法
    public static void main(String[] args) {
        //输出10句hello world
        int i = 1;//循环变量初始化
        int t = 4;
        while (i <= t) {//循环条件
            System.out.println("hello world" + i);
            i++;//循环变量迭代
        }
        System.out.println("退出while ,继续..");
    }
}

运行结果

 注意事项和细节说明

1、循环条件是返回一个布尔值的表达式

2、while循环是先判断再执行语句

while循环练习题

1、打印1—100之间所有能被33整除的数[使用while]

public class WhileExercise {
    //编写一个main方法
    public static void main(String[] args) {

        int i = 1;//循环变量初始化
        int t = 100;
        int n = 33;
        while (i <= t) {//循环条件
            if (i % n == 0) {
                System.out.println("能被33整除的有" + i);
            }
            i++;//循环变量迭代
        }
        System.out.println("退出while ,继续..");
    }
}

运行结果

2、打印40—200之间所有的偶数[使用while]

public class WhileExercise {
    //编写一个main方法
    public static void main(String[] args) {

        int start = 40;
        int end = 200;
        while (start <= end) {//循环条件
            if (start % 2 == 0) {
                System.out.println("偶数为" + start);
            }
            start++;//循环变量迭代
        }
        System.out.println("退出while ,继续..");
    }
}

运行结果

do..while循环控制

基本语法

循环变量初始化;
do{
    循环体(语句);
    循环变量迭代;
}while(循环条件);

说明:

1、do while是关键字

1、也有循环四要素，只是位置不一样

2、先执行，再判断，也就是说，一定会执行一次

3、最后有一个分号;

4、while和do..while区别举例:要账

do...while循环执行流程分析

演示

public class DoWhile {
    //编写一个main方法
    public static void main(String[] args) {

        int i = 1;
        do {
            //循环执行语句
            System.out.println("hello world~~~" + i);
            //循环变量迭代
            i++;
        } while (i <= 10);
        System.out.println("退出do...while ,继续..");
        System.out.println("i=" + i);
    }
}

运行结果

 注意事项和细节说明

1、循环条件是返回一个布尔值的表达式

2、do..while循环是先执行，再判断，因此它至少执行一次

do..while循环练习题

1、打印1—100

2、计算1—100的和

3、统计1—200之间能被5整除但不能被3整除的个数

public class DoWhileExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //统计1—200之间能被5整除但不能被3整除的个数
        int i = 1;
        int sum = 0;
        int a = 5;
        int b = 3;
        int num = 200;
        do {
            if (i % a == 0 && i % b != 0) {
                //循环执行语句
                System.out.println("i=" + i);
                sum++;
            }
            i++;//循环变量迭代
        } while (i <= num);
        System.out.println("sum=" + sum);
    }
}

运行结果

4、如果李三不还钱，则将一直使出五连鞭，直到李三说还钱为止
 

import java.util.Scanner;

public class DoWhileExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //如果李三不还钱，则将一直使出五连鞭，直到李三说还钱为止
        //[System.out.println("问:还钱吗?y/n")]do...while ..
        Scanner myScanner = new Scanner(System.in);
        char answer = ' ';
        do {
            //循环执行语句
            System.out.println("使出五连鞭");
            System.out.println("问:还钱吗?y/n");
            answer = myScanner.next().charAt(0);
            System.out.println("他的回答是" + answer);
        } while (answer != 'y');
        System.out.println("李三还钱了");
    }
}

运行结果

多重循环控制（难点!重点!)

介绍

1、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do..while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层.否则，代码的可读性很差】

2、实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[案例]。

3、设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次

案例

public class DoWhileExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //
        for (int i = 0; i < 2; i++) {//第一层循环2
            for (int j = 0; j < 3; j++) {//第二层循环3
                System.out.println("i =" + i + "j=" + j);//2*3=6
            }
        }
    }
}

 运行结果

应用实例：

1、统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。

2、统计三个班及格人数,每个班有5名同学。

import java.util.Scanner;

public class MulForExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //统计3个班成绩情况，每个班有5名同学，
        // 求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
        //统计三个班级及格人数，每个班有5名同学
        //
        //思路分析
        //化繁为简
        //(1) 先计算一个班，5个学生的成绩和平均分，使用for
        //1.1 创建 Scanner 对象然后，接收用户输入
        //1.2 得到该班级的平均分，定义一个 double sum 把该班级5个学生的成绩累计

        //(2)统计3个班(每个班5个学生) 平均分
        //(3)所有班级的平均分
        //3.1 定义一个变量， double totalScore 累计所有学生的成绩
        //3.2 当多循环结束后， totalScore / (3 * 5)
        //(4)统计三个班及格人数
        //4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60，passNum++
        //4.2 如果 >=60 passNum++
        //(5) 可以优化[效率，可读性，结构]

        //创建 Scanner 对象
        Scanner myScanner = new Scanner(System.in);
        double totalScore = 0;
        int passNum = 0;
        for (int i = 1; i <= 3; i++) {
            double sum = 0;//一个班级的总分
            for (int j = 1; j <= 5; j++) {
                System.out.println("请输入第" + i + "个班的第" + j + "个学生的成绩");
                double score = myScanner.nextDouble();
                //当有一个学生成绩>=60，passNum++
                if (score >= 60) {
                    passNum++;
                }
                sum += score;//累计
                System.out.println("成绩为" + score);
            }

            //因为sum 是5个学生的总成绩
            System.out.println("sum=" + sum + "平均分" + (sum / 5));
            totalScore += sum;
        }
        System.out.println("三个班总分=" + totalScore + "平均分=" + (totalScore / 15));
        System.out.println("及格人数=" + passNum);
    }
}

运行结果

3、打印出九九乘法表

经典的打印金字塔

使用for循环完成下面的案例

请编写一个程序，可以接收一个整数，表示层数(totalLevel)，打印出金字塔。

[化繁为简，先死后活]

public class Stars {
    //编写一个main方法
    public static void main(String[] args) {
       /*
             *
           *  *
          *    *
         ********

         思路分析
         * 思路分析
         * 化繁为简
         1.先打印一个矩形
           *****
           *****
           *****
           *****
           *****
          2.打印半个金字塔
          *         //第1层 有 1个*
          **        //第2层 有 2个*
          ***       //第3层 有 3个*
          ****      //第4层 有 4个*
          *****     //第5层 有 5个*
          3.打印整个金字塔
          *         //第1层 有 1个*     2 * 1 - 1   有4=(总层数-1)个空格
         ***        //第2层 有 3个*     2 * 2 - 1   有3=(总层数-2)个空格
        *****       //第3层 有 5个*     2 * 3 - 1   有2=(总层数-3)个空格
       *******      //第4层 有 7个*     2 * 4 - 1   有1=(总层数-4)个空格
      *********     //第5层 有 9个*     2 * 5 - 1   有0=(总层数-5)个空格

          4.打印空心的金字塔
          *         //第1层 有 1个*     当前行的第一个位置是*，最后一个位置也是*
         * *        //第2层 有 2个*     当前行的第一个位置是*，最后一个位置也是*
        *   *       //第3层 有 2个*     当前行的第一个位置是*，最后一个位置也是*
       *     *      //第4层 有 2个*     当前行的第一个位置是*，最后一个位置也是*
      *********     //第5层 有 9个*     全部输出*
          5.先死后活    层数做成变量 int totalLevel = 5;
        */
        int totalLevel = 10;//层数
        for (int i = 1; i <= totalLevel; i++) {//i 表示层数

            //在输出*之前，还有输出 对应空格 = 总层数 - 当前层、
            for (int k = 1; k <= totalLevel - i; k++) {
                System.out.print(" ");
            }

            //控制打印每层的*个数
            for (int j = 1; j <= 2 * i - 1; j++) {
                //当前行的第一个位置是*，最后一个位置也是*
                if (j == 1 || j == 2 * i - 1 || i == totalLevel) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //每打印完一层的*后，就换行
            System.out.println("");
        }
    }
}

运行结果

跳转控制语句-break

看需求

随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次；

提示使用(int) (Math.random()*100)+1

思路分析

循环，但是循环的次数不知道，-> break ,当某个条件满足时，终止循环通过该需求可以说明其它流程控制的必要性，比如break

基本介绍

break语句用于终止某个语句块的执行，一般使用在switch或者循环[for , while , do-while]中

基本语法

{   ......
    break;
    ......
}

break示意图

break快速入门

public class BreakTest {
    //编写一个main方法
    public static void main(String[] args) {
        //测试代码
        for (int i = 0; i < 10; i++) {
            if (i == 3) {
                break;
            }
            System.out.println("i=" + i);
        }
        System.out.println("退出for循环，继续执行..");
        // ......
    }
}

运行结果

break注意事项和细节说明

1、break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块

2、标签的基本使用

label1: {    ......
label2:     {    ......
label3:         {    ......
                    break;
                     ......
                }
            }
        }

public class BreakDetail {
    //编写一个main方法
    public static void main(String[] args) {
        abc1:
        for (int j = 0; j < 4; j++) {//外层for
            abc2:
            for (int i = 0; i < 10; i++) {//内层for
                if (i == 2) {
                    // break;//等价break abc2
                    break abc1;
                }
                System.out.println("i =" + i);
            }
        }
    }
}

运行结果

解读

(1) break语句可以指定退出哪层

(2) label1是标签，名字由程序员指定

(3)break后指定到哪个label 就退出到哪里

(4)在实际的开发中，老韩尽量不要使用标签

(5)如果没有指定break,默认退出最近的循环体

break练习题

1、1-100以内的数求和,求出当和第一次大于20的当前数【for + break】

public class BreakExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //1-100以内的数求和,求出当和第一次大于20的当前数【for + break】

        //思路分析
        //1.循环 1-100，求和 sum
        //2.当 sum > 20 时，记录下当前的数，然后break
        //3.在for循环外部，定义变量n，把当前i赋给n

        //注意i的作用范围 for{}
        int sum = 0;//累计求和
        int n = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;//累计
            if (sum > 20) {
                System.out.println("和>20的时候 当前数i=" + i);
                n = i;
                break;
            }
        }
        System.out.println("当前数=" + n);
    }
}

运行结果

2、实现登录验证，有3次机会，如果用户名为"丁真"，密码"666"提示登录成功，否则提示还有几次机会,请使用for+ break完成
 

import java.util.Scanner;

public class BreakExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //实现登录验证，有3次机会，如果用户名为"丁真"，密码"666"提示登录成功，
        //否则提示还有几次机会,请使用for+ break完成

        //思路分析
        //1.创建Scanner对象接收用户输入
        //2.定义String name; String passwd;
        //3.最多循环3次[登录3次]，如果 满足条件就提前退出
        //4.定义一个变量 int chance 记录还有几次登录机会

        Scanner myScanner = new Scanner(System.in);
        String name = "";
        String passwd = "";
        int chance = 3;//登录一次，就减少一次
        for (int i = 1; i <= 3; i++) {
            System.out.println("请输入名字");
            name = myScanner.next();
            System.out.println("请输入密码");
            passwd = myScanner.next();
            //比较输入的名字和密码是否正确
            //补充说明字符串的内容 比较 使用的 方法 equals
            if ("丁真".equals(name) && "666".equals(passwd)) {
                System.out.println("恭喜你，登陆成功~~~");
                break;
            }

            //登录的机会就会减少一次
            chance--;
            System.out.println("你还有" + chance + "次登录机会");
        }
    }
}

运行结果

跳转控制语句-continue

continue基本介绍

1、continue语句用于结束本次循环，继续执行下一次循环。

2、continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样。

continue基本语法

{   ......
    continue;
    ......
}

continue示意图

continue快速入门

public class Continue {
    //编写一个main方法
    public static void main(String[] args) {
        //代码
        int i = 1;
        while (i <= 4) {
            i++;
            if (i == 2) {
                continue;
            }
            System.out.println("i=" + i);
        }
    }
}

运行结果

continue细节案例分析和说明

public class ContinueDetail {
    //编写一个main方法
    public static void main(String[] args) {
        label1:
        for (int j = 0; j < 4; j++) {
            label2:
            for (int i = 0; i < 10; i++) {
                if (i == 2) {
                    //看看分别输出什么值,并分析
                    continue;// 等价于 continue label2
                    //continue label1;//输出 2次[0,1]
                }
                System.out.println("i = " + i);
            }
        }

    }
}

运行结果

跳转控制语句-return

return介绍

return使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果return写在main方法，退出程序..

public class Return {
    //编写一个main方法
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("Hello~~~" + i);
                //break;
                //continue;
                return;//当return用在方法时，表示跳出方法，如果使用在main,表示退出程序
            }
            System.out.println("Hello World !!!");
        }
        System.out.println("go on..");
    }
}

运行结果

最后

以上就是内向砖头为你收集整理的Java笔记007-程序控制结构/if-else/switch/for/while/do-while/多重循环控制(break/continue/return)程序控制结构分支控制if-elseswitch分支结构switch和if的比较for循环控制while循环控制do..while循环控制多重循环控制（难点!重点!)的全部内容，希望文章能够帮你解决Java笔记007-程序控制结构/if-else/switch/for/while/do-while/多重循环控制(break/continue/return)程序控制结构分支控制if-elseswitch分支结构switch和if的比较for循环控制while循环控制do..while循环控制多重循环控制（难点!重点!)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。