目录

• 一、顺序控制
• 二、选择控制
  • 2.1分支控制
    • 2.1.1单分支
    • 2.1.2双分支
    • 2.1.3分支控制if-else
    • 2.1.4嵌套分支
  • 2.2switch分支结构
    • 细节讨论
    • 练习
  • 2.3 switch和if的比较
• 三、循环控制
  • 3.1for循环
    • 3.1.1基本语法
    • 3.1.2注意事项和细节
  • 3.2while循环
    • 3.2.1注意事项和细节
  • 3.3do while循环
  • 3.4多重循环
  • 3.5跳转控制语句break
    • 3.5.1break语句标签
    • 练习
  • 3.6continue跳转控制语句
    • 3.6.1跳转控制语句-return

一、顺序控制

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

注意事项:

• Java中定义变量时采用合法的前向引用。

二、选择控制

2.1分支控制

2.1.1单分支

2.1.2双分支

2.1.3分支控制if-else

注意：

1. 多分钟可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
2. 如果有else，如果所有的条件表达式都不成立，则默认执行else代码块

2.1.4嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外 层分支。老师建议: 不要超过 3 层

---

2.2switch分支结构

1. switch关键字，表示switch分支
2. 表达式对应一个值
3. case 常量1：当表达式的值等于 常量1，就执行 语句块1
4. break：退出switch
5. 如果一个都没有匹配，就执行default

细节讨论

1.表达式数据类型，应和case 后的常量类型一致

• 或者是可以 自动转换成可以相互比较的类型，比如输入的是字符，而常量是int

2.switch(表达式) 中表达式的返回值必须是：(byte,short,int,char,enum[枚举],Sting)

3.case子句中的值必须是常量 或者常量表达式,不能是变量

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

5.如果没有写break，程序会顺序执行到switch结尾，除非遇到一个break；

• break语句用来执行一个case分支后使程序跳出switch语句块

练习

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

2) 对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100), 提示 成绩/60
3) 根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
4) 课堂练习, 提示 使 用穿透

题目1

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

import java.util.Scanner;

public class SwitchExercise{

    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        char ch = myScanner.next().charAt(0);
        switch(ch){
            case 'a':
                ch = 'A';
                System.out.println(ch);
                break;
            case 'b':
                ch = 'B';
                System.out.println(ch);
                break;
            case 'c':
                ch = 'C';
                System.out.println(ch);
                break;  
            case 'd':
                ch = 'D';
                System.out.println(ch);
                break;  
            case 'e':
                ch = 'E';
                System.out.println(ch);
                break;
            default:
                System.out.println("你的输入有误");                   
        }
    }
} 

题目2

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

import java.util.Scanner;

public class SwitchExercise01{

    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入学生的成绩:");
        double score = myScanner.nextDouble();

        //把用score/60并转换成int类型如果等于1，就是60以上及格
        //如果不等于1，就是不及格
        if(score>=0 &&score<=100){
            switch((int)score/60){
                case 1:
                    System.out.print("成绩合格");
                case 0:
                    System.out.print("成绩不合格");  
            }
        }else{
            System.out.print("输入的成绩有误");
        }
    }
} 

题目3

根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

import java.util.Scanner;

public class SwitchExercise02{

    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入月份:");
        int month = myScanner.nextInt();

        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("请输入正确的月份");
                break;  
        }
    }
} 

2.3 switch和if的比较

1. 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可 以使用，建议使用 swtich 语句
2. 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围

---

三、循环控制

3.1for循环

3.1.1基本语法

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

2. for 有四要素:

1)循环变量初始化

2)循环条件

3)循环操作

4)循环变量迭代

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

2. 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省

3.1.2注意事项和细节

1. 循环条件是返回一个布尔值的表达式
2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。

public class ForDetail{

    public static void main(String[] args){

            int i = 1;//循环变量初始化，for循环结束之后，还想使用这个i，就写在外面
            for( ; i <= 10;){
                System.out.println("Hello World!" + i);
                i++;
            }

            System.out.println(i);//11
            for(;;){//表示一个无限循环
                System.out.println("ok~");
            }
        }
    }
} 

练习

题目1：打印1~100之间所有是9的倍数的整数，并统计个数及和

//打印1~100之间所有是9的倍数的整数，并统计个数及和
public class ForExercise{

    public static void main(String[] args){
        //1.利用for循环进行搜索 for(int i=1;i<100;i++)
        //2.进行判断，如果i满足 i%9==0 则输出i的值，并利用cnt变量记录个数
        //cnt变量默认为1
        //3.求和：满足条件后，把i加到sum里面去。
        int cnt = 0;
        int sum = 0;
        for(int i =1; i <= 100; i++){
            if( i % 9 == 0 ){
                System.out.println(i);
                sum+=i;
                ++cnt;
            }
        }
        System.out.println("1~100中9的倍数的个数为： " + cnt);
        System.out.println("1~100中9的倍数和为： " + sum);
    }
} 

方法2：

//打印1~100之间所有是9的倍数的整数，并统计个数及和
public class ForExercise{

    public static void main(String[] args){
        //1.利用for循环进行搜索 for(int i=1;i<100;i++)
        //2.进行判断，如果i满足 i%9==0 则输出i的值，并利用cnt变量记录个数
        //cnt变量默认为1
        //3.求和：满足条件后，把i加到sum里面去。
        int cnt = 0;
        int sum = 0;
        int i = 9;
        int end =100;
        for(int j =1; i*j <= end; j++){
            System.out.println(i*j);
            sum+=i*j;
            ++cnt;
        }
        System.out.println("1~100中9的倍数的个数为： " + cnt);
        System.out.println("1~100中9的倍数和为： " + sum);
    }
} 

---

3.2while循环

基本形式：

3.2.1注意事项和细节

1. 循环条件是返回一个布尔值的表达式
2. while循环是先判断再执行语句

练习

题目一：打印 1—100 之间所有能被 3 整除的数 [使用 while, 老师评讲 ]

public class WhileExercise{

    public static void main(String[] args){
        //打印 1—100 之间所有能被 3 整除的数
        
        int i = 1;
        int end = 100;
        while(i<=end){
            if(i%3==0){
                System.out.println(i);
            }
            i++
        }
    }
} 

题目二：打印 40—200 之间所有的偶数 使用 while

public class WhileExercise01{

    public static void main(String[] args){
        //打印 40—200 之间所有的偶数
        int i = 40;
        int end = 200;
        while(i<=end){
            if(i%2==0){
                System.out.println(i);
            }
            i++;
        }
    }
} 

3.3do while循环

循环变量初始化;

do{ 

    循环体(语句); 

    循环变量迭代; 

}while(循环条件);

1. do while 是关键字
2. 也有循环四要素, 只是位置不一样
3. 先执行，再判断，也就是说，一定会至少执行一次
4. 最后 有一个 分号 ;
5. while 和 do..while 区别举例

练习

题目：打印 1—100 并计算 1—100的和

public class DoWhileExercise{

    public static void main(String[] args){
        //打印 1—100之并计算和
        
        int sum = 0;
        int i = 1;
        int end = 100;
        do{
            sum+=i;
            System.out.println("i=" + i);
            i++
        }while(i<=end);
        
    }
} 

题目： 统计 1---200 之间能被 5 整除但不能被 3 整除的个数

public class DoWhileExercise01{

    public static void main(String[] args){
        //统计 1---200 之间能被 5 整除但不能被 3 整除的个数
        
        int cnt = 0;
        int i = 1;
        int end = 200;
        do{
            if(i % 5 ==0 && i % 3 != 0){
                    System.out.println("i=" + i);
                    cnt++;
            }
            i++;
        }while(i<=end);
        System.out.println("cnt=" + cnt);
    }
} 

题目：如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止

import java.util.Scanner;

public class DoWhileExercise02{

    public static void main(String[] args){
        //如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止
        Scanner myScanner = new Scanner(System.in);
        char anwser = ' ';
        //方法1
        /*do{
            System.out.println("还钱吗？y/n");
            anwser = myScanner.next().charAt(0);
            if (anwser!='y') {
                System.out.println("五连鞭");
            }else{
                System.out.println("张三还钱了");
            }
        }while(anwser!='y');*/

        do{
            System.out.println("老韩使出五连鞭");
            System.out.println("老韩问：还钱吗？y/n");
            anwser = myScanner.next().charAt(0);
            System.out.println("张三的回答：" + anwser);
        }while(anwser!='y');

        System.out.println("张三还钱了");
        
    }
} 

3.4多重循环

1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。
   • 建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内 层循环，才可结束外层的当次循环，开始下一次的循环。
3. 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

练习

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

import java.util.Scanner;

public class MulForExercise01{

    public static void main(String[] args){
        //统计统计 3 个班成绩情况，每个班有 5 名同学，
        //求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
        
        Scanner myScanner = new Scanner(System.in);
        double score = 0;
        double average = 0;
        double sum = 0;
        int cnt = 0;//统计的及格人数
        double classSum;
        double classAve;

        for(int i = 1 ; i<=3; i++){
             classSum = 0;//统计各班的总分
             classAve =0;//统计各班的平均分
            for(int j = 1 ; j<=5;j++){
                System.out.println("请输如第 "+ i +"班"+ "第" +j +"个同学的成绩:");
                score = myScanner.nextDouble();
                classSum+=score;
                if(score>=60){
                    cnt++;//分数大于60的cnt+1，cnt，代表及格个数
                }
            }
            sum+=classSum;//把各班级加到sum里面去，sum位总成绩之和
            classAve= classSum/5.0;
            System.out.println("第 "+ i +"班的平均成绩是："+ classAve );
            System.out.println("============================");
            System.out.println("============================");
        }
        average = sum/15.0;
        System.out.println("三个班的平均成绩是："+ average);
        System.out.println("及格人数："+ cnt);
    }
} 

题目：九九乘法表

public class MulForExercise03{

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

题目：经典的打印金字塔

public class Stars{

    public static void main(String[] args){
    /*打印空心金字塔
        totaLeave 层数
        1.打印完整的金字塔
         1.1打印的空格
            1.1.1 每层的空格数=总层数-1
         1.2打赢*
    */  
    
        for (int i = 1;i <= 5 ; i++ ) {//i 表示层数
            
            //在输出*之前，还要输出对应空格 
            for (int k = 1; k <= 5-i; k++) {
                System.out.print(" ");
            }


            for (int j = 1; j <= i *2  - 1; j++ ) {
                System.out.print("*");
            }
            
            System.out.print("\n");
        }
    }
} 

public class Stars{

    public static void main(String[] args){
    /*打印空心金字塔
        1.打印完整的金字塔
        *           //第1层 有1个*  4个空格   
       ***          //第2层 有3个*  3个空格
      *****         //第3层 有5个*  2个空格
     *******        //第4层 有7个*  1个空格
    *********       //第5层 有9个*  0个空格
        2.打印空心金字塔
                
        *           //第1层 有1个*  当前行的第一个位置是*，最后一个位置也是*
       * *          //第2层 有2个*  当前行的第一个位置是*，最后一个位置也是*   
      *   *         //第3层 有2个*  当前行的第一个位置是*，最后一个位置也是*
     *     *        //第4层 有2个*  当前行的第一个位置是*，最后一个位置也是*
    *********       //第5层 有9个*  全部输出*
        3.先死后活
        层数变成变量
    
    */  
        int totalLevel = 20;
        for (int i = 1;i <= totalLevel ; i++ ) {//i 表示层数
            
            //在输出*之前，还要输出对应空格 
            for (int k = 1; k <= totalLevel - i ; k++) {
                System.out.print(" ");
            }
            //输出*
            for (int j = 1; j <= i * 2 - 1 ; j++ ) {
                if ( i==totalLevel||j==1||j==i*2-1) {
                    System.out.print("*");
                }else{
                    System.out.print(" ");
                }
                
            }
            //没打印完一行就换行
            System.out.print("\n");
        }
    }
} 

---

3.5跳转控制语句break

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

思路分析：

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

random() 
返回值为 double值为正号，大于等于 0.0 ，小于 1.0 

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

基本语法：
{
 break;
}

3.5.1break语句标签

1. break语句出现在多重嵌套的语句块中，可以通过标签指明要终止的是哪一层语句块BreakDetial.java

2. 标签的基本使用

lable1:{
lable2: 
    {
    
    }
}

• break语句可以指定退出哪一层
• lable1是标签，名字由程序员决定
• break 后指定到那个lable就突出到哪里
• 在实际的开发中，老韩建议尽量不使用标签
• 如果没有指定break，默认退出最近的循环体

练习

题目：1-100 以内的数求和，求出 当和 第一次大于 20 的当前数 【for + break】

public class BreakDetail{

    public static void main(String[] args){
        int i;
        int sum = 0;
        for (i = 1;i <= 100 ;i++ ) {
            sum+=i;
            if(sum > 20){
                System.out.println("第一次大于20的数="+ i);
                break;
            }
        }
    
    }
} 

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

import java.util.Scanner;

public class BreakExercise{

    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        String name = "";
        String password = "";
        int chance = 3;
        int i;
        for (i = 1; i<=3 ; i++ ) {
            System.out.print("请输入用户名:");
            name = myScanner.next();
            System.out.print("请输入密码:");
            password = myScanner.next();

            if ( "丁真".equals(name)  &&  "666".equals(password)) {
                //这样写可以避免空指针
                System.out.println("登陆成功~");
                break;
            }
            chance--;
            System.out.println("你还有" + chance + "次登陆机会");
        }
        System.out.println("程序运行结束");
    }
} 

注意：

• 字符串不能直接进行比较，要用equal进行比较
  • 格式："字符串".equals(字符串变量名)

---

3.6continue跳转控制语句

1. continue 语句用于结束本次循环，继续执行下一次循环
2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的 使用的规则一样.

import java.util.Scanner;

public class Java_Continue{

    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;
                }
                System.out.println("i = " + i);//4组 i=0,i=1
            }
        }
    }
} 

3.6.1跳转控制语句-return

return 使用在方法，表示跳出所在的方法

本章作业

public class Homework01{

    public static void main(String[] args){
        /* 
        我的思路
        int cnt = 0;
        double money = 100000;
        while(money>=1000){
            if (money>50000) {
                money-=money*0.05;

            }else{
                money-=1000;
            }
            cnt++;
        }
        System.out.println("该人可以经过" + cnt + "次路口");//62次 
        */

        double money = 100000;
        int cnt = 0;
        while(true){
            if(money>50000){
                money -= money*0.05;
                cnt++;
            }else if(money>=1000&&money<=50000){
                money -= 1000;
                cnt++;
            }else{
                break;
            }
        }
        System.out.println("可以经过" + cnt + "次路口");
    }
}