Java基础教程-02-运算符与选择循环结构

最新推荐文章于 2024-07-13 22:56:10 发布
最新推荐文章于 2024-07-13 22:56:10 发布
阅读量681 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kc44601/article/details/123941873
版权

Java基础教程-02-运算符与选择循环

1. 关系运算符

1.1 概述

关系运算符就是用来描述两个变量或者常量之间的关系的.主要分为以下6种:

符号说明
==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

1.2 注意事项

• 关系运算符的结果都是boolean类型，要么是true，要么是false。
• 千万不要把==写成了=, 否则结果可能不是你想要的.

1.3 案例

需求

  1. 定义两个int类型的变量a和b, 分别赋值为10和5.
  2. 通过关系运算符比较这两个变量之间的关系, 并打印结果.
    参考代码
public class OperatorDemo01 {
    public static void main(String[] args) {
        //定义两个int类型的变量a和b, 分别赋值为10和5.
        int a = 10;
        int b = 5;
        //通过`关系运算符`比较这两个变量之间的关系, 并打印结果.
        System.out.println(a > b);
        System.out.println(5 >= 5);
        System.out.println(a < b);
        System.out.println(5 <= 5);
        System.out.println(a != b);
        System.out.println(a == b);
        System.out.println(a = b);
        
        //关系运算符的最终结果是boolean类型, 所以我们也可以用boolean类型的变量接收.
        boolean flag = 10 < 5;
        System.out.println(flag);
    }
}

运行结果为:

true
true
false
true
true
false
5
false

2. 逻辑运算符

2.1 概述

• 逻辑运算符是用来判断并且, 或者, 除非等逻辑关系的符号.
• 该符号两端一般连接值为布尔类型的关系表达式
例如: 某企业招工, 要求年龄必须在 20 ~ 65岁之间.

2.2 分类

注意: 假设下表中的a和b, 都是boolean类型的值.

符号作用说明
&逻辑与a&b，并且的意思. 有false则整体为false, 都为true, 则整体为true.
|逻辑或a|b，或者的意思, 有true则整体为true, 都为false, 则整体为false.
!逻辑非!a，取反的意思, 以前为true, 取反后为false, 以前为false, 取反后为true.
^逻辑异或a^b，异同的意思, 相同为false, 不同为true.

小技巧:
对一个布尔数据, 偶数次取反, 该数据值不变.
!true = false

2.3 示例: 逻辑运算符入门

需求

  1. 定义三个int类型的变量a, b, c, 它们的初始化值分别为10, 20, 30.
  2. 通过上述的三个变量, 演示各个逻辑运算符.
    参考代码
public class OperatorDemo02 {
    public static void main(String[] args) {
        int a = 10, b = 20, c = 30;
        //&: 逻辑与, 并且的意思, 有false则整体为false.
        //相当于: 班长找女朋友, 要求长得漂亮, 并且身材好.
        System.out.println((a > b) & (a > c)); //false & false
        System.out.println((a < b) & (a > c)); //true & false
        System.out.println((a > b) & (a < c)); //false & true
        System.out.println((a < b) & (a < c)); //true & true
        System.out.println("-----------------");

        //|: 逻辑或, 或者的意思, 有true则整体为true.
        //相当于: 降低条件了, 要么长得漂亮, 要么身材好.
        System.out.println((a > b) | (a > c)); //false | false
        System.out.println((a < b) | (a > c)); //true | false
        System.out.println((a > b) | (a < c)); //false | true
        System.out.println((a < b) | (a < c)); //true | true
        System.out.println("-----------------");

        //!: 逻辑非, 取反的意思
        //相当于: 只要不是男的就行.
        System.out.println(!(a > b));   //!false
        System.out.println(!(a < b));   //!true
        System.out.println("-----------------");

        //逻辑异或, 异同的意思, 相同为false, 不同为true.
        //相当于: 最后还是找了个男的, 但是领不了证.
        //法律规定: 一夫一妻, 一男一女, 必须是异性才能领证.
        System.out.println((a > b) ^ (a > c)); //false ^ false
        System.out.println((a < b) ^ (a > c)); //true ^ false
        System.out.println((a > b) ^ (a < c)); //false ^ true
        System.out.println((a < b) ^ (a < c)); //true ^ true
    }
}

运行结果为:

false
false
false
true
-----------------
false
true
true
true
-----------------
true
false
-----------------
false
true
true
false

2.4 短路逻辑运算符

在实际开发中, 并且, 或者这样的操作是非常多的, 但是上述的&(逻辑与), !(逻辑或)运算符没有短路效应, 所以效率相对较低, 针对这种情况, 我们可以使用&&(短路与), ||(短路或)来优化.

2.4.1 格式
符号作用说明
&&短路与作用和&相同，但是有短路效果, 前边出现false, 后边不执行.
||短路或作用和 | 相同，但是有短路效果, 前边出现true, 后边不执行.
2.4.2 解释

• 在短路与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与运算符就有这样的效果，可以提高效率。
• 同理在短路或运算中，一旦发现值为true，右边的表达式将不再参与运算。

2.4.3 短路和非短路之间的区别

• 逻辑与 和 短路与之间的区别
  – 逻辑与&(也叫单与): 无论左边真假，右边都要执行。
  – 短路与&&(也叫双与): 如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或 和 短路或之间的区别
  – 逻辑或|(也叫单或): 无论左边真假，右边都要执行。
  – 短路或||(也叫双或): 如果左边为假，右边执行；如果左边为真，右边不执行。
• 记忆: 在实际开发中, 我们用的最多的逻辑运算符就是: &&, ||, !

2.4.4 案例

需求
参考代码

public class OperatorDemo03 {
    public static void main(String[] args) {
        //1. 定义两个int类型的变量a和b, 初始化值分别为: 2, 5
        int a = 2, b = 5;
        //2. 演示逻辑与(&)
       /* System.out.println((a++ > 2) & (b++ < 7)); //两个表达式都会执行.
        System.out.println(a);
        System.out.println(b);*/
        System.out.println("------------------");

        //3. 演示短路与(&&)
        System.out.println((a++ > 2) && (b++ < 7)); //左边表达式结果为false, 右边不执行.
        System.out.println(a);
        System.out.println(b);
    }
}

运行结果为:

false
3
5

3. 三元运算符

3.1 格式

三元运算符也叫三目运算符，即由三部分组成，格式如下：
(关系表达式) ? 表达式1：表达式2；

3.2 执行流程

  1. 先执行关系表达式, 看其结果是true还是false.
  2. 如果是true, 则执行表达式1
  3. 如果是false, 则执行表达式2

3.3 案例一: 入门案例

需求

  1. 定义两个int类型的变量a. b, 初始化值分别为10, 20
  2. 通过三元运算符, 获取变量a和b的最大值.
  3. 将结果(最大值)打印到控制台上.
    参考代码
public class OperatorDemo04 {
    public static void main(String[] args) {
        //1. 定义两个int类型的变量a. b, 初始化值分别为10, 20
        int a = 10, b = 20;
        //2. 通过三元运算符, 获取变量a和b的最大值.
        int max = a < b ? b : a;
        //3. 将结果(最大值)打印到控制台上.
        System.out.println(max);
    }
}

运行结果为:

max=20

3.4 案例二: 判断老虎体重

需求
动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
参考代码

public class OperatorDemo05 {
    public static void main(String[] args) {
        //1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
        int weight1 = 180;
        int weight2 = 200;
        //2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
        boolean flag = weight1 == weight2 ? true : false;
        //3：输出结果
        System.out.println("flag:" + flag);
    }
}

运行结果为:

flag = false
-----------------
flag2: false

3.5 案例三: 获取和尚的最高身高

需求

  1. 一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm.
  2. 请用程序实现获取这三个和尚的最高身高。
    参考代码
public class OperatorDemo06 {
    public static void main(String[] args) {
        /*
            需求:
                1.一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm.
                2.请用程序实现获取这三个和尚的最高身高。
         */
        //1. 定义三个变量, 分别记录三个和尚的身高.
        int h1 = 150, h2 = 210, h3 = 165;
        //2. 通过三元运算符先获取前两个和尚的最高身高.
        int temp = h1 > h2 ? h1 : h2;
        //3. 在通过三元运算符, 获取 第二步获取的身高 和 第三个和尚之间的 最高身高.
        //此时, 我们获取的就是三个和尚中的最高身高.
        int max = temp > h3 ? temp : h3;
        //4. 打印结果.
        System.out.println("max: " + max);

        //方式二: 通过三元运算符嵌套实现, 目前只要能看懂即可.
        //h1 > h2 ? 说明h1高,比较h1和h3 : 说明h2高, 比较h2和h3;
        //int max2 = (h1 > h2) ? (h1 > h3 ? h1 : h3) : (h2 > h3 ? h2 : h3);
        //最终版
        int max2 = h1 > h2 ? h1 > h3 ? h1 : h3 : h2 > h3 ? h2 : h3;
        System.out.println("max2: " + max2);
    }
}

运行结果为:

max: 210
max2: 210

4. 键盘录入

4.1 概述

之前我们涉及到的数据都是写死的, 固定的数据, 这样做用户体验并不好, 我们就想着, 能不能让用户录入数据, 我们通过特定的代码来接收, 这样做就非常好玩儿了, 针对于这种情况, 我们可以通过键盘录入来实现.
即: Java中键盘录入功能指的就是Scanner类, 我们可以通过它的一些方法, 来获取用户录入的数据.

4.2 使用步骤

  1. 导包. 包就是文件夹.
    注意:
    – Scanner类是java.util包下的类, 使用之前必须要先导包.
    – 导包的语句是定义在类的上面的, 格式如下:
    import java.util.Scanner;
  2. 创建Scanner类的对象, 格式为:
    //暂时先理解为固定格式, 也就是必须这么写.
    Scanner sc = new Scanner(System.in);
  3. 通过Scanner类的nextInt()方法接收用户录入的数据.
    int a = sc.nextInt();

4.3 案例一: Scanner入门

需求

  1. 提示用户录入他/她的年龄.
  2. 通过键盘录入功能, 接收用户录入的年龄.
  3. 将用户录入的数据(年龄)打印到控制台上.

参考代码

public class ScannerDemo01 {
    public static void main(String[] args) {
        //1.提示用户录入他/她的年龄.
        System.out.println("请录入您的年龄: ");
        //2.通过键盘录入功能, 接收用户录入的年龄.
        //2.1 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //2.2 接收用户录入的年龄.
        int age = sc.nextInt();
        //3.将用户录入的数据(年龄)打印到控制台上
        System.out.println("您的年龄是:" + age);
    }
}

运行结果为:

请录入您的年龄: 
20
您的年龄是:20

4.4 案例二: 键盘录入版和尚身高

需求

  1. 提示用户录入第一个和尚的身高, 并接收
  2. 提示用户录入第二个和尚的身高, 并接收
  3. 提示用户录入第三个和尚的身高, 并接收.
  4. 通过三元运算符, 获取三个和尚中身高最矮的那个和尚的身高.
  5. 将结果(最低身高)打印到控制台上.

参考代码

public class ScannerDemo02 {
    public static void main(String[] args) {
        //1. 创建Scanner类型的对象.   细节: 由IDEA自动导包
        Scanner sc = new Scanner(System.in);
        //2. 提示用户录入三个和尚的身高并接收.
        System.out.println("请录入第一个和尚的身高:");
        int h1 = sc.nextInt();
        System.out.println("请录入第二个和尚的身高:");
        int h2 = sc.nextInt();
        System.out.println("请录入第三个和尚的身高:");
        int h3 = sc.nextInt();

        //用三元运算符获取前两个和尚的较低身高值，并用临时身高变量保存起来。
        int temp = h1 < h2 ? h1 : h2;
        //用三元运算符获取临时身高值和第三个和尚身高较低值，并用最低身高变量保存。
        int min = temp < h3 ? temp : h3;


        //3. 通过三元获取三个和尚的最高身高.
//        int max = h1 > h2 ? h1 > h3 ? h1 : h3 : h2 > h3 ? h2 : h3;

        //4. 打印结果.
        System.out.println("这三个和尚中身高最低的是：" + min +"cm");
    }
}

运行结果为:

请录入第一个和尚的身高:
200
请录入第二个和尚的身高:
165
请录入第三个和尚的身高:
180
这三个和尚中身高最低的是：165cm

5. 练习

需求
• 提示用户键盘录入一个三位数, 并接收.
• 求这个数的个位,十位,百位分别是多少.
• 并将结果打印到控制台上.
参考代码

package com.luokk.demo02_scanner;

import java.util.Scanner;

//案例: 获取三位数的各个位数上的数字, 并打印结果.
public class ScannerDemo03 {
    public static void main(String[] args) {
        /*
            需求:
                1. 提示用户键盘录入一个三位数, 并接收.
                2. 求这个数的个位,十位,百位分别是多少.
                3. 并将结果打印到控制台上.
         */
        //1. 提示用户录入一个三位数.
        System.out.println("请录入一个三位整数: ");
        //2 创建键盘录入对象.
        Scanner sc = new Scanner(System.in);
        //3. 接收用户录入的数字.
        int num = sc.nextInt();
        //4. 获取该三位数的各个位数数字.
        /*
            规律:  例如: 1153
                个位:  153 / 1  % 10  = 3                  商15, 余3
                十位:  153 / 10 % 10 = 5
                百位:  153 / 100 % 10   = 1
         */
        int ge = num / 1 % 10;
        int shi = num / 10 % 10;
        int bai = num / 100 % 10;
        //5. 打印结果.
        System.out.println("您录入的数字是 " + num + ", 该数字的个位数是 " + ge + ", 十位是 " + shi + ", 百位是 " + bai);
        //System.out.println("ge: " + ge);
    }
}

运行结果为:

请录入一个三位整数: 
123
您录入的数字是 123, 该数字的个位数是 3, 十位是 2, 百位是 1

6. 流程控制

6.1 概述

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
例如: 某些代码是满足特定条件的情况下, 才会被执行. 而有些代码, 在满足某些条件的情况下, 需要重复执行, 这些, 都需要用到流程控制语句.

6.2 分类

• 顺序结构
• 选择结构(if语句, switch.case语句)
• 循环结构(for循环, while循环, do.while循环)

6.3 顺序结构

概述
顺序结构指的是代码是按照从上往下, 从左往右的顺序, 依次逐行执行的, 且顺序结构也是Java程序的默认结构.
图解
在这里插入图片描述

需求
定义类OrderDemo01, 在类中定义main方法, 打印如下数据:

//start
//HelloWorld1
//HelloWorld2
//HelloWorld3
//end

参考代码

public class OrderDemo01 {
    public static void main(String[] args) {
        //打印指定的数据
        System.out.println("start");
        System.out.println("HelloWorld1");
        System.out.println("HelloWorld2");
        System.out.println("HelloWorld13");
        System.out.println("end");
    }
}

7. 选择结构之if语句

7.1 概述

如果我们想某些代码是在满足条件的情况下, 才能被执行, 此时就需要用到选择结构了, 选择结构也叫分支结构, 主要分为以下两种:
• if语句
• switch.case语句

7.2 分类

if 语句一般用于范围的判断, 例如: 如果当前时间是0~8点, 小黑就和你说: 早上好, 如果当前时间是9 ~12点, 小黑就和你说: 中午好. 根据应用场景的不同(即: 分支个数不同), if语句的格式主要分为以下三种:

  1. if语句(也叫: 单分支)
  2. if.else语句(也叫: 双分支)
  3. if.else if语句(也叫: 多分支)

7.3 单分支

单分支结构一般用来判断一种情况, 格式如下:
格式

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

执行流程

  1. 先执行关系表达式, 看其结果是true还是false.
  2. 如果是true, 则执行大括号中的语句体.
  3. 如果是false, 则大括号中的语句体不执行.

图解
在这里插入图片描述需求
定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则不操作.
解释: [0, 8], 意思是说 0~8之间, 包含0, 也包含8, 这种写法属于"前闭后闭".
[0, 8), 意思是: 0~8之间, 包含0, 不包含8, 这种写法属于"前闭后开", 也叫: 包左不包右.
参考代码

public class IfDemo01 {
    public static void main(String[] args) {
        //定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则不操作.
        System.out.println("start");
        int time = 30;
        //if结构之单分支
        if (time >= 0 && time <= 8) {
            System.out.println("早上好");
        }
        System.out.println("end");
    }
}

运行结果为:

start
end

7.4 双分支

双分支结构指的是if. else语句, 一般用来判断两种情况, 格式如下:

7.4.1 格式
if(关系表达式) {	//if的意思: 如果
    //语句体1;
} else {	   //否则...
    //语句体2;
}
7.4.2 执行流程
  1. 先执行关系表达式, 看其结果是true还是false.
  2. 如果是true, 则执行语句体1.
  3. 如果是false, 则执行语句体2.
7.4.3 图解

在这里插入图片描述

7.4.5 案例一: if格式二入门

需求
定义变量time表示时间, 如果它的范围是在0~8之间, 就打印早上好, 否则就打印中午好.
参考代码

public class IfDemo02 {
    public static void main(String[] args) {
        //定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则就打印中午好.
        System.out.println("start");
        int time = 6;
        //方式一: if结构之双分支
        if (time >= 0 && time <= 8) {
            System.out.println("早上好");
        } else {
            System.out.println("中午好");
        }
        System.out.println("------------------------");

        //方式二: 通过三元运算符实现
        //time >= 0 && time <= 8 ? System.out.println("早上好") : System.out.println("中午好"); 这样写会报错
        //分解版
        String str = time >= 0 && time <= 8 ? "早上好" : "中午好";
        System.out.println(str);
        System.out.println("------------------------");

        //最终版
        System.out.println(time >= 0 && time <= 8 ? "早上好" : "中午好");
        System.out.println("end");
    }
}

运行结果为:

start
早上好
------------------------
早上好
------------------------
早上好
end
7.4.6 案例二: 判断奇偶数

需求

  1. 提示用户键盘录入一个数据并接收.
  2. 判断该数据是奇数还是偶数, 并将结果打印到控制台上.
    参考代码
import java.util.Scanner;

//案例: 演示判断奇偶数.
public class IfDemo03 {
    public static void main(String[] args) {
        //1.提示用户键盘录入一个数据并接收.
        System.out.println("请录入一个数字: ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        //2.判断该数据是奇数还是偶数, 并将结果打印到控制台上.
        //方式1: if.else实现
        if (num % 2 == 0) {
            System.out.println(num + "是偶数");
        } else {
            System.out.println(num + "是奇数");
        }
        System.out.println("------------------------");

        //方式2: 三元运算符
        System.out.println(num + (num % 2 == 0 ? "是偶数" : "是奇数"));
    }
}

运行结果为:

请录入一个数字: 
10
10是偶数
------------------------
10是偶数

记忆

  1. if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写.
    例如:
    if(5 > 3)
    System.out.println(“夯哥最纯洁!”);
  2. if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写, 定义变量的语法除外.
    例如:
    if(5 > 3)
    int a = 10; //这样写会报错, jvm会识别这样代码为两行: int a; a = 10;
    上述的代码就相当于:
    if(5 > 3) {
    int a;
    }
    a = 10; //这样写肯定会报错.
  3. 你省略if后边的大括号时, 有个问题一定要注意, 不要乱写分号.
    例如:
    if(5 > 3) ; //这里如果写分号了, 就意味着if语句结束了.
    System.out.println(“本意: 这行代码只有条件成立才会被执行”);

7.5 多分支

多分支结构指的是if. else if语句, 一般用来判断多种情况, 格式如下:

7.5.1 格式
if(关系表达式1) {
    //语句体1;
} else if(关系表达式2){
    //语句体2;
} else if(关系表达式3){	//这里可以根据需求, 有多个else if语句
    //语句体3;
} else {
    //语句体n;
}
7.5.2 执行流程
  1. 先执行关系表达式1, 看其结果是true还是false.
  2. 如果是true, 则执行语句体1, 整个if语句结束.
  3. 如果是false, 则判断关系表达式2, 看其结果是true还是false.
  4. 如果是true, 则执行语句体2, 整个if语句结束.
  5. 如果是false, 则判断关系表达式3, …以此类推.
  6. 如果所有的关系表达式都不成立, 则执行else语句的语句体n, 整个if语句结束.
7.5.3 图解

在这里插入图片描述

7.5.4 案例一: 打印星期

需求

  1. 提示用户录入[1, 7]之间的数字, 并接收.
  2. 根据用户录入的数字, 打印对应的星期, 格式如下:
      – 用户录入1, 打印"星期一"
      – 用户录入2, 打印"星期二"
      – …以此类推
      – 用户录入非法数字, 打印"没有这样的日期"

参考代码

import java.util.Scanner;

//案例: if多分支之: 打印星期.
public class IfDemo04 {
    public static void main(String[] args) {
        //需求: 接收用户录入的数字[1, 7], 然后打印对应的星期.
        //1. 接收用户录入的数字.
        System.out.println("请录入一个数字: ");
        Scanner sc = new Scanner(System.in);
        int week = sc.nextInt();

        //2. 通过if. else if 实现判断用户录入的是星期几, 并打印结果.
        if (week == 1) {
            System.out.println("星期一");
        } else if (week == 2) {             //else的隐含条件是: week != 1
            System.out.println("星期二");
        } else if (week == 3) {             //else的隐含条件是: week != 1 && week != 2
            System.out.println("星期三");
        }else if (week == 4) {
            System.out.println("星期四");
        }else if (week == 5) {
            System.out.println("星期五");
        }else if (week == 6) {
            System.out.println("星期六");
        }else if (week == 7) {
            System.out.println("星期日");
        }else  {
            System.out.println("你是从火星来的吧, 地球没有这样的星期!");
        }
    }
}

运行结果为:

请录入一个数字: 
6
星期六
7.5.5 案例二: 发放奖励

需求

  1. 小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
  2. 假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
  3. 礼物标准如下:
      – 95~100 山地自行车一辆
      – 90~94 游乐场玩一次
      – 80~89 变形金刚玩具一个
      – 80以下 胖揍一顿

参考代码

import java.util.Scanner;

//案例: if多分支之 发放奖励.
/*
    测试代码的小技巧, 测试3类值
        1. 正确的值.
        2. 非法值.
        3. 边界值.
 */
public class IfDemo05 {
    public static void main(String[] args) {
        /*
            需求(规则)
               95~100 山地自行车一辆
               90~94 游乐场玩一次
               80~89 变形金刚玩具一个
               80以下 胖揍一顿
         */
        //1. 接收用户录入的成绩.
        System.out.println("请录入小明的成绩: ");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();

        //2. 通过if. else if 实现判断用户录入的成绩, 并发放对应的奖励.
        if (score >= 95 && score <= 100) {
            System.out.println("奖励: 山地自行车一辆");
        } else if (score >= 90 && score < 95) {
            System.out.println("奖励: 游乐场玩一次");
        }else if (score >= 80 && score < 90) {
            System.out.println("奖励: 变形金刚玩具一个");
        }else if (score >= 0 && score < 80) {
            System.out.println("奖励: 男女组合拳一套 + 扫帚棒法");
        } else {
            System.out.println("录入的成绩有误!...");
        }
        System.out.println("----------------------------");

        //优化版
        if(score > 100 || score < 0) {
            System.out.println("录入的成绩有误!...");
        } else if (score >= 95) {                         //else的隐含条件是:  score >= 0 && score <= 100
            System.out.println("奖励: 山地自行车一辆");
        } else if (score >= 90) {                         //else的隐含条件是:  score >= 0 && score < 95
            System.out.println("奖励: 游乐场玩一次");
        }else if (score >= 80) {                         //else的隐含条件是:  score >= 0 && score < 90
            System.out.println("奖励: 变形金刚玩具一个");
        }else{                                          //else的隐含条件是:  score >= 0 && score < 80
            System.out.println("奖励: 男女组合拳一套 + 扫帚棒法");
        }
    }
}

运行结果为:

请录入小明的成绩: 
85
奖励: 变形金刚玩具一个
----------------------------
奖励: 变形金刚玩具一个
7.5.6 案例三: 获取最大值

需求

  1. 提示用户录入3个整数, 并接收.
  2. 通过if语句获取这三个整数的最大值.
  3. 将结果打印到控制台上.

参考代码

import java.util.Scanner;

//案例: if.else if 实现, 获取三个整数的最大值.
public class IfDemo06 {
    public static void main(String[] args) {
        //1. 接收用户录入的数字.
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个数字: ");
        int a1 = sc.nextInt();
        System.out.println("请录入第二个数字: ");
        int a2 = sc.nextInt();
        System.out.println("请录入第三个数字: ");
        int a3 = sc.nextInt();

        //2.获取三个整数的最大值.
        //方式1: if.else 嵌套版.
        int max1 = a1;          //假设a1是最大值.
        if (a1 > a2) {
            //a1 比 a2大
            if (a1 > a3) {
                max1 = a1;
            } else {
                max1 = a3;
            }
        } else {
            //a2 大于或者等于 a1
            if (a2 > a3) {
                max1 = a2;
            } else {
                max1 = a3;
            }
        }
        System.out.println("max1: " + max1);

        //方式2: 简单暴力版.
        int max2 = a1;
        if (a1 > a2 && a1 > a3) {
            max2 = a1;
        } else if (a2 > a1 && a2 > a3) {
            max2 = a2;
        } else {
            max2 = a3;
        }
        System.out.println("max2: " + max2);

        //方式3: 三元运算符嵌套版, 自己写.
    }
}

运行结果为:

请录入第一个数字: 
1
请录入第二个数字: 
3
请录入第三个数字: 
5
max1: 5
max2: 5

8. 选择结构之switch语句

8.1 概述

switch语句, 一般是用于做固定值判断的, 在实际开发中, 用到的频率也非常高, 所以也是要求大家掌握的知识点.

8.2 格式

switch(表达式) {
    case 值1: 	
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ...    //根据需求, 可以写多组case.
    default:	
        语句体n;
        break;
}

8.3 格式详解

在这里插入图片描述

8.4 执行流程

  1. 先计算表达式的值, 然后按照从上往下的顺序依次和每一个case对应的值相匹配.
  2. 如果能匹配成功, 则执行该case对应的语句体, 然后执行break, 至此, 整个switch语句结束.
  3. 如果和所有的case值都不匹配, 则执行default对应的语句体, 然后执行break, 至此, 整个switch语句结束.
    解释: default语句就类似于if. else语句中的else, 当所有条件都不满足时才会执行.

8.5 执行流程图解

在这里插入图片描述

8.6 示例一: 春夏秋冬

需求

  1. 一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。
  2. 具体标准如下:
     – 输入： 1、2、12 输出：冬季
     – 输入： 3、4、5 输出：春季
     – 输入： 6、7、8 输出：夏季
     – 输入： 9、10、11 输出：秋季
     – 输入：其它数字 输出：数字有误

参考代码

import java.util.Scanner;

//案例: 演示switch语法 入门案例.
public class SwitchDemo01 {
    public static void main(String[] args) {
        /*
            规则:
                输入： 1、2、12 输出：冬季
                输入： 3、4、5 输出：春季
                输入： 6、7、8 输出：夏季
                输入： 9、10、11 输出：秋季
                输入：其它数字 输出：数字有误
         */
        //1. 提示用户录入一个月份并接收.
        System.out.println("请录入一个月份: ");
        Scanner sc = new Scanner(System.in);
        int month = sc.nextInt();

        //2. 通过switch.case语句判断月份, 并打印对应的结果.
        switch (month) {    //表达式可以放: byte, short, char, int,  JDK1.5: 枚举,  JDK1.7: String
            case 12:
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;
            case 3:
                System.out.println("春季");
                break;
            case 4:
                System.out.println("春季");
                break;
            case 5:
                System.out.println("春季");
                break;
            case 6:
                System.out.println("夏季");
                break;
            case 7:
                System.out.println("夏季");
                break;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            default:        //类似于 if.else语法的 else结构.
                System.out.println("没有这样的月份!...");
                break;
        }
    }
}

运行结果为:

请录入一个月份: 
3
春季

8.7 case穿透

概述
在switch语句中，如果case的后面不写break，将出现case穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
格式

switch(表达式) {
    case 值1: 	
        语句体1;	//假设表达式的值 = 值1, 则执行完语句体1后, 不会判断第二个case, 直接执行语句体2;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ...    //根据需求, 可以写多组case.
    default:	
        语句体n;
        break;
}

需求 通过case穿透, 优化刚才的春夏秋冬案例.
参考代码

import java.util.Scanner;

//案例: 演示switch语法 case 穿透.
/*
    case穿透解释:
        在switch语句中，如果case的后面不写break，将出现case穿透现象，
        也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
 */
public class SwitchDemo02 {
    public static void main(String[] args) {
        /*
            规则:
                输入： 1、2、12 输出：冬季
                输入： 3、4、5 输出：春季
                输入： 6、7、8 输出：夏季
                输入： 9、10、11 输出：秋季
                输入：其它数字 输出：数字有误
         */
        //1. 提示用户录入一个月份并接收.
        System.out.println("请录入一个月份: ");
        Scanner sc = new Scanner(System.in);
        int month = sc.nextInt();

        //2. 通过switch.case语句判断月份, 并打印对应的结果.
        switch (month) {    //表达式可以放: byte, short, char, int,  JDK1.5: 枚举,  JDK1.7: String
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            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;
            default:        //类似于 if.else语法的 else结构.
                System.out.println("没有这样的月份!...");
                break;      //这个break写不写都行.
        }
    }
}

8.8 案例二: 发放奖励

需求

  1. 小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
  2. 假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
  3. 礼物标准如下:
     – 90~100 山地自行车一辆
     – 80~89 游乐场玩一次
     – 70~79 变形金刚玩具一个
     – 70以下 胖揍一顿

参考代码

import java.util.Scanner;

//案例: 发放奖励switch版.
public class SwitchDemo03 {
    public static void main(String[] args) {
        /*
            发放奖励的规则:
                90~100 山地自行车一辆
                80~89 游乐场玩一次
                70~79 变形金刚玩具一个
                70以下 胖揍一顿
         */
        //1. 接收用户录入的成绩.
        System.out.println("请录入小明的成绩: ");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();

        //2.通过if限定考试成绩必须合法.
        if (score >= 0 && score <= 100) {
            //走到这里, 说明考试成绩合法.
            //3. 通过switch.case语句发放奖励
            switch (score / 10) {   //结果: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
                case 10:
                case 9:
                    System.out.println("奖励: 山地自行车一辆");
                    break;
                case 8:
                    System.out.println("奖励: 游乐场玩一次");
                    break;
                case 7:
                    System.out.println("奖励: 变形金刚玩具一个");
                    break;
                default:
                    System.out.println("奖励: 胖揍一顿");
            }
        } else {
            //走到这里, 说明成绩不合法
            System.out.println("没有这样的成绩, 你是从火星来的吧? ");
        }
    }
}

9. 循环结构

9.1 概述

循环，即事物周而复始的变化。循环结构指的是，使一部分代码按照次数或一定的条件反复执行的一种代码结构. 有些时候, 我们想代码是在满足某些条件的情况下, 重复(循环)执行的, 就需要用到循环结构了.
例如: 打印100次HelloWorld. 如果不用循环实现的话, 输出语句我们就需要写100次, 我们发现这样做是非常繁琐的. 于是, 我们可以通过循环来优化它.

9.2 组成

  1. 初始化条件.
    假设用int类型的变量x记录循环次数,x从1开始数, 数到100刚好100次, 1在这里充当的角色就是: 初始化条件.
  2. 判断条件.
    变量x从1开始数, 数到100结束. 即: x <= 100, 这就是判断条件, 用来决定循环是否继续执行的.
  3. 控制条件.
    用来控制变量x变化的. 每循环一次, 变量x的值+1. 即: x++就是控制条件.
  4. 循环体.
    指的是需要重复执行的代码, 例如: System.out.println(“Hello World!”);

9.3 分类

• for循环
一般适用于循环次数固定的情况.
• while循环
一般适用于循环次数不固定的情况.
• do.while循环
我们在实际开发中, 基本不用. 适用于先执行一次, 然后判断的情况.

10. for循环

for循环是我们在实际开发中应用到的最多的循环, 它一般适用于循环次数固定的情况.

10.1 格式

for(初始化条件1; 判断条件2; 控制条件3) {
    //循环体4;
}

解释:

  1. 初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
  2. 判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
  3. 控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
  4. 循环体: 需要用来重复做的事情(代码).

10.2 执行流程

  1. 先执行初始化条件.
  2. 然后执行判断条件, 看其结果是true, 还是false.
  3. 如果是false, 则整个循环结束.
  4. 如果是true, 则执行循环体.
  5. 执行控制条件.
  6. 返回第2步, 继续往下重复执行.
    简单理解:
  7. 第一次执行: 1, 2, 4, 3. 假设判断条件成立.
  8. 重复执行: 2, 4, 3.
  9. 最后一次执行: 2 判断条件不成立, 循环结束.

10.3 图解

在这里插入图片描述

10.4 案例一: for循环入门

需求 通过for循环, 打印10次"Hello World!".
参考代码

public class ForDemo01 {
    public static void main(String[] args) {
        //需求: 通过for循环, 打印10次"Hello World!".
        for(int i = 1; i <= 10; i++) {
            System.out.println("Hello World");
            //System.out.println("Hello World" + i);
        }
    }
}

运行结果为:

Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World

10.5 案例二: 打印数字

需求

  1. 通过for循环, 打印1~5之间的数字.
  2. 通过for循环, 打印5~1之间的数字.

参考代码

public class ForDemo02 {
    public static void main(String[] args) {
        //1.通过for循环, 打印1~5之间的数字.
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        System.out.println("----------------------------");

        //2.通过for循环, 打印5~1之间的数字.
        for (int i = 5; i >= 1; i--) {
            System.out.println(i);
        }
    }
}

运行结果为:

1
2
3
4
5
----------------------------
5
4
3
2
1

10.6 案例三: 求和案例

需求
通过for循环, 获取1 ~ 5之间的数字之和.
参考代码

public class ForDemo03 {
    public static void main(String[] args) {
        //需求: 通过for循环, 获取1 ~ 5之间的数字之和.
        //核心点: 定义一个sum变量, 记录所有的数字和. 变量要定义到循环的 外 边.
        int sum = 0;

        for (int i = 1; i <= 5; i++) {
            //循环体, 即: 重复执行的代码
            sum += i;
        }
        //循环结束后, 打印sum变量的值, 即为: 总和.
        System.out.println(sum);
    }
}

运行结果为:

15

细节: 求和变量必须定义到for循环的外边, 如果定义到for循环的内容, 则每次循环都会被重置.

10.7 案例四: 求偶数和

需求 求1-100之间的偶数和，并把求和结果打印到控制台上.
参考代码

//案例: 求偶数和.
public class ForDemo04 {
    public static void main(String[] args) {
        //需求:  求1-100之间的偶数和，并把求和结果打印到控制台上.
        //1. 定义求和变量, 用来记录所有的偶数和.
        int sum = 0;
        //2. 通过for循环, 获取1~100之间所有的整数.
        for (int i = 1; i <= 100; i++) {     //2, 100 -> 102   102 * 25 = 2550
            //3. 判断当前遍历到的数字是否是偶数, 如果是, 就累加给 sum.
            if (i % 2 == 0) {
                //走到这里, 说明i是偶数
                sum += i;
            }
        }
        //4. 打印sum的值.
        System.out.println("sum: " + sum);

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

        //简化版
        //1. 定义求和变量, 用来记录所有的偶数和.
        int sum2 = 0;
        //2. 通过for循环, 获取1~100之间所有的 偶数.
        for (int i = 2; i <= 100; i += 2)
            //3. 能走到这里, 一定是偶数, 累加即可.
        {
            sum2 += i;
        }
        //4. 打印sum的值.
        System.out.println("sum2: " + sum2);
    }
}

运行结果为:

sum: 2550
--------------------------------
sum2: 2550

10.8 案例五: 获取水仙花数

需求
获取到所有的水仙花数, 并将结果打印到控制台上.
解释:

  1. 水仙花数是一个3位数的整数.
  2. 该数字的各个位数立方和相加等于它本身.
  3. 例如: 153就是水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 153

参考代码

public class ForDemo05 {
    public static void main(String[] args) {
        //需求: 获取到所有的水仙花数, 并将结果打印到控制台上.
        //1. 获取所有的三位数.
        for (int i = 100; i < 1000; i++) {
            //2. 获取该数字的各个位数值.
            int ge = i / 1 % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            //3. 判断其是否是水仙花数.
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i)
                //4. 如果是, 就打印.
            {
                System.out.println(i);
            }
        }

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


        //1. 获取所有的三位数.
        for (int i = 100, ge, shi, bai; i < 1000; i++) {
            //2. 获取该数字的各个位数值.
            ge = i / 1 % 10;
            shi = i / 10 % 10;
            bai = i / 100 % 10;
            //3. 判断其是否是水仙花数.
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i)
                //4. 如果是, 就打印.
            {
                System.out.println(i);
            }
        }
    }
}

运行结果为:

153
370
371
407
-------------------------------
153
370
371
407

10.9 案例六: 计数思想

需求
统计所有水仙花数的个数, 并将其打印到控制台上.
参考代码

//案例: 循环的计数思想
public class ForDemo06 {
    public static void main(String[] args) {
        //需求: 统计所有水仙花数的个数, 并将其打印到控制台上.
        //1. 定义统计变量, 用来记录水仙花数的个数, 该变量定义的循环的 外 边.
        int count = 0;
        //2. 通过for循环, 获取所有的3位数.
        for (int i = 100, ge, shi, bai; i < 1000; i++) {
            //3. 获取各个位数的数字.
            ge = i / 1 % 10;
            shi = i / 10 % 10;
            bai = i / 100 % 10;
            //4. 判断其是否是水仙花数.
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i)
                //5. 如果是, 统计变量就 +1
            {
                count++;
            }
        }
        //6. 循环结束后, 统计变量记录的就是所有的水仙花数, 直接打印它的结果就OK.
        System.out.println("水仙花数一共有: " + count + "个");
    }
}

运行结果为:

水仙花数一共有: 4个

11. while循环

while循环也是我们在实际开发中应用到的比较多的循环, 它一般适用于循环次数不固定的情况.

11.1 格式

初始化条件1;

while(判断条件2) {
    //循环体3;
    //控制条件4;
}

解释:

  1. 初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
  2. 判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
  3. 控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
  4. 循环体: 需要用来重复做的事情(代码).

11.2 执行流程

  1. 先执行初始化条件.
  2. 然后执行判断条件, 看其结果是true, 还是false.
  3. 如果是false, 则整个循环结束.
  4. 如果是true, 则执行循环体.
  5. 执行控制条件.
  6. 返回第2步, 继续往下重复执行.
    简单理解:
  7. 第一次执行: 1, 2, 3, 4. 假设判断条件成立.
  8. 重复执行: 2, 3, 4.
  9. 最后一次执行: 2 判断条件不成立, 循环结束.

11.3 图解

在这里插入图片描述

11.4 案例一: while循环入门

需求
在控制台打印10次HelloWorld.
参考代码

public class WhileDemo01 {
    public static void main(String[] args) {
        //需求: 在控制台打印10次HelloWorld.
        int i = 1;
        while(i <= 10) {
            System.out.println("HelloWorld " + i);;
            i++;        //控制条件
        }
        System.out.println("----------------");

        int x = 0;
        while(x < 10) {
            x++;        //控制条件
            System.out.println("HelloWorld " + x);;
        }
    }
}

运行结果为:

HelloWorld 1
HelloWorld 2
HelloWorld 3
HelloWorld 4
HelloWorld 5
HelloWorld 6
HelloWorld 7
HelloWorld 8
HelloWorld 9
HelloWorld 10
----------------
HelloWorld 1
HelloWorld 2
HelloWorld 3
HelloWorld 4
HelloWorld 5
HelloWorld 6
HelloWorld 7
HelloWorld 8
HelloWorld 9
HelloWorld 10

11.5 案例二: 求和

需求
获取1~100之间所有偶数和, 并将结果打印到控制台上.
参考代码

//案例: while循环, 求和思想.
public class WhileDemo02 {
    public static void main(String[] args) {
        //需求: 获取1~100之间所有偶数和, 并将结果打印到控制台上
        //1. 定义变量sum, 记录所有的偶数和.
        int sum = 0;
        //2. 通过while循环, 获取1~100之间所有的数字.
        int i = 1;
        while (i <= 100) {
            //3. 判断其是否是偶数.
            if (i % 2 == 0)
                //4. 如果是, 就累加给sum
            {
                sum += i;
            }

            //细节: 千万不要忘记 i++
            i++;
        }
        //5. 打印sum的结果.
        System.out.println("sum: " + sum);
        System.out.println("------------------------------");

        //1. 定义变量sum, 记录所有的偶数和.
        int sum2 = 0;
        //2. 通过while循环, 获取1~100之间所有的数字.
        int x = 2;
        while (x <= 100) {
            //3. 就累加给sum
            sum2 += x;
            //细节: 千万不要忘记 i++
            x+=2;
        }
        //5. 打印sum的结果.
        System.out.println("sum2: " + sum2);
    }
}

运行结果为:

sum: 2550
------------------------------
sum2: 2550

11.6 案例三: 珠穆朗玛峰

需求

  1. 已知世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米).
  2. 假如我有一张足够大的纸，它的厚度是0.1毫米.
  3. 请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

即: 纸张的厚度 >= 珠穆朗玛峰的高度

参考代码

//案例: 珠穆朗玛峰,  还是一个 计数思想.
public class WhileDemo03 {
    public static void main(String[] args) {
        //1. 定义变量, 记录纸张的厚度.
        double paper = 0.1;
        //2. 定义变量, 记录珠峰的高度.
        int zf = 8844430;
        //3. 定义变量, 记录折叠次数.
        int count = 0;
        //4. 通过while循环, 获取折叠次数, 只要纸张的厚度不大于珠峰的高度, 就一直折叠.
        while (paper < zf) {
            //5. 每折叠一次, 计数器+1
            //5.1 纸的厚度 * 2
            paper *= 2;
            //5.2 计数器+1
            count++;
        }
        //6. 打印计数器结果即可.
        System.out.println("折叠次数为: " + count);
    }
}

运行结果为:

折叠次数为: 27

12. do.while循环

do.while循环在实际开发中应用到的并不是特别多, 所以我们简单的了解下它的用法即可.

12.1 格式

初始化条件;

do {
    循环体;
    控制条件;
} while(判断条件);

解释:

  1. 初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
  2. 判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
  3. 控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
  4. 循环体: 需要用来重复做的事情(代码).

12.2 执行流程

  1. 先执行初始化条件.
  2. 再执行循环体.
  3. 再执行控制条件.
  4. 执行判断条件, 看其结果是true还是false.
  5. 如果是false, 则整个循环结束.
  6. 如果是true, 则返回第2步重复往下执行.
    简单理解:
  7. 第一次执行: 1, 2, 3, 4. 假设判断条件成立.
  8. 重复执行: 2, 3, 4.
  9. 最后一次执行: 2 判断条件不成立, 循环结束.

12.3 图解

在这里插入图片描述

12.4 案例: 打印HelloWorld

需求 通过do.while循环, 在控制台打印10次Hello World!
参考代码

public class DoWhileDemo01 {
    public static void main(String[] args) {
        //需求:  通过do.while循环, 在控制台打印10次Hello World!
        int i = 1;
        do{
            System.out.println("Hello World!");
            i++;
        }while(i <= 10);
    }
}

运行结果为:

Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

13. 循环扩展

13.1 三种循环之间的区别

  1. do.while循环和其他两个循环之间的区别
     – do.while循环是先执行一次, 后判断.
     – 而其他两个循环都是先执行判断条件, 然后决定是否执行循环体.
  2. for循环和其他两个循环之间的区别
     – for循环执行结束后, 初始化条件就不能继续使用了.
     – 而其他两个循环执行结束后, 初始化条件还可以继续使用.

13.2 死循环

13.2.1 概述

所谓的死循环指的是永不会结束的循环, 也就是循环的判断条件永远为true,
在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

13.2.2 分类

在Java中, 死循环的写法格式主要有以下3种:
• for( ; ; ) { }
• while(true){ }
• do { } while(true)

13.2.3 参考代码
public class DeadLoop {
    public static void main(String[] args) {
        /*for(;;) {
            System.out.println("Hello World!");
        }*/

        /*while(true) {
            System.out.println("Hello World!");
        }*/

        do {
            System.out.println("Hello World!");
        } while(true);
    }
}

14. 循环跳转

14.1 概述

有些时候, 我们想提前终止循环的执行, 或者跳过循环的某一次执行, 例如: 打印1~10之间, 所有不是3倍数的数字, 或者采用死循环让用户不断的录入他/她的账号和密码, 直到用户录入正确, 再终止循环. 这些都要用到循环控制跳转知识点.

14.2 分类

• break: 是用来终止循环的, 循环不再继续执行.
• continue: 用来结束本次循环, 进行下一次循环的, 循环还会继续执行.

14.3 案例一: break入门

需求 打印10次HelloWorld, 当打印第五次的时候, 结束循环.
参考代码

public class BreakDemo01 {
    public static void main(String[] args) {
        //需求: 打印10次HelloWorld, 当打印第五次的时候, 结束循环.
        for (int i = 1; i <= 10; i++) {
            //判断当前是否是第5次循环, 如果是, 结束循环.
            if (i == 5) {
                break;  //结束循环.
            }
            System.out.println("Hello World!  " + i);
        }
        System.out.println("end");
    }
}

运行结果为:

Hello World!  1
Hello World!  2
Hello World!  3
Hello World!  4
end

图解
在这里插入图片描述

14.4 案例二: continue入门

需求
打印1~10之间, 所有不是3倍数的整数.
参考代码

public class ContinueDemo02 {
    public static void main(String[] args) {
        System.out.println("start");
        //1. 通过for循环, 获取1 - 10之间所有的整数
        for (int i = 1; i <= 10; i++) {
            //2. 判断该数字是否是3的倍数.
            if (i % 3 == 0)
                //3. 如果是, 就结束本次循环
            {
                continue;
            }
            //4. 如果不是, 就打印该数字的值.
            System.out.println(i);
        }
        System.out.println("end");
    }
}

运行结果为:

start
1
2
4
5
7
8
10
end

图解
在这里插入图片描述

15. 循环嵌套

所谓的循环嵌套指的是循环结构中还包裹着循环结构, 外边的循环结构叫外循环, 里边的循环结构叫内循环.

15.1 格式

循环嵌套用的最多的就是for循环的嵌套, 具体格式如下:

for(初始化条件; 判断条件; 控制条件) {		//外循环, 例如: 5   1      2
   for(初始化条件; 判断条件; 控制条件) {		//内循环, 例如: 3   1,2,3  1,2,3
   	  //循环体;
   }
}

15.2 执行流程

  1. 外循环执行一次, 内循环执行一圈.
  2. 循环嵌套的总执行次数 = 外循环的次数 * 内循环的次数.
    例如:
  3. 现实世界中的年月关系, 即: 1年 = 12个月
  4. 现实世界中的时分, 分秒关系, 即: 1小时 = 60分钟, 1分钟=60秒.

15.3 案例一: 打印年月

需求
打印2020年1月至2023年12月之间所有的月份, 格式为: XXXX年XX月
参考代码

public class ForforDemo01 {
    public static void main(String[] args) {
        //需求: 打印2020年1月至2023年12月之间所有的月份, 格式为: XXXX年XX月
        //方式一: 复杂写法
        //打印2020年所有的月份
        for (int i = 1; i <= 12; i++) {
            //细节: \t叫水平制表符, 相当于 4个空格
            System.out.print("2020年" + i + "月\t");
        }
        //要换行
        System.out.println();

        //打印2021年所有的月份
        for (int i = 1; i <= 12; i++) {
            //细节: \t叫水平制表符, 相当于 4个空格
            System.out.print("2021年" + i + "月\t");
        }
        System.out.println();

        //打印2022年所有的月份
        for (int i = 1; i <= 12; i++) {
            //细节: \t叫水平制表符, 相当于 4个空格
            System.out.print("2022年" + i + "月\t");
        }
        System.out.println();

        //打印2023年所有的月份
        for (int i = 1; i <= 12; i++) {
            //细节: \t叫水平制表符, 相当于 4个空格
            System.out.print("2023年" + i + "月\t");
        }
        System.out.println();

        System.out.println("------------------------我是华丽的分割线------------------------");

        //方式二: 简化版, 采用循环嵌套.
        //1. 定义外循环, 控制年份
        for (int i = 2020; i <= 2023; i++) {
            //i的取值: 2020, 2021, 2022, 2023

            //2. 定义内循环, 控制每年的月份
            for (int j = 1; j <= 12; j++) {
                //细节: \t叫水平制表符, 相当于 4个空格
                System.out.print(i + "年" + j + "月\t");
            }
            System.out.println();       //千万记得要换行.
        }

    }
}

运行结果为:

2020年1月	2020年2月	2020年3月	2020年4月	2020年5月	2020年6月	2020年7月	2020年8月	2020年9月	2020年10月	2020年11月	2020年12月	
2021年1月	2021年2月	2021年3月	2021年4月	2021年5月	2021年6月	2021年7月	2021年8月	2021年9月	2021年10月	2021年11月	2021年12月	
2022年1月	2022年2月	2022年3月	2022年4月	2022年5月	2022年6月	2022年7月	2022年8月	2022年9月	2022年10月	2022年11月	2022年12月	
2023年1月	2023年2月	2023年3月	2023年4月	2023年5月	2023年6月	2023年7月	2023年8月	2023年9月	2023年10月	2023年11月	2023年12月	
------------------------我是华丽的分割线------------------------
2020年1月	2020年2月	2020年3月	2020年4月	2020年5月	2020年6月	2020年7月	2020年8月	2020年9月	2020年10月	2020年11月	2020年12月	
2021年1月	2021年2月	2021年3月	2021年4月	2021年5月	2021年6月	2021年7月	2021年8月	2021年9月	2021年10月	2021年11月	2021年12月	
2022年1月	2022年2月	2022年3月	2022年4月	2022年5月	2022年6月	2022年7月	2022年8月	2022年9月	2022年10月	2022年11月	2022年12月	
2023年1月	2023年2月	2023年3月	2023年4月	2023年5月	2023年6月	2023年7月	2023年8月	2023年9月	2023年10月	2023年11月	2023年12月

15.4 案例二: 打印矩形

需求

  1. 在控制台打印一个3行5列的矩形星星序列, 具体格式如下:
    在这里插入图片描述

  2. 要求: 一次只能打印一个"*"
    参考代码

public class ForForDemo02 {
    public static void main(String[] args) {
        //1. 定义外循环, 控制行数
        for (int i = 1; i <= 3; i++) {
            //2. 定义内循环, 控制每行的列数
            for (int j = 1; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();   //换行
        }
    }
}

运行结果为:

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

15.5 案例三: 打印正三角形

需求

  1. 在控制台打印一个5行5列的正三角形星星序列, 具体格式如下:
    在这里插入图片描述

  2. 要求: 一次只能打印一个"*"
    参考代码

public class ForForDemo03 {
    public static void main(String[] args) {
        //1. 定义外循环, 控制行数
        for (int i = 1; i <= 5; i++) {      //i的变化: 1, 2, 3, 4, 5
            //2. 定义内循环, 控制列数.
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

运行结果为:

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

小技巧: 打印正三角形和打印矩形相比: 判断条件发生变化.

15.6 案例四: 打印倒三角形

需求

  1. 在控制台打印一个5行5列的正三角形星星序列, 具体格式如下:
    在这里插入图片描述

  2. 要求: 一次只能打印一个"*"
    参考代码

public class ForForDemo04 {
    public static void main(String[] args) {
        //1. 定义外循环, 控制行数
        for (int i = 1; i <= 5; i++) {        //i的值的变化: 1, 2, 3, 4, 5
            //2. 定义内循环, 控制每行的列数
            for (int j = i; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();   //换行
        }
    }
}

运行结果为:

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

小技巧: 打印倒三角形和打印矩形相比: 初始化条件发生变化.

15.7 案例五: 打印99乘法表

需求
打印99乘法表, 格式如下
在这里插入图片描述
参考代码

public class ForForDemo05 {
    public static void main(String[] args) {
        //需求: 打印99乘法表
        //定义外循环, 控制: 第二个乘数
        for (int i = 1; i <= 9 ; i++) {
            //定义内循环, 控制: 第一个乘数
            for (int j = 1; j <= i ; j++) {     //正三角形, 判断条件发生变化.
                //1 * 3 = 3  2 * 3 = 6  3 * 3 = 9
                System.out.print( j +  "*" + i + "="+ i*j +"\t");
            }
            System.out.println();
        }
    }
}

运行结果为:

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*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

16. 生成随机数

16.1 概述

Math类似Scanner，也是Java提供好的API(Application Programming Interface)，内部提供了产生随机数的功能. API后续课程详细讲解，现在可以简单理解为Java已经写好的代码, 我们可以直接拿来用.

16.2 格式

Math.random();		//可以获取0.0 ~ 1.0之间所有的数据, 包左不包右.

//示例: 获取1-100之间的随机数
int num = (int)(Math.random()*100 + 1);

16.3 案例一: Math入门

需求
使用Math类，生成5个1~10之间的随机整数, 并将结果打印到控制台.
参考代码

public class MathDemo01 {
    public static void main(String[] args) {
        //需求: 使用Math类，生成5个1~10之间的随机整数, 并将结果打印到控制台.

        //1. Math.random()入门
        /*double d = Math.random();
        System.out.println(d);*/

        //2. 获取一个1到100之前的随机数, 包含1, 也包含100.
        /*int num = (int)(Math.random() * 100 + 1);
        System.out.println(num);*/

        //---------------------------------以上为铺垫知识---------------------------------
        //2. 因为要5个随机数, 所以用循环改进, 又因为循环次数已知, 用for循环.
        for (int i = 0; i < 5; i++) {
            //1. 获取1个1-10之间的随机数.
            int num = (int)(Math.random() * 10 + 1);
            System.out.println(num);
        }
    }
}

运行结果为:

9
7
7
8
6

16.4 案例二: 猜数字

需求

  1. 生成一个1-100之间的随机数, 让用户来猜.
  2. 如果猜的数字比生成的随机数大，提示你猜的数据大了
  3. 如果猜的数字比生成的随机数小，提示你猜的数据小了
  4. 如果猜的数字与生成的随机数相等，提示恭喜你猜中了

参考代码

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

public class MathDemo02 {
    public static void main(String[] args) {
        //1. 生成一个随机数让用户来猜.
        int guessNum = (int)(Math.random()*100 + 1);
        //2. 因为不知道用户多少次能猜对, 所以用while(true)死循环.
        int inputNum = 0;
        while (true) {
            //3. 提示用户录入猜的数据, 并接收.
            System.out.println("请录入您猜的数据(1-100): ");
            inputNum = new Scanner(System.in).nextInt();
            //4. 比较用户录入的数据 和 生成的随机数是否一致, 并提示.
            if (inputNum > guessNum)
                System.out.println("您猜的数字大了!");
            else if (inputNum < guessNum)
                System.out.println("您猜的数字小了");
            else {
                System.out.println("恭喜您, 猜对了, 请找班任领取奖品... 就业班晋级卡");
                break;
            }
        }
    }
}

作业

  1. 身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下：
    //儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2
    //女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2
    现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？
package com.luokk.day02;

public class Demo01 {
    public static void main(String[] args) {
        // 定义父母身高
        double height_fa = 177, height_mo = 165;
        // 定义儿女身高
        double son , daughter;
        // 求儿女身高
        son = (height_fa + height_mo) * 1.08 / 2;
        daughter = (height_fa * 0.923 + height_mo) /2;
        // 输出
        System.out.println("儿子的身高是:" + son);
        System.out.println("女儿的身高是:" + daughter);
    }
}
  1. 已知: 红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。
    绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。
    判断红茶妹妹和绿茶妹妹的钱是否一致, 并打印结果.
    /*
    提示:
    1. 定义红茶妹妹原来的钱为整数变量
    2. 定义绿茶妹妹原来的钱为整数变量
    3. 使用赋值运算符和算术运算符计算其现有的钱
    4. 使用比较运算符对数值做出比较
    */
package com.luokk.day02;

public class Demo02 {
    public static void main(String[] args) {
        int red_tea = 21, green_tea = 24;
        red_tea = 2 * red_tea + 3;
        green_tea = 2 * green_tea;
        if (red_tea == green_tea) {
            System.out.println("钱数一样");
        } else if (red_tea > green_tea) {
            System.out.println("红茶钱多");
        } else {
            System.out.println("绿茶钱多");
        }
    }
}
  1. 某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元(fish)，
    油炸花生米单点8元(peanut)，米饭单点3元(rice)。
    订单满30元8折优惠, 鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。
    那么这个小伙要点这三样东西，最少要花多少钱？
public class Demo03 {
    public static void main(String[] args) {
        double fish = 24, peanut = 8, rice = 3;
        // 使用优惠的价钱
        double youhui = 16 + 8 + 3;
        System.out.println("优惠的价格为:" + youhui);
        // 使用折扣的价钱
        double sale = (24 + 8 + 3) * 0.8;
        System.out.println("折扣的价格为:" + sale);
        double result;
        result = youhui < sale ? youhui : sale;
        System.out.println("最便宜的价格为:" + result);
    }
}
  1. 键盘录入一个int类型的数据,使用三元运算符判断这个数是奇数还是偶数, 并打印结果.
import java.util.Scanner;

/*
4. 键盘录入一个int类型的数据,使用三元运算符判断这个数是奇数还是偶数, 并打印结果.
 */
public class Demo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println(num % 2 ==0 ? "偶数" : "奇数");
    }
}
  1. 提示用户键盘录入学员张浩的3门课程(Java、SQL、Web)的成绩, 编写程序实现如下需求:
    1. 获取Java课程和SQL课程的分数之差, 并打印结果.
    2. 获取3门课程的平均分, 并打印.
import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // java成绩
        System.out.println("请输入你的java成绩:");
        double java_score = sc.nextDouble();
        System.out.println("java成绩是" + java_score);
        // SQL成绩
        System.out.println("请输入你的SQL成绩:");
        double sql_score = sc.nextDouble();
        System.out.println("SQL成绩是" + sql_score);
        // Web成绩
        System.out.println("请输入你的Web成绩:");
        double web_score = sc.nextDouble();
        System.out.println("Web成绩是" + web_score);

        // java和sql成绩差
        double cha = java_score - sql_score;
        System.out.println("java和sql成绩差是:" + cha);

        // 平均分
        double score_average = (java_score + sql_score + web_score) / 3;
        System.out.println("平均分为:" + score_average);



    }
}

  1. 分析以下需求，并用代码实现
    1.商场推出幸运抽奖活动，抽奖规则如下：
    (1)键盘录入四位数字(1000-9999的数字),作为顾客的会员卡号
    (2)该会员卡号(键盘录入的四位数字)各位数字之和大于20，则为幸运客户
    2.打印格式如下：
    请输入4位会员卡号：
    3569
    会员卡号3569各位之和为：23
    会员卡号3569是幸运客户

     请输入4位会员卡号：
 1234
 会员卡号3569各位之和：10
 会员卡号3569不是幸运客户

import java.util.Scanner;

public class Demo06 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入4位会员卡号：");
        int vipCardNum = sc.nextInt();
        int ge = vipCardNum / 1 % 10;
        int shi = vipCardNum / 10 % 10;
        int bai = vipCardNum / 100 % 10;
        int qian = vipCardNum / 1000 % 10;
        int sum = ge + shi + bai + qian;
        System.out.println("会员卡号" + vipCardNum + "各位之和:" + sum);
        String result = sum > 20 ? "是幸运客户" : "不是幸运客户";
        System.out.println("会员卡号" + vipCardNum + result);

    }
}

  1. 键盘录入小明左右手牌的点数, 并接收, 编写代码实现交换小明手中的牌, 并打印结果.
    /*
    //尽可能多的用多种思路实现.
    格式如下:
    请输入小明左手中的纸牌：
    10
    请输入小明右手中的纸牌：
    8

     	互换前小明手中的纸牌：
 	左手中的纸牌：10
 	右手中的纸牌：8

 	互换后小明手中的纸牌：
 	左手中的纸牌：8
 	右手中的纸牌：10

    */

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入小明左手中的纸牌：");
        int left = sc.nextInt();
        System.out.println("请输入小明右手中的纸牌：");
        int right = sc.nextInt();
        System.out.println("互换前小明手中的纸牌：");
        System.out.println("左手中的纸牌：" + left);
        System.out.println("右手中的纸牌：" + right);
        System.out.println(" ");
        int temp = left;
        left = right;
        right = temp;
        System.out.println("互换后小明手中的纸牌：");
        System.out.println("左手中的纸牌：" + left);
        System.out.println("右手中的纸牌：" + right);



    }
}
  1. 键盘录入一个数字, 判断它是否是水仙花数, 并打印结果.
    //尽可能多的用多种思路实现.
    //提示: 1. 水仙花数是一个3位数. 2. 它的各个位数的立方和等于它本身.
    //例如: 153就是一个水仙花数: 153 = 111 + 555 + 333 = 153;
import java.util.Scanner;

public class Demo08 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数:");
        int num = sc.nextInt();
        int ge, shi, bai;
        ge = num / 1 % 10;
        shi = num / 10 % 10;
        bai = num / 100 % 10;
        String flag = ge * ge * ge + shi * shi * shi + bai * bai * bai == num ? "是" : "不是";
        System.out.println(num + flag + "一个水仙花数");

    }
}
  1. 键盘录入学生考试成绩，判断学生等级:
    90-100 优秀
    80-90 好
    70-80 良
    60-70 及格
    60以下 不及格
    //尽可能多的用多种思路实现.
import java.util.Scanner;

public class Demo09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入该生成绩:");
        double score = sc.nextInt();
        if (score > 100 || score < 0) {
            System.out.println("成绩输入错误");
        } else if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("好");
        } else if (score >= 70) {
            System.out.println("良");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }

    }
}
  1. 某人想买车，没什么车决定于此人在银行有多少存款(键盘录入)。
    /*
    如果此人的存款超过500万，则买奥迪A8L；
    否则，如果此人的存款超过100万，则买奥迪A6L；
    否则，如果此人的存款超过50万，则买奥迪A4L；
    否则，如果此人的存款超过10万，则买大众速腾；
    否则此人买大众捷达。
    */
import java.util.Scanner;

public class Demo10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入存款:");
        double money = sc.nextDouble();
        if (money < 0){
            System.out.println("找个班上吧");
        } else if (money > 500){
            System.out.println("买奥迪A8L");
        } else if (money > 100) {
            System.out.println("买奥迪A6L");
        } else if (money > 50) {
            System.out.println("则买奥迪A4L");
        } else if (money > 10) {
            System.out.println("买大众速腾");
        } else {
            System.out.println("买大众捷达");
        }
    }
}
落空空。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
【方法知识点】
qq_64451048的博客
11-08 272
和方法相关的知识点
Java基础
潘潘她老公的博客
03-09 225
Java基础
java:方法
qq_63531507的博客
01-08 481
方法： 简单的理解：就是特定功能模块： 很多语言中都有方法的定义，有着不同的叫法，有的叫函数，但是在java中函数就是方法，方法就是函数。 定义方法的语句格式: 修饰符 返回值类型 方法名（参数类型 参数名,参数类型 参数名................）{ 函数体 return 返回值； } 名词解释： 修饰符：修饰符比较多，但是呢目前我们只需要记住一个组合 public static 返回值类型：参考我们一直使用的Scanner 定义return返回的数...
Java程序设计基础教程-期末试卷B卷.docx
12-16
本资源是 Java 程序设计基础教程的期末试卷 B 卷，涵盖了 Java 程序设计的基础知识点，包括变量、运算符、控制流程、方法、数组、类和对象、继承、多态、接口、异常处理等。 变量和数据类型 * 变量的声明和赋值 * ...
Java基础-经典入门教程
11-27
这个“Java基础-经典入门教程”旨在帮助初学者掌握Java编程的核心概念和技能，为深入学习和应用Java打下坚实的基础。 1. **Java简介**：Java以其“一次编写，到处运行”的特性而闻名，它使用JVM（Java虚拟机）作为...
Java零基础教程-适合Java初学者的教程
07-07
通过阅读“Java零基础教程-适合Java初学者的教程.txt”文件，你可以深入了解这些知识点，并结合实践进行学习，逐步成为Java开发的专家。记得理论与实践相结合，多写代码，多解决问题，这样才能更好地掌握Java编程。
计算机教程-编程基础PPT文档.pptx
11-14
本教程主要涵盖了编程的基础知识，包括程序设计语言、算法与流程图、程序设计方法以及JavaScript编程。以下是这些主题的详细阐述： 1. **程序设计语言**： - 程序是通过特定的计算机语言描述的解决问题的指令集合...
Elsaticsearch java基本操作
qq_62383709的博客
07-13 430
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 388
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 451
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2445
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1452
在 Java 中，可以通过多种方法将一个Object转换为Integer。
elk部署springboot
Chihirozy的博客
07-11 296
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3342
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
Java 线程池详解
最新发布
qq_41591215的博客
07-13 645
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 765
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 358
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。
uboot的功能
weixin_43732386的博客
07-13 19
uboot=裸机程序，uboot的核心功能是启动内核。
《Java程序设计项目化教程》.docx
12-16
《Java程序设计项目化教程》.docx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值