Home Explore Help
Sign In
lovecoding
/
J260713
8
0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Tree: 56d4091d4d
Branches Tags
J260713
/
课堂笔记
/
01-JavaSE基础-笔记
/
20260714-笔记.md

20260714-笔记.md 25 KB
History Raw

JavaSE 基础 — Day02 笔记

日期：2026-07-14
项目：c260714
作者：WanJL

一、流程控制（if-else）

1. 程序的结构

程序的结构分为三种：

结构 说明
顺序结构 代码从左到右、从上到下依次执行
分支结构 为代码设定条件，满足条件执行 A，不满足执行 B
循环结构 重复执行某段代码（后续课程讲解）

2. if-else 分支结构

核心思想：告诉程序在什么情况下做什么事。

如果下雨，要打伞；否则就不打伞。

语法格式：

if (布尔表达式) {
    // 条件为 true 时执行的代码
} else {
    // 条件为 false 时执行的代码
}

布尔表达式：运算结果为 boolean 类型值（true 或 false）的表达式。

示例：判断一个整数是正数还是负数

int a = 15;
if (a > 0) {
    System.out.println("正数");
} else {
    System.out.println("负数");
}

完整代码 —— Demo01.java

/**
 * @author WanJl
 * @version 1.0
 * @title Demo01
 * @description 流程控制
 * @create 2026/7/14
 */
public class Demo01 {
    public static void main(String[] args) {
        /*
            逻辑
            流程控制就是告诉程序，要在什么情况下做什么事 的逻辑
            如果 下雨 要打伞 否则就不打伞

            程序的结构分为三种：
                1、 顺序结构  代码从左到右从上到下依次执行
                2、 分支结构 为代码设定条件，如果满足条件，就执行A，不满足就执行B
                        如果 (是否下雨){
                            要打伞
                        }否则{
                            不打伞
                        }
                        if(下雨==true){       括号里的 必须是布尔表达式（布尔表达式就是运算的结果是布尔类型值 true 或 false）
                            要打伞
                        }else{
                            不打伞
                        }
                 比如判断： 15 是 正数 还是负数
         */
        System.out.println("前面有n多代码...............");
        int a = 15;   // 定义一个整数类型的变量
        if (a > 0) {   // 判断 变量值是否大于0   运行结果是boolean类型值
            System.out.println("正数");
        } else {
            System.out.println("负数");
        }
        System.out.println("后面有n多代码...............");
        /*
            1、判断年龄age 是否大于30岁
            2、判断年龄 age2 是否成年
            3、判断分数 score 是否优秀 大于90分
         */
    }
}

3. 随堂练习（if 分支）

  1. 判断年龄 age 是否大于 30 岁
  2. 判断年龄 age2 是否成年（≥ 18 岁）
  3. 判断分数 score 是否优秀（大于 90 分）

二、Java 运算符

1. 运算符的分类

按操作数的数量分类

类型 说明 示例
一元运算符 只有一个操作数参与运算 ++、--
二元运算符 有两个操作数参与运算 +、-、*、/
三元运算符 有三个操作数参与运算 ? :（后面课程讲解）

按功能分类

类别 说明
算术运算符 ✅ 本次课程重点
赋值运算符 ✅ 本次课程重点
比较运算符 ✅ 本次课程重点
逻辑运算符 ✅ 本次课程重点
位运算符 后续课程讲解
三目运算符 后续课程讲解

2. 算术运算符

运算符 名称 示例 结果
+ 加号 5 + 5 10
- 减号 5 - 3 2
* 乘号 5 * 3 15
/ 除号 5 / 3 1（不是 1.666...）
% 取余/取模 5 % 3 2（5 / 3 = 1 余 2）
++ 自增 ++i / i++ 一元运算符
-- 自减 --i / i-- 一元运算符

基本运算示例

int a = 10, b = 3;
System.out.println("10+3=" + (a + b));   // 13
System.out.println("10-3=" + (a - b));   // 7
System.out.println("10*3=" + (a * b));   // 30
System.out.println("10/3=" + (a / b));   // 3
System.out.println("10%3=" + (a % b));   // 1

常见问题

① 整数除法截断

两个整数相除，结果为整数，会直接截断小数部分，只保留整数。

System.out.println(10 / 3);     // 3（截断小数）
System.out.println(10 / 3.0);   // 3.3333333333333335（有小数参与，结果为小数）
System.out.println(10.0 / 3);   // 3.3333333333333335
② 0 不能做除数

整数除法中，除数为 0 会抛出异常：

// System.out.println(3 / 0);    // ArithmeticException（算术异常，程序停止）

但浮点数除法中，除数为 0 有特殊结果：

System.out.println(3 / 0.0);     // Infinity（无穷大）
System.out.println(3 / -0.0);    // -Infinity（负无穷大）
System.out.println(0.0 / 0.0);   // NaN（Not a Number，非数字）
③ 取模运算 %
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1（结果的符号与被除数相同）

取模规则：a % b 的结果符号与 a（被除数）的符号一致。

④ 自增 ++ 与自减 --
  • ++ 表示这个数增加 1，-- 表示这个数减少 1
  • 符号在前（++i）：先进行自增运算，再进行其他操作（如赋值）

  • 符号在后（i++）：先进行其他操作，再进行自增运算

    int i = 10;
int j = ++i;   // i 先自增变为 11，再将 11 赋值给 j
int k = i++;   // 先将 i（当前 11）赋值给 k，i 再自增变为 12

System.out.println(j);   // 11
System.out.println(k);   // 11
System.out.println(i);   // 12

3. 赋值运算符

运算符 名称 含义 等价于
= 赋值 把右边的值赋给左边 —
+= 加后赋值 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

示例

int x = 10;
x += 5;            // x = x + 5 → 15
System.out.println(x);

x *= 3;            // x = x * 3 → 45
System.out.println(x);

复合运算符隐含强制类型转换

byte a = 15;
// a = a + 6;      // ❌ 编译错误：a + 6 结果被提升为 int，赋值给 byte 需强制转换
a += 6;             // ✅ 复合赋值运算符隐含强制类型转换

重要：复合赋值运算符（+=、-= 等）内部隐含了强制类型转换，不需要手动强转。

完整代码 —— Demo03.java

/**
 * @author WanJl
 * @version 1.0
 * @title Demo03
 * @description 赋值运算符
 * @create 2026/7/14
 */
public class Demo03 {
    public static void main(String[] args) {
        /*
            赋值运算符
            把=右边的值赋值给等号左边，比如 a=10
                =       赋值          a=b         把b的值赋值给a
                +=      加后赋值       a=a+b       把a+b的结果赋值给a
                -=      减后赋值       a=a-b       把a-b的结果赋值给a
                *=      乘后赋值       a=a*b       把a*b的结果赋值给a
                /=      除后赋值       a=a/b       把a/b的结果赋值给a
                %=      取余后赋值     a=a%b       把a%b的结果赋值给a
         */
        int x = 10;
        x += 5;
        System.out.println(x);   // 15
        x *= 3;
        System.out.println(x);   // 45  (x = x * 3)

        // 复合运算符隐含强制类型转换
        byte a = 15;
        // a = a + 6;  // 因为a+6的结果被提升为int类型，再赋值给byte类型的a需要强制类型转换
        a += 6;   // 复合赋值运算符 隐含就帮我们做了强制类型转换。
    }
}

4. 比较运算符

运算符 名称 示例 结果
> 大于 5 > 3 true
< 小于 5 < 3 false
== 等于 5 == 3 false
>= 大于等于 5 >= 3 true
<= 小于等于 5 <= 3 false
!= 不等于 5 != 3 true

注意：比较运算符的结果都是 boolean 类型（true 或 false）。 判断相等使用 ==（双等号），不能写成 =（单等号是赋值）。

浮点数精度陷阱

使用 == 比较浮点数时要特别小心，因为浮点数存在精度误差：

double b1 = 0.1 + 0.2;
double b2 = 0.3;
System.out.println(b1 == b2);   // false！浮点数精度误差
System.out.println(b1);         // 0.30000000000000004
System.out.println(b2);         // 0.3

0.1 + 0.2 在计算机中无法精确表示为 0.3，而是近似值 0.30000000000000004，因此 == 比较返回 false。

解决方案：使用 printf 格式化输出，或设置误差范围进行比较。

System.out.printf("%.1f", b1);   // 输出 0.3（保留1位小数）

完整代码 —— Demo04.java

/**
 * @author WanJl
 * @version 1.0
 * @title Demo04
 * @description 比较运算符
 * @create 2026/7/14
 */
public class Demo04 {
    public static void main(String[] args) {
        /*
           >        大于          5>3     true
           <        小于          5<3     false
           ==       等于          5==3    false
           >=       大于等于       5>=3    true
           <=       小于等于       5<=3    false
           !=       不等于         5!=3    true
         */

        // 比较运算符 陷阱（精度陷阱）
        double b1 = 0.1 + 0.2;
        double b2 = 0.3;
        System.out.println(b1 == b2);     // false 浮点数精度误差
        System.out.println(b1);           // 0.30000000000000004
        System.out.println(b2);           // 0.3

        // 输出保留1位小数
        System.out.printf("%.1f", b1);    // 0.3
    }
}

5. 逻辑运算符

逻辑运算符操作的对象要么是布尔表达式，要么是布尔值。

运算符 名称 示例 结果 说明
& 与 true & false false 两边都为 true 结果才为 true
\| 或 true \| false true 两边都为 false 结果才为 false
! 非 !true false 取反（单目运算符）
&& 短路与 true && false false 左边为 false 时右边不执行
\|\| 短路或 true \|\| false true 左边为 true 时右边不执行
^ 异或 true ^ false true 两边相同返回 false，不同返回 true

① & 与（AND）

符号左右两侧的布尔表达式结果如果都是 true，则运算结果为 true，否则为 false。

System.out.println(true & true);    // true
System.out.println(true & false);   // false
System.out.println(false & true);   // false
System.out.println(false & false);  // false

② | 或（OR）

符号左右两侧的布尔表达式结果如果都是 false，则运算结果为 false，否则为 true。

System.out.println(true | true);    // true
System.out.println(true | false);   // true
System.out.println(false | true);   // true
System.out.println(false | false);  // false

③ ! 非（NOT）

取反，单目运算符。符号右侧的布尔表达式结果为 true 时运算后为 false，反之亦然。

System.out.println(!true);    // false
System.out.println(!false);   // true

④ && 短路与（Short-circuit AND）

作用与 & 相同，但具有短路特性：如果符号左边为 false，右边不再运算，直接返回 false。

System.out.println(true && true);    // true
System.out.println(true && false);   // false
System.out.println(false && true);   // false（右边不执行）
System.out.println(false && false);  // false（右边不执行）

⑤ || 短路或（Short-circuit OR）

作用与 | 相同，但具有短路特性：如果符号左边为 true，右边不再运算，直接返回 true。

System.out.println(true || true);    // true（右边不执行）
System.out.println(true || false);   // true（右边不执行）
System.out.println(false || true);   // true
System.out.println(false || false);  // false

⑥ ^ 异或（XOR）

符号左右两侧的布尔表达式如果相同，返回 false；不同返回 true。

System.out.println(true ^ true);    // false
System.out.println(true ^ false);   // true
System.out.println(false ^ true);   // true
System.out.println(false ^ false);  // false

完整代码 —— Demo05.java

/**
 * @author WanJl
 * @version 1.0
 * @title Demo05
 * @description 逻辑运算符
 * @create 2026/7/14
 */
public class Demo05 {
    public static void main(String[] args) {
        /*
        逻辑运算符 操作的数 要么是布尔表达式  要么是布尔值。
            &       与           true&false      false
            |       或           true|false      true
            !       非           !true           false
            &&      短路与        true&&false     false
            ||      短路或        true||false     true
            ^       异或          true^false      true
         */
        // & 与：符号左右两侧的布尔表达式结果如果都是true，则运算结果为true，否则就是false
        System.out.println(true & true);   // true
        System.out.println(true & false);  // false
        System.out.println(false & true);  // false
        System.out.println(false & false); // false

        // | 或：符号左右两侧的布尔表达式结果如果都是false，则运算结果为false，否则就是true
        System.out.println(true | true);   // true
        System.out.println(true | false);  // true
        System.out.println(false | true);  // true
        System.out.println(false | false); // false

        // && 短路与，作用和&相同，只不过，符号左边如果是false，右边就不运算了，直接返回false
        System.out.println(true && true);   // true
        System.out.println(true && false);  // false
        System.out.println(false && true);  // false
        System.out.println(false && false); // false

        // || 短路或，作用和|相同，只不过，符号左边如果是true，右边就不运算了，直接返回true
        System.out.println(true || true);   // true
        System.out.println(true || false);  // true
        System.out.println(false || true);  // true
        System.out.println(false || false); // false

        // ! 非 也就是取反，它也是单目运算符，符号右侧的布尔表达式的结果如果是true，运算后就是false
        System.out.println(!true);   // false
        System.out.println(!false);  // true

        // ^ 异或 符号左右两侧的布尔表达式如果相同，就返回false，不同返回true
        System.out.println(true ^ true);    // false
        System.out.println(true ^ false);   // true
        System.out.println(false ^ true);   // true
        System.out.println(false ^ false);  // false
    }
}

结合 if-else 分支结构与算术运算符，完成以下练习：

练习 1：判断奇偶数

int i1 = 7;
if (i1 % 2 == 0) {
    System.out.println("偶数");
} else {
    System.out.println("奇数");
}

思路：奇数不能被 2 整除（% 2 == 1），偶数能被 2 整除（% 2 == 0）。

练习 2：判断倍数关系

int a1 = 10, b1 = 5;
if (a1 % b1 == 0) {
    System.out.println("是倍数");
} else {
    System.out.println("不是倍数");
}

思路：a1 % b1 == 0 说明 a1 能被 b1 整除，即 a1 是 b1 的倍数。

练习 3：判断正数、负数还是 0

int i2 = 10;
if (i2 > 0) {
    System.out.println("正数");
} else if (i2 < 0) {
    System.out.println("负数");
} else {
    System.out.println("0");
}

思路：使用 if - else if - else 进行多分支判断。

练习 4：分钟数转换

将总分钟数（如 130 分钟）转换为几小时几分钟，并判断是否超过 1 小时。

int time = 130;
int h = time / 60;     // 整除获取小时数
int m = time % 60;     // 取余获取剩余分钟数
System.out.println(h + "小时" + m + "分钟");
if (h > 1) {
    System.out.println("超过1小时");
} else {
    System.out.println("不超过1小时");
}

思路：小时 = 总分钟 / 60（整除），剩余分钟 = 总分钟 % 60（取余）。

四、完整代码汇总

Demo01.java — 流程控制

/**
 * @author WanJl
 * @version 1.0
 * @title Demo01
 * @description 流程控制
 * @create 2026/7/14
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("前面有n多代码...............");
        int a = 15;
        if (a > 0) {
            System.out.println("正数");
        } else {
            System.out.println("负数");
        }
        System.out.println("后面有n多代码...............");
    }
}

Demo02.java — 算术运算符 + 综合练习

/**
 * @author WanJl
 * @version 1.0
 * @title Demo02
 * @description Java运算符
 * @create 2026/7/14
 */
public class Demo02 {
    public static void main(String[] args) {
        // 1. 算术运算符
        int a = 10, b = 3;
        System.out.println("10+3=" + (a + b));
        System.out.println("10-3=" + (a - b));
        System.out.println("10*3=" + (a * b));
        System.out.println("10/3=" + (a / b));
        System.out.println("10%3=" + (a % b));

        // 整数除法截断
        System.out.println(10 / 3);     // 3
        System.out.println(10 / 3.0);   // 3.3333...

        // 0 不能做除数
        System.out.println(3 / 0.0);    // Infinity
        System.out.println(3 / -0.0);   // -Infinity
        System.out.println(0.0 / 0.0);  // NaN

        // 取模运算
        System.out.println(10 % 3);     // 1
        System.out.println(-10 % 3);    // -1

        // 自增自减
        int i = 10;
        int j = ++i;   // 11
        int k = i++;   // 11（赋值后再自增）
        System.out.println(j);
        System.out.println(k);
        System.out.println(i);   // 12

        // 练习1：判断奇偶数
        int i1 = 7;
        if (i1 % 2 == 0) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }

        // 练习2：判断倍数
        int a1 = 10, b1 = 5;
        if (a1 % b1 == 0) {
            System.out.println("是倍数");
        } else {
            System.out.println("不是倍数");
        }

        // 练习3：判断正数/负数/0
        int i2 = 10;
        if (i2 > 0) {
            System.out.println("正数");
        } else if (i2 < 0) {
            System.out.println("负数");
        } else {
            System.out.println("0");
        }

        // 练习4：分钟转换
        int time = 130;
        int h = time / 60;
        int m = time % 60;
        System.out.println(h + "小时" + m + "分钟");
        if (h > 1) {
            System.out.println("超过1小时");
        } else {
            System.out.println("不超过1小时");
        }
    }
}

Demo03.java — 赋值运算符

/**
 * @author WanJl
 * @version 1.0
 * @title Demo03
 * @description 赋值运算符
 * @create 2026/7/14
 */
public class Demo03 {
    public static void main(String[] args) {
        int x = 10;
        x += 5;
        System.out.println(x);   // 15
        x *= 3;
        System.out.println(x);   // 45

        // 复合运算符隐含强制类型转换
        byte a = 15;
        a += 6;   // 隐含强制类型转换
    }
}

Demo04.java — 比较运算符 + 浮点数精度陷阱

/**
 * @author WanJl
 * @version 1.0
 * @title Demo04
 * @description 比较运算符
 * @create 2026/7/14
 */
public class Demo04 {
    public static void main(String[] args) {
        /*
           >        大于          5>3     true
           <        小于          5<3     false
           ==       等于          5==3    false
           >=       大于等于       5>=3    true
           <=       小于等于       5<=3    false
           !=       不等于         5!=3    true
         */

        // 比较运算符 陷阱（精度陷阱）
        double b1 = 0.1 + 0.2;
        double b2 = 0.3;
        System.out.println(b1 == b2);     // false 浮点数精度误差
        System.out.println(b1);           // 0.30000000000000004
        System.out.println(b2);           // 0.3

        // 输出保留1位小数
        System.out.printf("%.1f", b1);    // 0.3
    }
}

Demo05.java — 逻辑运算符

/**
 * @author WanJl
 * @version 1.0
 * @title Demo05
 * @description 逻辑运算符
 * @create 2026/7/14
 */
public class Demo05 {
    public static void main(String[] args) {
        /*
        逻辑运算符 操作的数 要么是布尔表达式  要么是布尔值。
            &       与           true&false      false
            |       或           true|false      true
            !       非           !true           false
            &&      短路与        true&&false     false
            ||      短路或        true||false     true
            ^       异或          true^false      true
         */
        // & 与
        System.out.println(true & true);   // true
        System.out.println(true & false);  // false
        System.out.println(false & true);  // false
        System.out.println(false & false); // false

        // | 或
        System.out.println(true | true);   // true
        System.out.println(true | false);  // true
        System.out.println(false | true);  // true
        System.out.println(false | false); // false

        // && 短路与（左边为false时右边不执行）
        System.out.println(true && true);   // true
        System.out.println(true && false);  // false
        System.out.println(false && true);  // false
        System.out.println(false && false); // false

        // || 短路或（左边为true时右边不执行）
        System.out.println(true || true);   // true
        System.out.println(true || false);  // true
        System.out.println(false || true);  // true
        System.out.println(false || false); // false

        // ! 非（取反）
        System.out.println(!true);   // false
        System.out.println(!false);  // true

        // ^ 异或（相同为false，不同为true）
        System.out.println(true ^ true);    // false
        System.out.println(true ^ false);   // true
        System.out.println(false ^ true);   // true
        System.out.println(false ^ false);  // false
    }
}

五、随堂练习要点

  1. if-else 分支结构：if (布尔表达式) { ... } else { ... }
  2. 算术运算符：+、-、*、/、%、++、--
  3. 整数除法截断：两个整数相除结果直接截断小数，不会四舍五入
  4. 0 不能做除数：整数除 0 会抛异常，浮点数除 0 得 Infinity / NaN
  5. 取模运算：% 获取余数，结果符号与被除数相同
  6. 自增 ++ / 自减 --：符号在前先运算，符号在后先赋值
  7. 赋值运算符：=、+=、-=、*=、/=、%=
  8. 复合赋值运算符隐含强制类型转换
  9. 比较运算符：>、<、==、>=、<=、!=，结果都是 boolean 类型
  10. 条件判断中比较相等使用 ==，不要写成 =
  11. 浮点数精度陷阱：0.1 + 0.2 == 0.3 为 false，浮点数不能直接用 == 比较
  12. 解决方案：使用 printf 格式化输出，或设置误差范围
  13. 掌握 if - else if - else 多分支结构
  14. 学会利用 % 取模运算判断奇偶、倍数关系
  15. 学会利用 / 整除和 % 取余进行单位换算（分钟 → 小时 + 分钟）
  16. 逻辑运算符：&（与）、|（或）、!（非）、&&（短路与）、||（短路或）、^（异或）
  17. & vs &&：& 两边都要计算，&& 左边为 false 时右边不执行（短路）
  18. | vs ||：| 两边都要计算，|| 左边为 true 时右边不执行（短路）
  19. ^ 异或：两边相同为 false，不同为 true
  20. ! 非：单目运算符，取反操作

六、拓展阅读

概念 说明
布尔表达式 运算结果为 true 或 false 的表达式
算术异常 ArithmeticException，整数除以 0 时抛出
Infinity 浮点数除 0 的结果，表示无穷大
NaN Not a Number，0.0 / 0.0 的结果
复合赋值运算符 如 +=、-= 等，自带隐式强制类型转换
短路特性 && 左边为 false 或 `
浮点数精度 浮点数在计算机中采用 IEEE 754 标准存储，存在精度误差，避免直接用 == 比较