[学习交流] 【石家庄校区】java基础班day03-流程控制语句

本帖最后由 xiekai_sjz 于 2018-9-7 14:59 编辑

day03 流程控制语句
   今天我们来学习流程控制语句，就是控制代码执行顺序的语句。
以下是今天的学习目标：
理解if语句的格式和执行流程
理解if...else语句的格式和执行流程
理解if...else if语句的格式和执行流程
了解if语句和三元运算符互换
理解switch选择语句的格式和执行流程
了解switch选择语句接收的数据类型
了解case的穿透性
理解while语句的格式和执行流程
理解for语句的格式和执行流程
理解do...while语句的格式和执行流程
了解do...while循环的特点
了解跳出语句break，continue的意义
理解嵌套for循环的执行流程

以下是今天的详细笔记：

流程控制语句流程: 语句执行的先后顺序
Java中3种语句的执行流程:
      1. 顺序结构
      2. 选择结构
            1. if 判断语句
      2. switch 选择语句
      3. 循环结构
            1. for 循环语句
            2. while 循环语句
            3. do while 循环语句
顺序结构
顺序结构: 在方法(代码块)中, 从上往下依次执行

[Java] 纯文本查看 复制代码

public class Test {
    // 方法中的代码从上往下执行
    public static void main(String[] args) {
        eat();
        eat();
    }   
    
    // 方法中的代码从上往下执行
    public static void eat() {
        System.out.println("吃");
        System.out.println("喝");
        System.out.println("买单");
    }
}

选择结构判断语句
if格式1: if
if语句的第一种格式: 适用于1种情况的判断

if (关系表达式) {  // false
      语句体
}

// 理解方式
如果 (这句话是真的) 那么{
      执行这里的代码
}

[Java] 纯文本查看 复制代码

// 说出结果
public class Test {
    public static void main(String[] args) {
        int money = 10;
        if (money == 0) {  // false
            System.out.println("没钱了");
        }
        
        boolean isLate = true;  // 迟到了
        if (!isLate) {  // 没/不
            System.out.println("买早餐");
        }
    }
}

格式2: if...else
if语句的第2种格式: 适用于2种情况的判断, 肯定会执行其中一种情况

if (关系表达式) {
      语句体1
} else {
      语句体2
}

// 理解方式
如果 (这句话是真的) 那么{
      执行这里的代码
} 否则 {
      执行这里的代码
}

[Java] 纯文本查看 复制代码

// 说出结果
public class Test {
    public static void main(String[] args) {
        int money = 0;
        if (money == 0) {  // true
            System.out.println("没钱了");
        } else {
            System.out.println("买买买");
        }
        
        boolean isLate = true;  // 迟到了
        if (isLate) {
            System.out.println("喝水");
        } else {
            System.out.println("买早餐");
        }
    }
}

格式3: if...else if...else
if语句的第3种格式: 适用于多种情况的判断

if (关系表达式1) {
      语句体1
} else if (关系表达式2) {
      语句体2
}
...
      } else if (关系表达式n) {
      语句体n
} else {
      语句体n+1
}

// 理解方式
如果 (这句话是真的) 那么{
      执行这里的代码
} 否则, 如果 (这句话是真的) 那么{
      执行这里的代码
}
...
      } 否则, 如果 (这句话是真的) 那么{
      执行这里的代码
} 否则 {
      执行这里的代码
}

[Java] 纯文本查看 复制代码

// 说出结果
public class Test {
    public static void main(String[] args) {
        int money = -10;
        if (money == 0) {
            System.out.println("没钱了");
        } else if (money > 0 && money < 1000) {
            System.out.println("买自行车");
        } else if (money >= 1000 && money < 10000) {
            System.out.println("买电动车");
        } else if (money >= 10000 && money < 1000000) {
            System.out.println("买汽车");
        } else {
            System.out.println("欠钱了");
        }
    }
}

实际上最完整的格式是第三种 if...else if...else , 其他格式都是省略了其中某个部分, 最后的 else {} 也可以省略:

[Java] 纯文本查看 复制代码

// 1 省略 else if 和 else
if () {  
}

// 2 省略 else if
if () {   
} else {   
}

// 3 完整格式
if () {  
} else if () {  
} else if () {  
} else {  
}

// 4 省略 else
if () {
} else if () {    
} else if () {    
}

练习演示: 用if语句实现考试成绩划分
需求: 定义变量作为考试成绩，使用if语句判断成绩, 输出学生等级
      90-100 优秀
      80-89 好
      70-79 良
      60-69 及格
      60 以下不及格
      对于不正常分数的处理(大于100, 小于0)
代码:

[Java] 纯文本查看 复制代码

/*
需求: 定义变量作为考试成绩，使用if语句判断成绩, 输出学生等级
        90-100 优秀
        80-89 好
        70-79 良
        60-69 及格
        60 以下 不及格
        对于不正常分数的处理(大于100, 小于0)
*/
public class Test {
        public static void main(String[] args) {
                // 定义分数变量
                int score = 1000;
                
                // 通过if...else if...else判断分数范围
                if (score >= 90 && score <= 100) {
                        System.out.println("优秀");
                } else if (score >= 80 && score <= 89) {
                        System.out.println("好");
                } else if (score >= 70 && score <= 79) {
                        System.out.println("良");
                } else if (score >= 60 && score <= 69) {
                        System.out.println("及格");
                } else if (score >= 0 && score <= 59) {
                        System.out.println("不及格");
                } else {
                        System.out.println("分数有误");
                }
        }
}

练习演示: if与三元运算符的互换
如果是二者选其一的判断, 是可以互换的

[Java] 纯文本查看 复制代码

public class TestIf{
        public static void main(String[] args){
                //使用三元运算符计算两个数中的最大值
                int a = 10;
                int b = 20;
                int max = (a>b)?a:b;
                System.out.println("两个数中的最大值是："+max);
                //使用if格式计算两个数中的最大值
                int max1;
                if(a>b){
                        max1 = a;
                }else{
                        max1 = b;
                }
                System.out.println("两个数中的最大值是："+max1);
        }
}

选择语句switchswitch语句
switch语句的格式: 适用于多个具体值的选择

switch (表达式) {
      case 常量值1:
         语句体1;
         break;
      case 常量值2:
         语句体2;
         break;
      ...
      default:
         语句体n+1;
         break;  // 当default在switch中的最下面时, 其中的break可以省略不写
}

switch语句的注意事项
注意事项：
      1. 多个 case 后面的数值不可以重复
      2. switch 后面小括号当中只能是下列数据类型：
            基本数据类型: byte, short, char, int
            引用数据类型: JDK 5 开始支持enum枚举, JDK 7 开始支持 String 字符串
      3. switch 语句格式可以很灵活：
            case 和 default 前后顺序可以颠倒
            break 语句可以省略
            case穿透: 在switch语句中，如果case的后面不写break，则不会再判下一个case的值，而是直接向下运行，直到遇到break或者switch结束

5分钟练习: switch语句输出月份
需求:
定义变量 String month = "五月"; 代表月份
使用switch语句判断month变量的值属于什么季节?
      三月, 四月, 五月输出春季
      六月, 七月, 八月输出夏季
      九月, 十月, 十一月输出秋季
      十二月, 一月, 二月输出冬季
      其他值提示输出错误
      看看是否能利用case穿透简化代码
代码:

[Java] 纯文本查看 复制代码

/*
需求: 
定义变量 String month = "五月"; 代表月份
使用switch语句判断month变量的值属于什么季节?
        三月, 四月, 五月 输出春季
        六月, 七月, 八月 输出夏季
        九月, 十月, 十一月 输出秋季
        十二月, 一月, 二月 输出冬季
        其他值提示输出错误
        看看是否能利用case穿透简化代码
*/
public class Test {
        public static void main(String[] args) {
                // 定义月份变量
                String month = "四月";
                
                // 普通写法
                /*switch (month) {
                        case "三月":
                                System.out.println("春季");
                                break;
                        case "四月":
                                System.out.println("春季");
                                break;
                        case "五月":
                                System.out.println("春季");
                                break;
                        case "六月":
                                System.out.println("夏季");
                                break;
                        case "七月":
                                System.out.println("夏季");
                                break;
                        case "八月":
                                System.out.println("夏季");
                                break;
                        case "九月":
                                System.out.println("秋季");
                                break;
                        case "十月":
                                System.out.println("秋季");
                                break;
                        case "十一月":
                                System.out.println("秋季");
                                break;
                        case "十二月":
                                System.out.println("冬季");
                                break;
                        case "一月":
                                System.out.println("冬季");
                                break;
                        case "二月":
                                System.out.println("冬季");
                                break;
                        default: 
                                System.out.println("错误");
                                break;
                }*/
                
                // 利用case穿透简化代码
                switch (month) {
                        case "三月":
                        case "四月":
                        case "五月":
                                System.out.println("春季");
                                break;
                        case "六月":
                        case "七月":
                        case "八月":
                                System.out.println("夏季");
                                break;
                        case "九月":
                        case "十月":
                        case "十一月":
                                System.out.println("秋季");
                                break;
                        case "十二月":
                        case "一月":
                        case "二月":
                                System.out.println("冬季");
                                break;
                        default: 
                                System.out.println("错误");
                                break;
                }
        }
}

循环结构
循环概述与基本组成部分
循环: 让程序重复执行某些代码, 可以指定循环次数, 也可以在某种情况下停止, 还可以无限循环
循环结构的4个组成部分:
1. 初始化语句: 在循环开始最初执行，而且只做唯一一次                         最开始执行一次
2. 条件判断  : 如果成立，则循环继续；如果不成立，则循环退出                每次循环前执行
3. 循环体 : 重复要做的事情内容，若干行语句                            循环时执行
4. 步进语句  : 每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次每次循环后执行
for循环
for循环的格式: 适用于知道循环次数的场景
for (初始化表达式①; 布尔表达式②; 步进表达式④) {
      循环体③
}

[Java] 纯文本查看 复制代码

// 说出以下代码的执行流程和结果:
public class Test {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {  // 6
            System.out.println("你是最棒的!" + i);
        }
    }
}

你是最棒的!1
你是最棒的!2
你是最棒的!3
你是最棒的!4
你是最棒的!5

[Java] 纯文本查看 复制代码

// 说出以下代码的执行流程和结果:
public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("你是最棒的!" + i);
        }
    }
}

你是最棒的!0
你是最棒的!1
你是最棒的!2
你是最棒的!3
你是最棒的!4

[Java] 纯文本查看 复制代码

// 说出以下代码的执行流程和结果:
public class Test {
    public static void main(String[] args) {
        for (int i = 5; i > 0; i--) { // 0
            System.out.println("你是最棒的!" + i);
        }
    }
}

你是最棒的!5
你是最棒的!4
你是最棒的!3
你是最棒的!2
你是最棒的!1

[Java] 纯文本查看 复制代码

// 说出以下代码的执行流程和结果:
public class Test {
    public static void main(String[] args) {
        for (int i = 5; i < 0; i--) {
            System.out.println("你是最棒的!" + i);
        }
    }
}

5分钟练习: 使用for循环打印1-100的数字
需求: 使用for循环打印1-100的数字
代码:

[Java] 纯文本查看 复制代码

/*
使用for循环打印1-100的数字
*/
public class Test {
        public static void main(String[] args) {
                // 利用for循环产生1-100的数字
                for (int i = 1; i <= 100; i++) {
                        System.out.println(i);
                }
        }
}

while循环
while循环的标准格式: 适用于不知道循环次数的场景
while (条件判断) {
      循环体
}
// 理解方式
当 (这句话是真的时) {
      执行这里的代码
}

while循环的扩展格式: 可以和for循环相互转换

初始化语句;
while (条件判断) {
      循环体;
      步进语句;
}

[Java] 纯文本查看 复制代码

// 说出以下代码的执行流程和结果
public class Test {
    public static void main(String[] args) {
        boolean b = false;
        while (b) {
            System.out.println("会输出吗?");
        }
    }
}


// 说出以下代码的执行流程和结果
public class Test {
    public static void main(String[] args) {
        int age = 15;
        while (age <= 18) {
            System.out.println("祝我" + age + "岁生日快乐!");
            age++;
        }
    }
}

do...while循环
do while循环的标准格式:
do {
      循环体
} while (条件判断);
do while循环的扩展格式:
初始化语句;
do {
      循环体
      步进语句;
} while (条件判断);

[Java] 纯文本查看 复制代码

// 说出以下代码的执行流程和结果
public class Test {
    public static void main(String[] args) {
        do {
            System.out.println("也会打印一次哦");
        } while (false);
    }
}

练习演示: 用循环求出1-100之间的偶数和
5分钟练习: 求和
需求: 使用for循环求出1-100之间的偶数和

分析:
      获取1-100的每个数字: for (int i = 1; i <= 100; i++) {}
      怎么判断是偶数: i % 2 == 0
      怎么累加求和:
            1. 在for循环前面定义求和变量sum
            2. 在for循环体中, 是偶数的累加到变量sum:  sum += i;
            3. for循环结束后, sum变量中保存的值就是总和
代码:

[Java] 纯文本查看 复制代码

/*
需求: 使用for循环求出1-100之间的偶数和

分析:
        获取1-100的每个数字: for (int i = 1; i <= 100; i++) {}
        怎么判断是偶数: i % 2 == 0
        怎么累加求和: 
                1. 在for循环前面定义求和变量sum
                2. 在for循环体中, 是偶数的累加到变量sum:  sum += i;
                3. for循环结束后, sum变量中保存的值就是总和
*/
public class Test {
        public static void main(String[] args) {
                // 定义求和变量
                int sum = 0;
                // for循环产生1-100之间的数字
                for (int i = 1; i <= 100; i++) {
                        // 判断i的值是否是偶数
                        if (i % 2 == 0) {
                                // 是偶数, 累加到sum
                                sum += i;
                        }
                }
                // for循环结束后, sum保存的值就是总和
                System.out.println(sum);  // 2550
        }
}

编程思维: 求和
获取指定范围内的数字, 对符合条件的数字求和

[Java] 纯文本查看 复制代码

// 1. 定义求和变量
int sum = 0;

// 2. for循环产生指定范围的数字
for (int i = 初始值; i <= 结束值; i++) {
    // 3. 判断是否符合条件
    if (符合某种条件) {
        // 4. 将符合条件的值累加
        sum += i;
    }
}

// 5. for循环结束后, sum就是符合要求的总和
System.out.println(sum);

编程思维: 计数
对符合条件的场景计数

[Java] 纯文本查看 复制代码

// 1. 定义变量当作计数器
int count = 0;

// 2. for循环产生指定范围的数字
for (int i = 初始值; i <= 结束值; i++) {
    // 3. 判断是否符合条件
    if (符合某种条件) {
        // 4. 符合条件时, 计数器增加1
        count++;
    }
}

// 5. for循环结束后, count就是最终次数
System.out.println(count);

5分钟练习: 计数
需求: 打印1-100之内能被7整除的数字, 输出在同一行, 并统计个数
System.out.println(a): 输出并换行
System.out.print(a): 输出不换行

分析:
      获取1-100的每个数字: for (int i = 1; i < 100; i++) {}
      怎么判断能被7整除的数字: if (i % 7 == 0) {}
      怎么统计个数:
            1. 在for循环前面定义计数器变量count
            2. 在for循环体中, 判断能被7整除的数字后, 打印该数字不换行, 同时计数器增加:  count++;
            3. for循环结束后, count变量中保存的值就是次数

代码:

[Java] 纯文本查看 复制代码

/*
需求: 打印1-100之内能被7整除的数字, 输出在同一行, 并统计个数
*/
public class Test {
        public static void main(String[] args) {
                // 定义变量作为计数器
                int count = 0;
                
                // for循环产生1-100之间的数值
                for (int i = 1; i < 100; i++) {
                        // 判断该数值是否能被7整除
                        if (i % 7 == 0) {
                                // 打印该数值
                                System.out.print(i + " ");
                                // 计数器增加1
                                count++;
                        }
                }
                // for循环结束后, 输出统计的个数
                System.out.println("总共有" + count + "个");  // 7 14 21 28 35 42 49 56 63 70 77 84 91 98 总共有14个
        }
}

3种循环的区别区别:
1. 如果条件判断从来没有满足过,
         for 循环和 while 循环将会执行0次
         do while 循环会执行至少一次
2. for 循环的变量在小括号当中定义，只有循环内部才可以使用.
      while 循环和 do while 循环初始化语句本来就在外面，所以出来循环之后还可以继续使用
补充：
for: 适用于知道循环次数的场景
while: 适用于不知道循环次数的场景

for (int i = 0; i < 10; i++) {
}

while (true) {
      System.out.println("...");
      // 判断是否满足退出循环的条件
if (满足) {
         break;
}
}

循环控制语句break结束循环
break的应用场景:
      1. switch语句中: 用于结束switch语句
      2. 循环中: 用于结束循环
continue结束当此循环
continue的应用场景:
      1. 循环中: 跳过剩余循环内容, 结束本次循环, 继续下次循环.

[Java] 纯文本查看 复制代码

/*
请添加一行代码, 分别达到以下目的
        1. 输出2次 HelloWorld  break
        2. 输出7次 HelloWorld  continue
        3. 输出13次 HelloWorld  System.out.println("HelloWorld");
*/
public class Test {
        public static void main(String[] args) {
                for (int i = 1; i <= 10; i++) {
                        if (i % 3 == 0) {  // 3, 6, 9
                                // 添加一行代码
                 
                        }
                        System.out.println("HelloWorld");
                }
        }
}

死循环
死循环: 永远停不下来的循环

死循环后面的代码是永远无法执行到的

[Java] 纯文本查看 复制代码

// while实现死循环
while (true) {
    System.out.println("还有完吗?");
}

// for实现死循环
for (;;) {
    System.out.println("没完没了啊!");
}

嵌套循环
嵌套循环: 循环中嵌套循环 (循环中的循环体是另一个循环)
补充:
对于多层嵌套循环, break, continue 只对他们外面的一层循环有效

[Java] 纯文本查看 复制代码

public class Test {
    public static void main(String[] args) {
                // 外层for
        for (int i = 0; i < 10; i++) {
                // 内层for
            for (int j = 0; j < 20; j++) {
                if (j == 5) {
                                        break;  // 只能结束内层for
                }
            }
        }
    }
}



// 循环中嵌套循环
for () {
    for () {
        
    }
}


while () {
    while () {
        
    }
}


for () {
    while () {
        
    }
}

注意平时写代码时, 循环不要嵌套太多层, 这样代码的阅读性会较差, 难以修改, 容易出错
5分钟练习: 使用嵌套for循环模拟时钟
需求: 使用嵌套for循环模拟时钟
      小时0-23, 分钟0-59, 输出格式:
      0点0分
      0点1分
      ...
      23点59分

[Java] 纯文本查看 复制代码

public class TestHourAndMinute{
        public static void main(String[] args){
                for(int hour = 0;hour<24;hour ++){
                        for(int minute = 0;minute <60;minute ++){
                                System.out.println(hour+"时"+minute+"分钟");
                        }
                }
        }
}

扩展
if ()
System.out.println();
System.out.println();
if, for, while 可以省略大括号, 但省略大括号时, 只有下面的第一行语句是语句体, 再往后的语句不属于语句体
      if (条件判断)
            语句体
      这里不再是if的语句体

      for (...;...;...)
            语句体
      这里不再是for的语句体

      while (条件判断)
            语句体
      这里不再是while的语句体

if, for, while 也可以没有大括号和方法体, 用分号直接结尾
      if (true);  // 没什么用
      for (int i = 0; i < 5; i++);  // 程序循环5次, 每次什么都不做
      while (true);  // 死循环, 也没办法结束

[Java] 纯文本查看 复制代码

public class Test {
        public static void main(String[] args) {
                
                // if
                if (false)
                        System.out.println("是if语句体, 但因为条件是false所以不执行");
                        System.out.println("不是if的语句体");
                        
                System.out.println("--------------------");
                
                // for
                for (int i = 0; i < 5; i++) 
                        System.out.println("是for语句体");
                        System.out.println("不是for的语句体, 循环结束后才执行");
                        
                System.out.println("--------------------");
                        
                // while 
                boolean b = false;
                while (b) 
                        System.out.println("是while语句体, 但因为条件是false所以不执行");
                        System.out.println("不是while的语句体, 循环结束后才执行");
                        
                System.out.println("--------------------");
                        
                // if直接分号结束
                if (true);
                
                // for直接分号结束
                for (int i = 0; i < 5; i++);
                
                // while直接分号结束
                while (true);
        }
}

cuipu · cuipu

消灭零回复

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【石家庄校区】java基础班day03-流程控制语句

1 个回复