• 【Java 语言】Java 和基于 Java 的编程基础 d.运算符

    运算符

    一、运算符（Operator）的分类

    ⭐️ 算术运算符
    ⭐️ 赋值运算符
    ⭐️ 关系运算符
    ⭐️ 逻辑运算符
    ⭐️ 位运算符
    ⭐️ 三元运算符

    二、算术运算符

    ⭐️ 对数值类型的变量进行运算操作的符号
    在这里插入图片描述

    public class Test {
    public static void main(String[] args) {
        int num1 = 8;
        int num2 = 2;
        int num3 = 1;

        // +、-、*、/、%、++、--
        System.out.println("加：" + (num1 + num2)); // 加：10
        System.out.println("减：" + (num1 - num2)); // 减：6
        System.out.println("乘：" + (num1 * num2)); // 乘：16
        System.out.println("除：" + (num1 / num2)); // 除：4
        System.out.println("取余：" + (num1 % num2)); // 取余：0

        System.out.println("后加加：" + num3++); // 后加加：1
        System.out.println("后减减：" + num3--); // 后减减：2

        System.out.println("前加加：" + ++num3); // 前加加：2
        System.out.println("前减减：" + --num3); // 前减减：1
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    ++：自增运算符
    --：自减运算符

    	int num = 1; 
	
	// 使用完 num 的值后, 把 num 的值增加1
	// 所以, 下面的一行代码执行完毕后, num 的值为 2
	System.out.println("后加加：" + num++); // 后加加：1

	// 先使用 num 的值后, 把 num 的值减少1
	// 由于上面的代码把 num 的值增加了1, 所以此时 num 的值为2
	// 执行完下面的一行代码后, num 的值减少1
	// 执行完下面的一行代码后, num 的值为1
	System.out.println("后减减：" + num--); // 后减减：2
	
	// 先把当前 num 的值增加1, 再打印 num 的值
	// 由于上面一行代码把 num 的值修改为了 1
	// 下面的一行代码会先把 num 的值加1, 然后打印
	// 所以, 打印的值为 2
	System.out.println("前加加：" + ++num); // 前加加：2

	// 下面的一行代码会把当前的 num 值先减少1, 然后打印
	System.out.println("前减减：" + --num); // 前减减：1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    我初学编程的时候，总是弄晕自增运算符和自减运算符。最好的解决方法是记住：自增运算符放前面就先运算，放后面就后运算，然后自己动手尝试一下。

    public class Test {
    public static void main(String[] args) {
        int iniNum = 6;
        // 先把 iniNum 当前的值赋值给 num, 然后 iniNum 再自增1
        int num = iniNum++;
		
		// 进过上面的一行代码, iniNum 的值变成了7
		// 先把当前 iniNum 的值赋值给 iniNum, 然后 iniNum 再自增1
        iniNum = iniNum++;

        System.out.println(num); // 6
        System.out.println(iniNum); // 7
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    public class Test {
    public static void main(String[] args) {
        int i = 0;
        // 先把 i 当前的值赋值给 i, 然后 i 再自增1
        i = i++;
        System.out.println(i); // 0
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    public class Test {
    public static void main(String[] args) {
        int i = 1;
        // 先把当前 i 的值增加 1, 然后才赋值给 i
        i = ++i;
        System.out.println(i); // 2
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    public class Test {
    public static void main(String[] args) {
        int i = 0;
        // 先把当前 i 的值赋值给i, 然后把 i 的值增加 1
        i = i++;
        System.out.println(i); // 0
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    public class Test {
    public static void main(String[] args) {
        int num1 = 1;
        int num2 = 0;
        // 先把 num1 的值赋值给 num 后, num1 的值增加 1
        int num = num1++;

        System.out.println(num); // 1
        System.out.println(num2); // 0
        System.out.println(num1); // 2

        // 先把 num2 的值减少1, 然后赋值给 num
        num = --num2;
        System.out.println(num); // -1
        System.out.println(num2); // -1
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    %：取余运算符（计算一个数除以另一个数后的余数）

    ❓：假如还有 59 天放假，则还有多少星期零多少天放假？

    public class Test {
    public static void main(String[] args) {
        int totalDay = 59;
        int seven = 7;

        int week = totalDay / seven;
        int days = totalDay % seven;

        // 还有8个星期, 零3天放假。
        System.out.println("还有" + week + "个星期, 零" + days + "天放假。");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    三、关系运算符（比较运算符）

    ⭐️ 关系运算符的结果都是 boolean 类型（要么是 true，要么是 false）
    ⭐️ 关系表达式经常用在 if 结构的条件中或循环结构的条件中
    在这里插入图片描述
    instanceof 也非常常用，后期再详细说

    public class Test {

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;

        System.out.println("num1 == num2 " + (num1 == num2));
        System.out.println("num1 != num2 " + (num1 != num2));
        System.out.println("num1 <  num2 " + (num1 < num2));
        System.out.println("num1 >  num2 " + (num1 > num2));
        System.out.println("num1 <= num2 " + (num1 <= num2));
        System.out.println("num1 >= num2 " + (num1 >= num2));
        
        /*
            num1 == num2 false
            num1 != num2 true
            num1 <  num2 true
            num1 >  num2 false
            num1 <= num2 true
            num1 >= num2 false
         */
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    ⭐️ 关系运算符的结果都是 boolean 型（要么是 true，要么是 false）
    ⭐️ 关系运算符组成的表达式被称为关系表达式
    ⭐️ 比较运算符【==】不能误写成【=】

    四、逻辑运算符

    ⭐️ 用于连接多个条件（多个关系表达式）
    ⭐️ 最终的结果也是一个 boolean 值

    && 短路与：两个为 true，才是 true
    || 短路或：一个为 true，就是 true
    ! 取反
    & 逻辑与
    | 逻辑或
    ^ 逻辑异或：不同为 true，相同 false

    a && b：a 和 b 同时为 true，结果才为 true，否则是 false
    a & b：a 和 b 同时为 true，结果才为 true，否则是 false
    区别：
    🌿【&&】若前一个表达式（a）为 false 的时候，直接返回 false；不会判断后面的表达式（b）
    🌿【&】即使前一个表达式（a）为 false，也会判断后面的表达式（b）

    public class Test {
    public static void main(String[] args) {
        int age = 5;

        if (age >= 3 && age <= 7) { // 年龄大于等于3岁, 并且小于等于7岁则是 true
            System.out.println("可以报考银河幼儿园");
        }

        if (age >= 3 & age <= 7) { // 年龄大于等于3岁, 并且小于等于7岁则是 true
            System.out.println("可以报考银河幼儿园");
        } 
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    上面的两段代码中使用到了 if-else 语句（后期还会详细说明）
    if-else 语句的结构如下所示：

      if (expression) {
      // 如果 expression(表达式)的 boolean 值为 true
  } else {
      // 否则, 如果 expression(表达式)的 boolean 值为 false
  }

    • 1
    • 2
    • 3
    • 4
    • 5

    && 和 & 的区别：

    public class Test {
    public static void main(String[] args) {
        int num = 5;
        if (num > 6 && num++ > 7) { // if: false
            System.out.println(num); // 不打印
        } else {
            System.out.println(num); // 5 (结果为 5, 说明 && 右边的表达式没有执行)
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    public class Test {
    public static void main(String[] args) {
        int num = 5;
        if (num > 6 & num++ > 7) { // if: false
            System.out.println(num); // 不打印
        } else {
            System.out.println(num); // 6 (结果为 6, 说明 && 右边的表达式执行了)
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    a || b：a 和 b中 有一个为 true，则结果是 true，否则是false
    a | b：a 和 b中 有一个为 true，则结果是 true，否则是false
    区别：
    🌿【||】若前一个表达式（a）为 true 的时候，直接返回 true；不会判断后面的表达式（b）
    🌿【|】即使前一个表达式（a）为 true，也会判断后面的表达式（b）

    ! a：取反运算符（a 为 ture，则结果为 false；a 为 false，则结果为 true）
    a ^ b：当 a 和 b 的值不同时，结果为 true，否则为 false

    短路或测试代码

    public class Test {
    public static void main(String[] args) {
        int num = 5;
        /*
            num 真实值是 5, 所以【num > 3】为 true
            短路或【||】的特色是：若【||】左边的表达式为 true,
            【||】右边的表达式不会进行运算
         */
        if (num > 3 || num-- > 7) { // if: true
            System.out.println("if: " + num); // if: 5
        } else {
            System.out.println("else: " + num); // 不打印
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    逻辑或测试代码

    public class Test {
    public static void main(String[] args) {
        int num = 5;
        /*
            num 真实值是 5, 所以【num > 3】为 true
            短路或【|】的特色是：即使【|】左边的表达式为 true,
            【|】右边的表达式也会进行运算（把 num 的值减少1）
         */
        if (num > 3  | num-- > 7) { // if: true
            System.out.println("if: " + num); // if: 4
        } else {
            System.out.println("else: " + num); // 不打印
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    取反运算符测试代码

    public class Test {
    public static void main(String[] args) {
        boolean isBoy = true; // 是男孩
        boolean isGirl = false; // 不是女孩 (是男孩)

        // !isBoy = false // 不是男孩 (是女孩)
        System.out.println("!isBoy = " + !isBoy);
        // !isGirl = true // 是女孩
        System.out.println("!isGirl = " + !isGirl);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    取反运算符：原来是 true 的，取反后便是 false；原来是 false 的，取反后便是 true

    原来是【女孩👧】的取反后就是【男孩👦】；原来是【男孩👦】的取反后就是【女孩👧】

    异或运算符测试代码
    🏡异或符号左右两侧的表达式都是 true 或都是 false 的时候，值是 false

    public class Test {
    public static void main(String[] args) {
        int n1 = 66;
        int n2 = 55;
        boolean b1 = n1 > 38; // true
        boolean b2 = n2 > 1; // true
        // b1 ^ b2 = false // 左右两侧都是 true
        System.out.println("b1 ^ b2 = " + (b1 ^ b2)); 
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    public class Test {
    public static void main(String[] args) {
        int n1 = 66;
        int n2 = 55;
        boolean b1 = !(n1 > 38); // 【!true】false
        boolean b2 = !(n2 > 1); // 【!true】false

        // b1 ^ b2 = false // 左右两侧都是 false
        System.out.println("b1 ^ b2 = " + (b1 ^ b2));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    🏡异或符号左右两侧的表达式的值不一致的时候，值是 true

    public class Test {
    public static void main(String[] args) {
        int n1 = 66;
        int n2 = 55;
        boolean b1 = n1 > 38; // true
        boolean b2 = n2 == 666; // false

        // b1 ^ b2 = true 
        // 左边是 true, 右边是 false (左右两侧的表达式的值不一致)
        System.out.println("b1 ^ b2 = " + (b1 ^ b2));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    public class Test {
    public static void main(String[] args) {
        int n1 = 66;
        int n2 = 55;
        boolean b1 = n1 > 666; // false
        boolean b2 = n2 + 1 == 56; // true

        // b1 ^ b2 = true
        // 左边是 false, 右边是 true (左右两侧的表达式的值不一致)
        System.out.println("b1 ^ b2 = " + (b1 ^ b2));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    思考下面的例子的输出结果是啥？
    1️⃣

    public class Test {
    public static void main(String[] args) {
        int n1 = 5;
        int n2 = 5;
        if (n1++ == 6 & ++n2 == 6) {
            n1 = 11;
        }
        System.out.println("n1 = " + n1);
        System.out.println("n2 = " + n2);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    上面的例子中涉及如下知识点：
    ① 【=】是赋值运算符
    ② 【==】是判断两个操作数的地址值是否一样（目前可暂时理解为判断两个操作数的值是否一样）
    ③ 【&】逻辑与：即使左边的表达式为 false，右边的表达式也会进行运算
    ④ 【自增运算符】若放操作数前面，先运算；若放操作数后面，后运算

    public class Test {
    public static void main(String[] args) {
        int n1 = 5;
        int n2 = 5;
        /*
            (1) n1++ == 6: 后置自增运算符 --- 后运算, 所以 n1++ 的值还是 5
                所以 【n1++ == 6】的值是 false, 同时 n1 的值被修改为了 6
            (2) & 的特色：即使左边的表达式的值是 false, 后面的表达式也会执行运算
                ++n2 是前置增长运算符 --- 先运算, 所以 ++n2 的值是 6
                所以目前 n2 的值是6 
         */
        if (n1++ == 6 & ++n2 == 6) {
            n1 = 11;
        }
        System.out.println("n1 = " + n1); // n1 = 6
        System.out.println("n2 = " + n2); // n2 = 6
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    思考：如果把运算符修改为 &&、| 、|| 结果是啥？

    2️⃣

    public class Test {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        short s = 46;

        if ((s++ == 46) && (b2 = true)) s++;
        if ((b1 = false) || (++s == 46)) s++;

        System.out.println("s = " + s);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    上面代码中涉及到的知识点有：
    ① 自增运算符
    ② 短路与和短路或
    ③ 赋值操作的返回值是 true

    赋值操作的返回值？

    public class Test {
    public static void main(String[] args) {
        boolean b;

        // b1 = true
        System.out.println("b = " + (b = true));
        // b1 = false
        System.out.println("b = " + (b = false));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    注释解析：

    public class Test {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        short s = 46;

        /*
            【s++】后置自增, 所以【s++】的值是 46 --- 【s++ == 46】为true
            【s++ == 46】执行完毕后, s 的值变为了 47
            【b2 = true】赋值成功后, 值是 true
         */
        if ((s++ == 46) && (b2 = true)) s++; // s++ 后值变为：48

        /*
            【b1 = false】赋值成功后, 值是 false
            【++s == 49】需要执行, 【++s == 49】执行完毕后, s 的值是 49
         */
        if ((b1 = false) || (++s == 49)) s++; // s++ 后值变为 50

        System.out.println("s = " + s); // s = 50
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    五、赋值运算符

    赋值运算符【=】：将某个运算后的值，赋给指定的变量

    复合赋值运算符

    public class Test {
    public static void main(String[] args) {
        int a = 9;
        int b = 3;

        // 【+=】
        a += b; // a = a + b
        System.out.println("a = " + a); // a = 12

        // 【-=】
        a -= b; // a = a - b
        System.out.println("a = " + a); // a = 9

        // 【*=】
        a *= b; // a = a * b
        System.out.println("a = " + a); // a = 27

        // 【/=】
        a /= b; // a = a / b
        System.out.println("a = " + a); // a = 9

        // 【%=】
        a %= b; // a = a % b;
        System.out.println("a = " + a); // a = 0
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    六、三目运算符

    三目运算符的格式： 【条件表达式 ? 表达式1 : 表达式2】
    含义：判断条件表达式的值是多少？如果是 true，执行表达式1；如果是 false，执行表达式2

    public class Test {
    public static void main(String[] args) {
        int num = 66;
        String string1 = num > 88 ? "num 大于88" : "num 小于88";
        String string2 = num > 3 ? "num 大于3" : "num 小于3";

        System.out.println("string1 = " + string1); // string1 = num 小于88
        System.out.println("string2 = " + string2); // string2 = num 大于3
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    三目运算符（三元运算符）可以转换为 if-else 语句

    See you!

  • 相关阅读:
    mysql join语句优化实战
    LeetCode算法心得——美丽塔 I（HashMap）
    cocoscreator播放Spine动画
    DDD领域驱动设计基础
    软考复习 -- 计算机网络
    navicat关闭启动时自动检查更新
    访问网站提示：您未被授权查看该页恢复办法
    【AI视野·今日CV 计算机视觉论文速览 第249期】Tue, 19 Sep 202
    Docker基础学习
    偷偷告诉你，十大有效的推广引流渠道有哪些？
  • 原文地址：https://blog.csdn.net/m0_54189068/article/details/126488372