java basic 04day04 总结笔记 01-switch语句格式 : 注意事项 : case 后面的值不允许

day04 总结笔记

01-switch语句

格式 :

switch(将要匹配的值){
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	case 值3:
		语句体3;
		break;
	...
	default:
		语句体n+1;
		break;
}

1. 拿着switch() 中的值, 跟case给出的选项逐个进行匹配, 匹配成功, 就执行对应的语句体
    		随后再由break, 结束掉switch语句
2. 如果给出的所有case都匹配失败, 将会执行最后的default

注意事项 :
- case 后面的值不允许重复
- case 后面的值只能是常量, 不能是变量
- switch () 中可以接收的类型
  - 基本数据类型 : byte short char int
  - 引用数据类型 : jdk5版本开始可以是枚举, jdk7版本开始可以是String字符串
- 如果switch语句, 省略了break, 会开启case穿透现象
使用选择 :
- if : 适用于范围性的判断查找
- switch : 适用于固定值的匹配

02-for循环

目标 : 为什么要学习循环语句
- 回答 : 程序中有些逻辑代码, 需要重复的执行很多次, 就应该使用循环
- 用户输入密码, 3次输入机会
- 猜数字小游戏
for 循环格式 :

for(初始化语句; 判断条件; 条件控制语句){
	循环体语句;
}

初始化语句: 定义变量, 通过这个变量, 来控制循环
判断条件: 根据这个条件返回的结果, 决定循环是否要继续
循环体语句: 循环要重复执行的代码
条件控制语句: 改变变量的值

执行流程 :

1. 执行初始化语句, 在整个循环的过程中, 只执行一次
2. 执行判断条件, 看其返回结果是true, false
		false : 循环结束
		true : 进入第三步
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续


for(int i = 1; i <= 3; i++){
	System.out.println("HelloWorld");
}

案例1 :

package com.itheima.test;

public class ForTest1 {
    /*
        需求: 在控制台打印数字 1~3 和 3~1
        ------------------------------------------

        积累思路:
                 1. 循环中, 用于控制循环的那个变量, 是可以放在循环体中继续使用
                 2. 循环的条件控制语句, 不要局限的认为只能是++
     */
    public static void main(String[] args) {

        for (int i = 1; i <= 3; i++) {
            // 思路: 打印的东西, 需要是一个变量, 不能是常量
            // 分析: 变量的变化过程  1  2  3  这个变化过程, 跟 i 是一样的
            System.out.println(i);
        }

        System.out.println("--------------------");

        for (int i = 3; i >= 1; i--) {
            System.out.println(i);
        }
    }
}

案例2 :

package com.itheima.test;

public class ForTest2 {
    public static void main(String[] args) {
        for (int i = 10; i >= 1; i--) {
            System.out.println("干饭倒计时:" + i + "秒");
        }
        System.out.println("终于等到了饭点, 干饭人干饭时间!");
    }
}

案例3 :

package com.itheima.test;

public class ForTest3 {
    /*
        需求：求1-100之间的偶数和，并把求和结果在控制台输出

        积累思路: 今后只要需求中, 看到了求和字样, 就要联想到求和变量.
     */
    public static void main(String[] args) {
        // 1. 定义求和变量 sum，准备记录累加的结果
        int sum = 0;
        // 2. 使用 for 循环，分别获取数据 1 – 100
        for (int i = 1; i <= 100; i++) {
            // i : 在循环中, 代表 1 ~ 100 之间的每一个数值
            // 3. 循环使用 if 语句，筛选出偶数数据
            if (i % 2 == 0) {
                // 4. 将每一个偶数数据，和 sum 变量进行累加
                sum += i;
            }
        }
        System.out.println("1~100之间的偶数和:" + sum);

        System.out.println("--------------------------");

        int result = 0;
        for (int i = 2; i <= 100; i += 2) {
            result += i;
        }
        System.out.println("1~100之间的偶数和:" + result);
    }
}

案例4 :

package com.itheima.test;

public class ForTest4 {
    /*
        需求：在控制台输出所有的“水仙花数”

        分析：
            1. 通过 for 循环，获取到所有的三位数 100 - 999
            2. 在循环内部，将每一个三位数拆分为（个位，十位，百位）
            3. 加入 if 筛选条件
                if (ge*ge*ge + shi*shi*shi + bai*bai*bai == 原数)
            4. 满足条件则输出水仙花数
     */
    public static void main(String[] args) {

        // 1. 通过 for 循环，获取到所有的三位数 100 - 999
        for (int i = 100; i <= 999; i++) {
            // 2. 在循环内部，将每一个三位数拆分为（个位，十位，百位）
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
            // 3. 加入 if 筛选条件
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                // 4. 满足条件则输出水仙花数
                System.out.println(i);
            }
        }
    }
}

案例5 :

package com.itheima.test;

public class ForTest5 {
    /*
        需求: 在控制台打印所有的水仙花数, 并统计水仙花数的个数

        --------------------------------------------

        积累思路:  今后的需求, 只要涉及到统计xxx, 就要联想到计数器变量.
     */
    public static void main(String[] args) {

        // 定义变量, 准备帮我们查数(统计)
        int count = 0;

        for (int i = 100; i <= 999; i++) {

            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;

            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                System.out.println(i);
                // 每打印一次, 代表找到了一次, 让变量自增
                count++;
            }

        }

        // 在循环结束后, 打印水仙花数的个数
        System.out.println("水仙花数的个数为:" + count);

    }
}

案例6 :

package com.itheima.test;

public class ForTest6 {
    /*
        需求: 在控制台打印出所有的水仙花数, 每两个数据占一行
                153 370
                371 407

        打印语句使用:
                System.out.println();   :  打印数据后, 带有换行效果
                System.out.print();     :  打印数据后, 没有换行效果
     */
    public static void main(String[] args) {

        // 定义计数器变量, 准备统计, 已经打印了几个
        int count = 0;

        for (int i = 100; i <= 999; i++) {

            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;

            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                System.out.print(i + " ");
                // 每打印一次, 计数器变量自增
                count++;
                // 判断计数器变量, 是否到达了2的倍数
                if(count % 2 == 0){
                    // 换行
                    System.out.println();
                }
            }
        }
    }
}

循环的注意事项 :

1. for循环 () 和 {} 之间不要写分号
2. for循环 {} 中定义的变量, 在每一轮循环结束后, 都会从内存中释放(消失)
3. for循环 () 中定义的变量, 在整个循环结束后, 会从内存中释放(消失)
4. 因为马虎造成的无限循环(死循环)
	- 排查循环条件

循环嵌套 :

今天其他内容全部掌握了, 再看循环嵌套
阅读循环嵌套 :
- 思路 : 先看内循环, 搞清楚内循环单独拿出来是什么效果, 再看外循环.
编写循环嵌套 :
- 将大问题拆解为小问题
  - 先搞定内循环
  - 再考虑外循环

package com.itheima.test;

public class ForTest7 {
    /*
        循环嵌套: 在循环中, 继续编写循环语句
        ----------------------------------------------

        阅读循环嵌套代码: 先搞清楚内循环干的事儿, 然后再看外循环

                举例: 内循环单独拿出来, 打印5次HelloWorld, 整个内循环被外循环包裹, 外循环, 循环了5次
                        -- 效果: 25次HelloWorld

        ----------------------------------------------

        编写循环嵌套代码:
                先把大问题, 拆成小问题
                先把内循环干的事儿, 解决!
                然后, 再写外循环
     */
    /*
        需求: 在控制台使用 * 打印4行5列矩形

        1. 使用循环, 打印1行5列
        2. 改进为4行5列
     */
    public static void main(String[] args) {

        // 外循环: 控制的是行数
        for(int i = 1; i <= 4; i++){
            // 内循环: 控制的是列数
            for(int j = 1; j <= 5; j++){
                System.out.print("*");
            }
            System.out.println();
        }

        // 掌握扎实: 先写内循环, 再用外循环包裹
    }
}

package com.itheima.test;

public class ForTest8 {
    /*
        需求: 使用 * 在控制台打印直角三角形

            *
            **
            ***
            ****
            *****

            *****
            ****
            ***
            **
            *

        1. 5行5列矩形
        2. 改进为直角三角形

     */
    public static void main(String[] args) {

        // 外循环控制行数
        for (int i = 1; i <= 5; i++) {
            // 内循环控制列数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("----------------------");

        // 外循环控制行数
        for (int i = 5; i >= 1; i--) {
            // 内循环控制列数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

package com.itheima.test;

public class ForTest9 {
    /*
        需求: 在控制台打印99乘法表

            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开始, 逐个+1进行增长       ---> j
            乘号右边: 在所在行中, 数据都是不变的             ---> i

            1. 9行9列矩形
            2. 改进为直角三角形
            3. 改进为99乘法表

            - 今天学习循环嵌套, 是为了后期的内容做铺垫
     */
    public static void main(String[] args) {

        // 外循环: 行数
        for (int i = 1; i <= 9; i++) {
            // 内循环: 列数
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }

    }
}

03-while循环

格式 :

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

int i = 1;
while(i <= 10){
    System.out.println("HelloWorld");
    i++;
}

执行流程 :

1. 执行初始化语句, 在整个循环的过程中, 只执行一次
2. 执行判断条件, 看其返回结果是true, false
		false : 循环结束
		true : 进入第三步
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续

挑for循环中的几个练习, 使用while实现

04-do...while循环 (了解)

格式 :

初始化语句;
do {
	循环体语句;
	条件控制语句;
}while(判断条件);

int i = 1;
do {
	System.out.pritnln("HelloWorld");
	i++;
}while(i <= 10);

执行流程 :

1. 执行初始化语句
2. 执行循环体语句
3. 执行条件控制语句
4. 执行判断条件
		看其返回结果是true, false
		false : 循环结束
		true : 回到2继续
		
- 特点 : 无论判断条件是否满足, 都至少会执行一次循环体

05-三种循环的对比

(for, while) : 先判断, 后执行
(do...while) : 先执行, 后判断

思路: do...while循环今后很少使用

for , while : 使用选择

本质来说没什么区别, for能够解决的问题, while都能解决, 反之也是一样

06-break和continue

break : 结束 (switch, 循环)
continue : 跳过 (循环)
注意事项 : break, continue, 下面不允许写代码, 因为执行不到, 属于无效的代码
细节 : 如果在循环嵌套当中, break, continue 默认只能操作内循环
- 想要人为控制, 可以使用标号

package com.itheima.ctrl;

public class LoopDemo {
    /*
        注意: break, continue如果遇到了循环嵌套, 默认操作的是内部循环

        ----------------------------------------------

        使用循环标号技术, 控制break, continue操作指定一层的循环
     */
    public static void main(String[] args) {

        lo:
        for(int i = 1; i <= 3; i++){
            for(int j = 1; j <= 3; j++){
                if(j == 2){
                    break lo;
                }
                System.out.println("HelloWorld");
            }
        }

    }
}

07-Random产生随机数

1. 找符咒
		import java.util.Random;
2. 召唤精灵
		Random r = new Random();
3. 指挥精灵干活
		int num1 = r.nextInt(10);     		// 0~9
		int num2 = r.nextInt(100) + 1;		// 1~100
		int num3 = r.nextInt(101);		    // 0~100

		---------------------------------
		
		20~80
		
	    int num = r.nextInt(61) + 20;

package com.itheima.test;

import java.util.Random;
import java.util.Scanner;

public class RandomTest {
    /*
        需求: 实现猜数字小游戏
        -----------------------------

        1. 在程序中使用Random, 产生一个1~100之间的随机数, 我们要猜的数据 (randomNum)
        2. 使用Scanner键盘录入, 我们自己猜的数据 (scNum)
        3. 比较
     */
    public static void main(String[] args) {
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        // 1. 在程序中使用Random, 产生一个1~100之间的随机数, 我们要猜的数据 (randomNum)
        int randomNum = r.nextInt(100) + 1;
        while(true){
            // 2. 使用Scanner键盘录入, 我们自己猜的数据 (scNum)
            System.out.println("请输入:");
            int scNum = sc.nextInt();
            // 3. 比较
            if (scNum > randomNum) {
                System.out.println("猜大了");
            } else if (scNum < randomNum) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜,猜对了!");
                break;
            }
        }
        System.out.println("感谢您的使用, 再见!");
    }
}