第2章 运算符和流程控制

已于 2024-05-12 22:26:29 修改
阅读量525 收藏 11
点赞数 10
分类专栏： Java 文章标签： 开发语言 javaee 后端 java
于 2024-05-04 00:41:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1448824839/article/details/138428929
版权

第2章 运算符和流程控制

作者：张子默

一、章节结构

在这里插入图片描述

二、运算符

运算符概述

运算符就是对字面量或者变量进行操作的符号。

表达式概述

表达式就是用运算符把字面量或者变量连接起来的符合Java语法的式子。

小贴士：

  • 不同运算符连接的表达式，就是不同类型的表达式。
  • +是算术运算符，a + b是表达式，由于+是算术运算符，所以这个表达式叫做算术表达式。

算术运算符

符号作用说明
+加参看小学一年级
-减参看小学一年级
*乘参看小学二年级，与"×"相同
/除参看小学二年级，与"÷"相同
%取余获取的是两个数据做除法的余数

小贴士：

  • /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
  • 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
  • 在Java中，取余%运算通常只在整数类型中定义，并不适用double和float浮点数类型。

案例

数值拆分
package com.zzm;

/**
 * 用途：数值拆分
 * 时间：2024/5/3 13:06
 * 创建人：张子默
 */

/*
    案例：数值拆分
        java中两个整数相除：结果只取商
        java中两个整数取余：结果只取余数
 */
public class Demo01 {
    public static void main(String[] args) {
        // 定义变量
        int num = 456;

        // 数值拆分
        int ge = num % 10; // 456%10=45...6
        int shi = num / 10 % 10; // 456/10=45%10=4...5
        int bai = num / 100 % 10; // 456/100=4%10=4
        // int qian = num / 1000 % 10;

        // 做后续操作(打印结果)
        System.out.println("个位：" + ge);
        System.out.println("十位：" + shi);
        System.out.println("百位：" + bai);
    }
}
浮点数的取余操作

在Java中，取余%运算通常只在整数类型中定义，并不适用double和float浮点数类型，对浮点数float和double类型进行取余操作，会出现精度问题，要实现对浮点数取余操作，可以现将其转换为整型，然后进行取余运算，最后如果需要的话可以再转换回浮点数类型；另外可以使用BigDecimal类对浮点数进行高精度的模(取余)运算,BigDecimal类提供了精确的浮点运算工具。

小贴士

  • 浮点数在十进制转换为二进制时，整数部分采用除二取余法，小数部分采用乘二取整法，在小数转换过程中完成转换的标准为没有小数位或者长度足够，所以小数位仅仅满足长度要求的情况下将会造成精度丢失。
public class ModExample {
    public static void main(String[] args) {
        double number = 3.14;
        int divisor = 5;
 
        // 将double转换为int进行模运算
        int modResult = (int)(number % divisor);
 
        // 将模运算结果转换回double类型
        double modResultDouble = modResult;
 
        System.out.println("Mod result as double: " + modResultDouble);
    }
}

+操作的三种场景(案例)

数字相加(类型转换)

在Java程序中，数据参与运算要求数据类型一致，这里就涉及到了数据类型转换，而数据类型转换又分为两种。

  • 隐式转换：把一个表示数据范围小的数值或变量赋值给另一个表示数据范围大的变量。

    在这里插入图片描述

  • 强制转换(显式转换)：把一个表示数据范围大的数值或变量赋值给另一个表示数据范围小的变量。

    package com.zzm;

/**
 * 用途：数字相加(类型转换)
 * 时间：2024/5/3 18:59
 * 创建人：张子默
 */

/*
    案例：数字相加(类型转换)
        1.隐式转换：小 -> 大 计算机自动完成
        2.强制转换 大-> 小 手动书写格式，不推荐

    byte -> short(char)参与运算 会自动提升为int
        int -> long -> float -> double
 */
public class Demo02 {
    public static void main(String[] args) {
        // 1.隐式转换 小 -> 大
        int a = 10;
        double b = 12.3;
        System.out.println(a + b); // 23.3 a先提升为double类型，再做运算

        int ii = (int) (a + b);
        System.out.println(ii); // 22 如果使用double想要转为int，小数点后面就丢失了

        double num = 100; // 100默认是int类型，赋值给double，从小到大，属于隐式转换
        System.out.println(num);

        // 2.强制转换 大 -> 小
        // 格式：数据类型 变量名 = (目标类型)变量值;
        int i = (int) 3.14;
        System.out.println(i); // 3 强转可能会造成数据精度的丢失，不建议！
    }
}
字符相加
package com.zzm;

/**
 * 用途：字符相加
 * 时间：2024/5/3 20:33
 * 创建人：张子默
 */
/*
    案例：字符相加
        当字符参与运算，底层会使用该字符在ASCII码表中对应的十进制整数值运算

    A -> 65 A到Z是连续的，逐个+1
    a -> 97 a到z是连续的，逐个+1
    0 -> 48 0到9是连续的，逐个+1
 */
public class Demo03 {
    public static void main(String[] args) {
        // 单独打印，展示的是字符本身
        System.out.println('0'); // 0
        System.out.println('A'); // A
        System.out.println('a'); // a

        // 参与运算，展示的是字符在ASCII码表中对应的整数相加的结果
        System.out.println('0' + 1); // 49
        System.out.println('A' + 1); // 66
        System.out.println('a' + 1); // 98
    }
}

小贴士：字符参与+运算，其实就是拿字符在计算机底层对应的数值(ASCII码)来进行计算的。

在这里插入图片描述

赋值运算符

符号作用说明
=赋值a = 10，将10赋值给变量a
+=加后赋值a += b，将a + b的值赋值给a
-=减后赋值a -= b，将a - b的值赋值给a
*=乘后赋值a *= b，将a * b的值赋值给a
/=除后赋值a /= b，将a / b的值赋值给a
%=取余后赋值a %= b，将a % b的值赋值给a
赋值运算符案例
package com.zzm;

/**
 * 用途：赋值运算符
 * 时间：2024/5/3 21:07
 * 创建人：张子默
 */
public class A {
    public static void main(String[] args) {
        // 常量优化机制：在编译时，如果常量在左边类型的范围内，编译通过，反之编译失败(报错)
        short s = 1;
        // s = s + 1; // 报错原因：有int参与运算，整体结果提升为int，将int赋值给short类型的变量，大->小属于强转
        s = (short)(s + 1); // 解决：手动强转即可

        short ss = 1;
        ss += 1; // 等同于：ss = (short)(ss + 1);扩展的赋值运算符底层隐含了强转，所以不会报错
    }
}

小贴士：

  • 在后期的运用中，使用最多的赋值运算符为=和+=;
  • 扩展的赋值运算符底层隐含了强制类型转换;

关系运算符

符号作用说明
==等于a == b，判断a和b是否相等，成立为true，不成立为false
!=不等于a != b，判断a和b是否不相等，成立为true，不成立为false
>大于a > b，判断a是否大于b，成立为true，不成立为false
>=大于等于a >= b，判断a是否大于等于b，成立为true，不成立为false
<小于a < b，判断a是否小于b，成立为true，不成立为false
<=小于等于a <= b，判断a是否小于等于b，成立为true，不成立为false
关系运算符案例
package com.zzm;

/**
 * 用途：关系运算符案例
 * 时间：2024/5/5 13:05
 * 创建人：张子默
 */
public class OperatorDemo01 {
    public static void main(String[] args) {
        // 定义三个int类型的变量
        int i = 10;
        int j = 20;
        int k = 30;

        // 等于 ==
        System.out.println(i == j); // false
        System.out.println(i == k); // false
        System.out.println("---------");

        // 不等于 !=
        System.out.println(i != j); // true
        System.out.println(i != k); // true
        System.out.println("---------");

        // 大于
        System.out.println(i > j); // false
        System.out.println(i > k); // false
        System.out.println("---------");

        // 大于等于
        System.out.println(i >= j); // false
        System.out.println(i >= k); // false
        System.out.println("---------");

        // 小于
        System.out.println(i < j); // true
        System.out.println(i < k); // true
        System.out.println("---------");

        // 小于等于
        System.out.println(i <= j); // true
        System.out.println(i <= k); // true
    }
}

小贴士：

  • 关系运算符的结果都是boolean类型，要么是true，要么是false；
  • 等于使用符号==而不是=;

逻辑运算符

符号作用说明
&&与，并且的意思a && b，a和b都是true，结果为true，否则为false
``
!非，相反的意思!a，结果和a的结果正好相反，偶数次操作和原始结果一致
逻辑运算符案例
package com.zzm;

/**
 * 用途：逻辑运算符案例
 * 时间：2024/5/5 18:11
 * 创建人：张子默
 */
public class OeratorDemo02 {
    public static void main(String[] args) {
        // 定义变量
        int i = 10;
        int j = 20;
        int k = 30;

        // 逻辑与 &&
        System.out.println((i > j) && (i > k)); // false && fasle
        System.out.println((i < j) && (i > k)); // true && false
        System.out.println((i > j) && (i < k)); // false && trur
        System.out.println((i < j) && (i < k)); // true && true
        System.out.println("----------");

        // 逻辑或 ||
        System.out.println((i > j) || (i > k)); // false || false
        System.out.println((i < j) || (i > k)); // true || false
        System.out.println((i > j) || (i < k)); // false || true
        System.out.println((i < j) || (i < k)); // true || true
        System.out.println("----------");

        // 逻辑非 !
        System.out.println(!(i > j)); // !false
        System.out.println(!!(i > j)); // !!false
        System.out.println(!!!(i > j)); // !!!false
        System.out.println(!!!!(i > j)); // !!!!false
    }
}

三元运算符

三元运算符格式
关系表达式 ? 表达式1 : 表达式2;
a > b ? a : b;
三元运算符执行流程
  • 计算关系表达式的值
  • 如果关系表达式的值为true，表达式1的值就是运算结果
  • 如果关系表达式的值为false，表达式2的值就是运算结果
关系表达式案例
package com.zzm;

/**
 * 用途：三元运算符案例
 * 时间：2024/5/5 18:29
 * 创建人：张子默
 */
public class OperatorDemo03 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        int max = a > b ? a : b;

        System.out.println("较大值是：" + max);
    }
}

小贴士：

  • 三元运算符的运算结果要使用变量接收；
  • 如果if…else…控制语句是用变量记录数据值，可以通过三元运算符改进
  • 如果if…else…语句控制内容是通过输出语句直接输出数据值，无法通过三元运算符改进

在这里插入图片描述

在这里插入图片描述

自增自减运算符

  • ++：自增运算符，让变量自己+1
  • --：自减运算符，让变量自己-1

小贴士：自增自减运算符用于变量前，变量先+1后参与运算；自增自减运算符用于变量后，变量先参与运算，然后+1。

三、流程控制

顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照语法的先后顺序依次执行。

在这里插入图片描述

顺序结构案例
package com.zzm;

/**
 * 用途：顺序结构案例
 * 时间：2024/5/5 18:41
 * 创建人：张子默
 */
public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        System.out.println("语句A");
        System.out.println("语句B");
        System.out.println("语句C");
        System.out.println("结束");
    }
}
Debug的基本使用

Debug是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行的过程来调试程序。

Debug的作用
  • 查看程序执行流程
  • 调试程序
Debug的操作流程

Debug又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看。

  • 选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。

    在这里插入图片描述

  • 在代码区域右键Debug执行。

    在这里插入图片描述

  • 看Debugger窗口，看Console窗口。

    在这里插入图片描述

  • 点(Step Over F8)开始，点(Stop)结束

    在这里插入图片描述

  • 选择要删除的断点，单击鼠标左键即可，也就是把第一步的动作，再做一次即可。

选择(分支)结构

if语句
if语句格式1
if (结果为boolean类型的表达式) {
    语句体;
}

if语句格式1的执行流程

在这里插入图片描述

if语句格式1案例

package com.zzm;

/**
 * 用途：if语句格式1
 * 时间：2024/5/5 20:50
 * 创建人：张子默
 */
public class IfDemo01 {
    public static void main(String[] args) {
        boolean isGreen = true;

        if (isGreen) {
            System.out.println("绿灯行");
        }
    }
}
if语句格式2
if (结果为boolean类型的表达式) {
    语句体1;
} else {
    语句体2;
}

if语句格式2的执行流程

在这里插入图片描述

if语句格式2案例

![12-if语句](F:\Note\Java\第2章 运算符\pictures\12-if语句.png)package com.zzm;

/**
 * 用途：if语句格式2
 * 时间：2024/5/5 20:56
 * 创建人：张子默
 */
public class IfDemo02 {
    public static void main(String[] args) {
        // 定义一个变量用来表示绿灯的状态
        boolean isGreen = true;
        isGreen = false;

        if (isGreen) {
            System.out.println("绿灯行");
        } else {
            System.out.println("不是绿灯，不允许行驶");
        }
    }
}
if语句格式3
if (结果为boolean类型的表达式1) {
    语句体1;
} else if (结果为boolean类型的表达式2) {
    语句体2;
}
...
else {
    语句体n + 1；
}

if语句格式3的执行流程

在这里插入图片描述

if语句格式3案例

package com.zzm;

/**
 * 用途：if语句格式3
 * 时间：2024/5/5 21:08
 * 创建人：张子默
 */
public class IfDemo03 {
    public static void main(String[] args) {
        // 定义三个变量，表示交通信号灯的三种状态
        boolean isGreen = true;
        boolean isRed = true;
        boolean isYellow = true;

        // 红灯
//        isGreen = false;
//        isYellow = false;

        // 绿灯
//        isRed = false;
//        isYellow = false;

        // 黄灯
//        isRed = false;
//        isGreen = false;

        /*if (isRed) {
            System.out.println("红灯停");
        }

        if (isGreen) {
            System.out.println("绿灯行");
        }

        if (isYellow) {
            System.out.println("黄灯亮了等一等");
        }*/

        // 出现了故障，信号灯都不亮了
        isRed = false;
        isGreen = false;
        isYellow = false;

        if (isRed) {
            System.out.println("红灯停");
        } else if (isGreen) {
            System.out.println("绿灯行");
        } else if (isYellow) {
            System.out.println("黄灯亮了等一等");
        } else {
            System.out.println("交通信号灯故障，请在保证安全的情况下通行");
        }
    }
}
if语句案例

  • 交通信号灯

    package com.zzm;

/**
 * 用途：if格式3 交通信号灯案例
 * 时间：2024/5/3 23:33
 * 创建人：张子默
 */
public class Demo06 {
    public static void main(String[] args) {
        int l = 1; // 红灯
        // l= 2; // 绿灯
        // l = 3; // 黄灯
        // l = 4; // 出现故障

        // 根据l的值不同，打印不同结果
        if (l == 1) {
            System.out.println("红灯停");
        } else if (l == 2) {
            System.out.println("绿灯行");
        } else if (l == 3) {
            System.out.println("黄灯注意");
        } else {
            System.out.println("故障");
        }
    }
}

  • 奇偶数

    package com.zzm;

/**
 * 用途：奇偶数
 * 时间：2024/5/3 23:43
 * 创建人：张子默
 */
/*
    需求：使用程序，判断一个整数是奇数还是偶数，打印结果。

    if (条件) {
        满足才会走这里;
    }

    if (条件) {
        满足才会走这里;
    } else {
        不满足才会走这里;
    }
 */
public class Demo08 {
    public static void main(String[] args) {
        System.out.println("程序开始");
        // 定义变量
        int num = 11;
        num = 12;
        // 判断条件，如果能被2整除，代表是偶数，反之则是奇数
        if (num % 2 == 0) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }
        System.out.println("程序结束");
    }
}

  • 手机以旧换新

    package com.zzm;

/**
 * 用途：手机以旧换新
 * 时间：2024/5/3 23:48
 * 创建人：张子默
 */
public class Demo09 {
    public static void main(String[] args) {
        // 1.计算以旧换新的价格
        double a = 7988 * 0.8;
        // 2.计算不使用以旧换新的价格
        int b = 7988 - 1500;
        // 3.使用if判断语句
        if (a > b) {
            // 4.打印结果
            System.out.println("以旧换新");
        } else {
            System.out.println("不使用以旧换新");
        }
    }
}

  • 青年人判断

    package com.zzm;

import java.util.Scanner;

/**
 * 用途：判断年龄
 * 时间：2024/5/3 23:51
 * 创建人：张子默
 */
/*
    需求：根据键盘录入的age，判断这个人在哪一个范围
        [0-17] 未成年人
        [18-65] 青年人
        [66-79] 中年人
        [80-99] 老年人
        100+ 长寿老人
 */
public class Demo10 {
    public static void main(String[] args) {
        // 创建键盘对象
        Scanner sc = new Scanner(System.in);
        // 控制台提示输入年龄
        System.out.println("请输入年龄：");
        int age = sc.nextInt();

        // 由于有多个条件，选择if格式3
        if (age <= 17 && age >= 0) {
            System.out.println("未成年人");
        } else if (age <= 65 && age >= 18) {
            System.out.println("青年人");
        } else if (age <= 79 && age >=66) {
            System.out.println("中年人");
        } else if (age <= 99 && age >= 80) {
            System.out.println("老年人");
        } else if (age >= 100) {
            System.out.println("长寿老人");
        } else {
            System.out.println("您输入的年龄错误！");
        }
    }
}
sitch语句
switch (表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n + 1;
        break;
}

格式说明

  • 表达式：可以使byte类型、short类型、int类型、char类型，JDK 5之后可以是枚举值，JDK 7之后可以是String类型。
  • case：后面跟的是要和表达式进行比较的值。
  • break：表示中断，结束的意思，用来结束switch语句。
  • default：所有值都不匹配的时候，执行该处内容，与if语句的else相似。
switch语句的执行流程

在这里插入图片描述

switch语句案例
package com.zzm;

/**
 * 用途：Switch语句
 * 时间：2024/5/5 21:37
 * 创建人：张子默
 */
public class SwitchDemo {
    public static void main(String[] args) {
        // 定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)
        int light = 1;
        light = 2;
        light = 3;
        light = 4;

        // 用switch语句实现交通信号灯案例
        switch (light) {
            case 1:
                System.out.println("红灯停");
                break;
            case 2:
                System.out.println("绿灯行");
                break;
            case 3:
                System.out.println("黄灯亮了等一等");
                break;
            default:
                System.out.println("交通信号灯故障，请在保证安全的情况下通行");
                break;
        }
    }
}
switch穿透

在switch语句中如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整个switch语句结束。

循环结构

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

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

格式说明

  • 初始化语句：这里可以是一条或多条语句，这些语句用来完成初始化操作(int i= 1)
  • 条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体语句(i<= 1000)
  • 循环体语句：这里可以是任意语句，这些语句可能被执行多次
  • 条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的结果(i += 1)

for循环执行流程

在这里插入图片描述

for循环案例

  • 循环输出

    package com.zm;

/**
 * 用途：for循环结构
 * 时间：2024/5/10 22:45
 * 创建人：张子默
 */
public class ForDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("HelloWorld");
        }
    }
}

  • 输出数据

    package com.zm;

/**
 * 用途：输出数据
 * 时间：2024/5/8 12:32
 * 创建人：张子默
 */
/*
    案例：for循环案例1(输出数据)
        打印整数1到5
        打印整数5到1
    自增自减运算符：++、--只能用于变量不能用于常量
        ++作用：让变量自己+1
        --作用：让变量自己-1
 */
public class Demo01 {
    public static void main(String[] args) {
        // 需求：打印整数1到5
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        System.out.println("----------");
        // 需求：打印整数5到10
        for (int i = 5; i <= 10; i++) {
            System.out.println(i);
        }
        System.out.println("----------");
        for (int i = 5; i >=1 ; i--) {
            System.out.println(i);
        }

        /*
            常见问题：
                1.小括号后面不要写分号！分号代表一条语句的结束
                2.如果for循环控制语句的语句体只有一条语句的话，大括号可以省略，但是不建议
         */
    }
}

  • 求和思想

    package com.zm;

/**
 * 用途：求和思想
 * 时间：2024/5/8 12:42
 * 创建人：张子默
 */
/*
    案例：for循环案例2(求和思想)
        求整数[1-100]的和
 */
public class Demo02 {
    public static void main(String[] args) {
        // 定义求和变量
        int sum = 0;
        // 获取1到100之间的所有整数
        for (int i = 1; i <= 100; i++) {
            // 累加
            sum += i;
        }

        // 循环结束，打印结果
        System.out.println(sum);
    }
}

  • 求偶数和

    package com.zm;

/**
 * 用途：求偶数和
 * 时间：2024/5/8 12:46
 * 创建人：张子默
 */
/*
    案例：for循环案例3(求偶数和)
        求1到100之间的偶数和
 */
public class Demo03 {
    public static void main(String[] args) {
        // 定义求和变量
        int sum = 0;
        // 获取1到100之间所有整数
        for (int i = 1; i <= 100; i++) {
            // 判断当前整数是不是偶数
            if (i % 2 == 0) {
                // 累加
                sum += i;
            }
        }

        // 循环结束，打印结果
        System.out.println("sum:" +sum);
    }
}

  • 水仙花数

    package com.zm;

/**
 * 用途：水仙花数
 * 时间：2024/5/8 12:51
 * 创建人：张子默
 */
/*
    案例：for循环案例4(水仙花数)
        水仙花数是一个三位数，数字每个位置的立方和等于数字本身
 */
public class Demo04 {
    public static void main(String[] args) {
        // 使用for循环获取所有三位整数
        for (int i = 100; i <= 999; i++) {
            // 数值拆分
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
            // if语句判断，条件式如果每个位置的立方和等于数字本身
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                // 计数
                // 打印满足条件的数字
                System.out.println(i);
            }

        }
    }
}

  • 统计思想

    package com.zm;

/**
 * 用途：统计思想
 * 时间：2024/5/8 13:04
 * 创建人：张子默
 */
/*
    案例：for循环案例5(统计思想)
        统计有几个水仙花数
 */
public class Demo05 {
    public static void main(String[] args) {
        // 定义计数器
        int count = 0;
        // 使用for循环获取所有三位整数
        for (int i = 100; i <= 999; i++) {
            // 数值拆分
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
            // if语句判断，条件式如果每个位置的立方和等于数字本身
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                // 计数
                count++;
            }

        }

        // 循环结束，打印个数
        System.out.println("count:" + count);
    }
}

  • 回文数

    package com.zm;

/**
 * 用途：回文数
 * 时间：2024/5/8 22:38
 * 创建人：张子默
 */
/*
    案例6：for循环案例6(回文数)
        打印所有五位数的回文数(无论从左朝右还是从右朝左，读起来都是相同的数)
        并统计回文数个数
 */
public class Demo06 {
    public static void main(String[] args) {
        // 定义计数器
        int count = 0;
        // 获取范围内的数据
        for (int i = 10000; i <= 99999; i++) {
            // 数值拆分
            int ge = i % 10;
            int shi = i / 10 % 10;
            int qian = i / 1000 % 10;
            int wan = i / 10000 % 10;
            // 判断
            if (ge == wan && shi == qian) {
                // 计数
                count++;
                // 打印回文数
                System.out.println(i);
            }
        }
        // 循环结束，打印最终的count
        System.out.println("count：" + count);
    }
}

  • 逢七过

    package com.zm;

/**
 * 用途：逢七过
 * 时间：2024/5/8 23:22
 * 创建人：张子默
 */
/*
    案例：for循环案例7(逢七过)
        在整数1到1000中，个位不能是7，十位不能是7，并且该数不能是7的倍数
        打印满足条件的数据

    扩展：一行打印5个，使用空格分开
        System.out.println(); // 打印并换行
        System.out.print(); // 一行打印
 */
public class Demo07 {
    public static void main(String[] args) {
        // 定义计数器
        int count = 0;
        // for循环获取1到100的所有整数
        for (int i = 1; i <= 1000; i++) {
            // 数值拆分
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            int qian = i / 1000;
            // 判断条件
            if (ge != 7 && shi != 7 && bai != 7 && qian != 7 && i % 7 != 0) {
                // 一行打印
                System.out.print(i + " ");
                // 先计数
                count++;
                // 判断如果count是5的倍数，换行执行
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
    }
}
while循环
初始化语句;
while (条件判断语句) {
    循环体语句;
    条件控制语句;
}

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

while循环的执行流程

在这里插入图片描述

while循环案例

  • 求奇数和

    package com.zm;

/**
 * 用途：求奇数和
 * 时间：2024/5/10 21:41
 * 创建人：张子默
 */
/*
    案例：while循环案例1(求奇数和)
        求1到100之间的奇数和
 */
public class Demo08 {
    public static void main(String[] args) {
        // 定义求和变量
        int sum = 0;
        // 初始化语句
        int i = 1;
        // 判断语句
        while (i <= 100) {
            // 循环体
            if (i % 2 != 0) {
                sum += i;
            }
            // 控制语句
            i++;
        }
        System.out.println("sum:" + sum);

        /*int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                sum += i;
            }
        }
        System.out.println("sum:" + sum);*/
    }
}

  • 珠峰折纸

    package com.zm;

/**
 * 用途：珠峰折纸
 * 时间：2024/5/10 21:46
 * 创建人：张子默
 */
/*
    案例：while循环案例2(珠峰折纸)
        已知珠峰高度为8848.86米，纸张厚度为0.1毫米
        请问纸张对折几次，能达到或者超过珠峰高度
 */
public class Demo09 {
    public static void main(String[] args) {
        // 定义珠峰高度
        double zf = 8848.86;
        // 定义纸张厚度
        double zhi = 0.0001;
        // 定义计数器
        int count = 0;
        // 由于不知道循环多少次 --> 优先使用whule
        while (zhi < zf) {
            // 折纸
            zhi *= 2;
            // 计数
            count++;
        }
        // 循环结束，打印结果
        System.out.println(count);
    }
}
do…while循环
初始化语句;
do {
	循环体语句;
    条件控制语句;
} while (条件判断语句);

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

do…while循环的执行流程

在这里插入图片描述

三种循环的区别
  • foe循环和while循环先判断条件是否成立，然后再决定是否执行循环体(先判断后执行)
  • do…while循环先执行一次循环体，然后再判断条件是否成立，是否继续执行循环体(先执行后判断)

for循环和while循环的区别(应用场景)

  • 条件控制语句所控制的自增变量在for循环结束后，就不可以继续使用了
  • 条件控制语句所控制的自增变量在while循环结束后，还能继续使用

小贴士：

  • for循环一般应用在明确循环次数的场景
  • while循环一般用于循环次数不确定的场景下

死循环

for ( ; ; ) {
    
}

while (true) {
    
}

do {
    
} while (true);

死循环案例

package com.zm;

/**
 * 用途：死循环
 * 时间：2024/5/10 21:59
 * 创建人：张子默
 */
/*
    死循环：
        如果写死循环，必须找到循环的出口(停止条件)，否则后面的代码执行不到
 */
public class Test02 {
    public static void main(String[] args) {
        int a = 1;
        // for
        /*for ( ; ; ) {
            System.out.println("我停不下来了...");
        }*/

        // while 常见(用)
        while (true) {
            System.out.println("我停不下来了...");
        }

        // do...while
        /*do {
            System.out.println("我停不下来了...");
        } while (true);*/
    }
}

小贴士：while格式的死循环是最常用的。

跳转控制语句
  • continue：用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
  • break：用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环

小贴士：

  • break语句出了能够用在循环中结束循环，也可以用于switch结构中结束switch
  • continue只能用于循环中用于跳过本次循环

案例

  • continue和break

    package com.zm;

/**
 * 用途：continue和break的使用
 * 时间：2024/5/10 21:55
 * 创建人：张子默
 */
public class Test01 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 3 == 0) {
                continue;
            }

            if (i % 7 == 0) {
                break;
            }
            System.out.println(i);
        }
    }
}

  • 猜数字小游戏

    package com.zm;

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

/**
 * 用途：猜数字小游戏
 * 时间：2024/5/10 22:11
 * 创建人：张子默
 */
/*
    Random随机数对象：
        1.导包 import java.util.Random;
        2.创建对象 Random r = new Random();
        3.调用方法，接收数据 int num = r.nextInt(数据); // 取值范围：从0到指定数据，包含0不包含指定数据

    猜数字小游戏：
        使用Random随机数对象，生成一个[1-100]之间的整数，作为正确答案
        使用Scanner，提示用户录入猜的数据并接收，使用if语句判断用户猜的结果，打印对应提示
            情况1：猜的数超出了[1-100]的范围！请重新输入!
            情况2：猜大了
            情况3：猜小了
            情况4：恭喜你!猜对了
 */
public class RandomGame {
    public static void main(String[] args) {
        // 创建随机数对象
        Random r = new Random();
        // 生成1到100之间的一个随机数
        int num = r.nextInt(100) + 1; // 0到指定值，包含0不包含指定值
        // 创建键盘对象
        Scanner sc = new Scanner(System.in);
        // 使用死循环模拟多次游戏
        for ( ; ; ) {
            // 提示用户猜
            System.out.print("请输入你猜的数据：");
            // 接收
            int guessNum = sc.nextInt();
            // 判断
            if (guessNum > 100 || guessNum < 1) {
                System.out.println("你输入的数据有误!请重新输入!");
            } else if (guessNum > num) {
                System.out.println("猜大了");
            } else if (guessNum < num) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜你~猜对了!");
                // 结束循环
                break;
            }
        }
    }
}

  • 小芳存钱

    package com.zm;

/**
 * 用途：小芳存钱
 * 时间：2024/5/11 0:51
 * 创建人：张子默
 */
/*
    需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第五天或者5的倍数的话，她都会花去6元钱，请问经过多少天，小芳才可以存到100元钱
 */
public class ControlTest {
    public static void main(String[] args) {
        // 小芳的妈妈每天给她2.5元钱
        double dayMoney = 2.5;

        // 她都会存起来，涉及到了求和思想，定义求和变量，初始化值为0
        double sumMoney = 0;

        // 存到100元钱
        int result = 100;

        // 定义一个统计变量，用来记录存钱的天数，初始化值为1
        int dayCount = 1;

        // 因为不知道多少天才能存到100，所以，这里采用死循环来实现，当存到100元的时候，通过break跳转语句让循环结束
        while (true) {
            // 存钱
            sumMoney += dayMoney;

            // 判断存的钱是否大于等于100了，如果是就跳出循环
            if (sumMoney >= result) {
                break;
            }

            // 每当这一天是存钱的第5天或者5的倍数的话，她就会花去6元钱
            if (dayCount % 5 == 0) {
                sumMoney -= 6;
                System.out.println("第" + dayCount +"天花了6元");
            }

            dayCount++;
        }
        // 输出统计天数的变量
        System.out.println("共花了" + dayCount + "天存了100元");
    }
}

    四、练习

  • 如果switch语句省略了break, 会出现什么现象? 请简单描述下这个现象

    答：case穿透现象
当执行完某一个case中的语句体后, 如果没有遇到break, 将会开启case穿透
这种穿透指的是, 会进行到下一个case中, 继续执行语句体
直到遇见了break, 或者执行到了switch的末尾, 才会停止

  • 键盘录入学生成绩, 0 ~ 100分, 根据成绩所在的区间, 打印出不同的奖励机制，对于这个需求, 你觉得应该使用 if , 还是 switch 呢 ? 请说明理由

    答：switch只能进行相等判断
范围的判断if语句更加合适, 因为switch来做的话, 就要从 case 0: 一直写到 case 100:  代码繁琐

  • 现有如下代码 , 能否执行？

    public class Demo {
    public static void main(String[] args){
        for(int i = 1; i <= 5; i++){
            System.out.println(i);
        }
		System.out.println(i);
    }
}

    答：结果: 代码编译出错
原因: 在for循环执行完毕后, i的变量会从内存中释放掉, 再想使用就找不到了

  • 现有如下代码 , 统计 1 ~ 20 之间, 5的倍数有几个, 但是代码存在错误, 请说明错误原因, 并更正代码

    public class Demo {
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            int count = 0;
            if(i % 5 == 0){
                count++;
            }
            System.out.println(count);
        }
    }
}

    答：
1. int count = 0;  计数器变量应该定义在循环外部, 不然每一次进入循环, 都重新置为0了.   
2. System.out.println(count); 这句话是打印5的倍数有多少个, 应该放在循环结束, 因为只有循环结束了, 才算是统计完毕. 
public class Demo {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 20; i++) {
            
            if(i % 5 == 0){
                count++;
            }
            
        }
        System.out.println(count);
    }
}

  • 现有如下代码 , 打印所有的水仙花数, 但是代码存在错误, 请说明错误原因, 并更正代码

    public class Demo {
    public static void main(String[] args) {
        int i = 100;
        while(i <= 999){
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;
            
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
                System.out.println(i);
            }
            
        }
    }
}

    答：while循环中, 忘记了 i++ 所以操作的数据, 一直都是100
public class Demo {
    public static void main(String[] args) {
        int i = 100;
        while(i <= 999){
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
                System.out.println(i);
            }
            i++;
        }
    }
}

  • 观察以下的代码 , 下划线位置加入什么语句,可以在控制台分别打印如下内容：

    7次 I Love Java

    2次 I Love Java

    13次 I Love Java

    public class Demo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 3 == 0) {
                ___________
            }
            System.out.println("I Love Java");
        }
    }
}

    答：
7次: continue
2次: break
13次: System.out.println("I Love Java");

  • **需求描述：**求1~10之间不能被3整除的数之和 ，请分别用for循环和while循环实现

    public class Test01 {
    public static void main(String[] args) {
        //定义求和变量
        int sum = 0;

        //while实现
        int i = 1;
        while (i <= 10) {
        //筛选不能被3整除的数字
            if (i % 3 != 0) {
                sum += i;
            }
            i++;
        }

        //for实现
//        for (int i = 1; i <= 10; i++) {
//            //筛选不能被3整除的数字
//            if (i % 3 != 0) {
//                sum += i;
//            }
//        }
        //打印结果
        System.out.println("sum:" + sum);
    }
}

  • **需求描述：**求1~100之间所有奇数之和，并输出一共有多少个奇数，请分别用for循环和while循环实现

    public class Test02 {
    public static void main(String[] args) {
        //定义计数器
        int count = 0;
        //定义求和变量
        int sum = 0;

        //while循环实现
//        int i = 1;
//        while (i <= 100){
//            //筛选奇数
//            if (i % 2 != 0) {
//                count++; //奇数
//                sum += i; //累加
//            }
//            i++;
//        }

        //for循环实现
        for (int i = 1; i <= 100; i++) {
            //筛选奇数
            if (i % 2 != 0) {
                count++; //奇数
                sum += i; //累加
            }
        }

        //打印结果
        System.out.println("sum:" + sum);
        System.out.println("count:" + count);
    }
}

  • **需求描述：**请输出1-100之间能同时被2、3、5整除的数有多少个?请分别用for循环和while循环实现

    public class Test03 {
    public static void main(String[] args) {
        //定义计数器
        int count = 0;
        //获取1到100的整数
        for (int i = 1; i <= 100; i++) {
            //判断
            if (i % 2 == 0 && i % 3 == 0 && i % 5 == 0) {
                count++;
            }
        }
        //打印结果
        System.out.println("count:" + count);
    }
}

  • 需求描述：中国有闰年的说法。闰年的规则是：四年一闰，百年不闰，四百年再闰

    年份能够被4整除但不能被100整除算是闰年，年份能被400整除也是闰年

    请打印出1988年到2022年的所有闰年年份

    public class Test04 {
    public static void main(String[] args) {
        // 1、定义for循环,循环变量开始是1988,结束是2088.
        for (int year = 1988; year <= 2022; year++) {
            // 2、在循环中对年份进行判断,判读条件为:可以被4整除,并且不可以被100整除,或者可以被400整除
            if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                //  3、如果符合条件,输出该年份.
                System.out.println(year + "是闰年");
                /*
                    1988是闰年
                    1992是闰年
                    1996是闰年
                    2000是闰年
                    2004是闰年
                    2008是闰年
                    2012是闰年
                    2016是闰年
                    2020是闰年
                 */
            }
        }
    }
}

由于本人是利用业余时间整理，时间不是很充裕，本体系内容仍会继续更新，敬请等待…

IT搬砖工张子默
关注
  • 10
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第三章 Matlab流程控制.ppt
12-11
相比于第一代的机器语言和第二代的汇编语言，MATLAB更易学习且效率高，它提供了丰富的内置函数和封装对象，使得编程工作更加便捷。 MATLAB程序设计主要包括三种基本结构：顺序结构、选择结构和循环结构。这三种结构...
《C语言》课件教案PPT第02章数据类型运算符和表达式共6
10-30
【标题】"《C语言》课件教案PPT第02章数据类型运算符和表达式共6"指的是一个关于C语言教学的第二章节，主要涵盖了数据类型、运算符和表达式的基础知识。这一章是C语言学习的核心部分，理解和掌握这些概念对于编程至...
第03章_运算符与流程控制
m0_67446994的博客
07-07 929
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。功能操作数个数。
第四章 Python运算符和流程控制
yunqishequ1的博客
11-29 199
在第一章的时候讲解了运算操作符和赋值操作符，这章来学习下其他常用操作符。 4.1 基本运算符 4.1.1 比较操作符 操作符描述示例 ==相等>>> 1 == 1  True !=不相等>>> 1 != 1 False >大于>>> 2 > 1   True >> 2 >=大于等于>>> 1 >= 1  True >> 1 4.1.2
第3章_运算符与流程控制
qq_59510647的博客
07-02 387
C语言提供了丰富的运算符来执行算术、逻辑、位操作等，并使用流程控制语句（如if、switch、for、while和do-while）来控制程序的执行流程。
第二章 JavaScript 运算符与流程控制
weixiaowei_2016的博客
01-02 111
1.一元运算符的前置与后置操作 n++表示先使用n完成整个表达式的计算后，n再自加；而++n表示n先自加，然后在进行表达式的运算。 let n = 1 let f = 2 let d = f + n++ console.log(d)//3 let n = 1 let f = 2 let d = f + ++n console.log(d)//4 2.比较运算符 等于“==”，全等于“...
第2章Java基本语法变量、运算符和流程控制语句
ZHYLMBC的博客
07-23 139
第2章 Java语言概述声明1. 关键字和保留字2. 标识符3. 变量4. 运算符5. 程序流程控制 声明 本博客的目的是自己对于Java语言基础的复习，不适合新手上路。各位看官，很抱歉哦，不要在这个博客上下功夫，会耽搁大家时间的。 1. 关键字和保留字 2. 标识符 3. 变量 4. 运算符 5. 程序流程控制 ...
Java基础02-运算符&流程控制
也无风雨也无晴
11-08 94
运算符 package 基础; public class Demo07_运算符 { /* 四则运算当中“+”常见的三种用法： * 1. 对于数值来说，就是加法 * 2. 对于字符char来说，在计算之前，char会被提升为int类型，在进行计算 * char类型字符转为int类型的对照关系表：ASCII,Unicode * 3. 对于字符串String,代表字符串连接操作 * */ public static void main(String[]
手把手带你学习Scala(三)-Scala运算符和流程控制
aikeaidecxy的博客
09-04 560
手把手带你学习Scala(三)-Scala运算符和流程控制
第3章 运算符、表达式和流程控制
diaoyinji6441的博客
04-05 110
第3章运算符、表达式和流程控制 运算符和表达式 基本概念 运算符：用于标记对数据执行某种运算的特定符号。 操作数：参加运算的数据称为运算对象（操作数）。 分类 按运算符的功能，将运算符分为：算术运算符、关系运算符、逻辑运算符、位运算符等 按参与运算的操作数的个数，将运算符分为：单目运算符、双目运算符、三目运算符 表达式：若干操作数...
【java期末复习题】第3章 运算符与流程控制
DynamoTUO的博客
07-28 3405
第3章 运算符与流程控制 一、选择题 1．以下switch表达式语句正确的是：（ ）。 A．public void switchTest (char c){switch©{…}} B．public void switchTest(long c){switch©{…}} C．public void switchTest(byte c){switch©{…}} D．public void switchTest(double c){switch©{…}} 2．int i =1,j=10; do
Java程序设计课件：第二章 运算符和语句.ppt
06-01
Java编程语言中的运算符和语句是编程的基础，它们用于执行计算、比较、逻辑判断以及控制程序流程。在本章中，我们将详细讨论这些概念。 首先，自增和自减运算符（`++`和`--`）是两种常用的单目运算符。前缀形式（如...
c语言第二章程序的流程控制.pptx
09-27
在C语言中，程序的流程控制是编程的基础，它决定了程序执行的顺序和逻辑。本章节主要探讨了选择（分支）结构，这是程序设计中必不可少的一部分。选择结构允许程序根据不同的条件执行不同的代码块，从而实现灵活的...
《C语言》课件教案PPT第04章C语言的流程控制共90页
10-30
流程控制指的是程序执行的顺序和路径，它包括条件语句、循环语句以及选择性结构，是编写复杂逻辑和实现算法的基础。 在第04章的课件中，通常会涵盖以下知识点： 1. **条件语句**：这是程序根据特定条件执行不同...
【C++&Python&Java】字符处理详细解读_字符_ASCLL码_字母数字转换_算法竞赛_开发语言
最新发布
YLCHUP的博客
07-15 861
C++和Python和Java三语言超全讲解，详细辨析字符的妙用。让你熟练玩转“字符”这一数据类型。快来看ヾ(•ω•`)o
java内部类的本质
qq_43593646的博客
07-12 530
可以定义一个类Pair，包括最大值和最小值，但Pair这个名字太普遍，而且它主要是类内部使用的，就可以定义为一个静态内部类。内部类访问了外部类的一个私有静态变量shared，而我们知道私有变量是不能被类外部访问的，Java的解决方法是：自动为Outer生成一个非私有访问方法access$0，它返回这个私有静态变量shared。外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能使用内部类实现这个接口，这个内部类可以被设为private，对外完全隐藏。
java后端项目启动失败，解决端口被占用问题
SUMMERENT的博客
07-11 321
报错信息： Web server failed to start . Port 8020 was already in use.netstat -ano | findstr 端口号。taskkill /F /PID 进程ID。举例：关闭8020端口。
使用Nginx实现高效负载均衡
@云安全小杜
07-12 720
Nginx是一款高性能的HTTP和反向代理服务器，广泛用于Web服务的负载均衡。它能有效分发流量至多个后端服务器，提高网站的可用性和响应速度，同时增强系统的可扩展性和安全性。本文将介绍如何配置Nginx进行负载均衡，并提供具体的配置示例。Nginx提供了强大而灵活的负载均衡功能，通过合理配置，可以显著提升Web服务的性能和稳定性。无论是小型项目还是大型集群，Nginx都能提供有效的解决方案。以上配置示例为基本的负载均衡设置，实际场景中可能需要根据具体需求进行更详细的定制。
java程序设计_课件_第2章__java语言基础.ppt
05-16
java程序设计_课件_第2章__java语言基础.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值