[Java知识库]19-Java基础：运算符篇

运算符

• 是对字面量或者变量进行操作的符号

一、基本的算术运算符

package com.app.operator;

public class OperatorDemo1 {
    public static void main(String[] args) {
        // 目标：掌握基本的算术运算符：+ - * / %
        // 先定义两个变量a、b，用做基本的算术运算
        int a = 10;
        int b = 4;
        // 1.+：两个变量、数据做加法运算
        int addUp = a + b;
        System.out.print("a + b = ");
        System.out.println(addUp);      // 14

        // 2.-：两个变量、数据做减法运算
        int subtract = a - b;
        System.out.print("a - b = ");
        System.out.println(subtract);   // 6

        // 3.*：两个变量、数据做乘法运算
        int multiply = a * b;
        System.out.print("a * b = ");
        System.out.println(multiply);   // 40

        // 4./：两个变量、数据做除法运算
        /*
            注意： 10 除以 4，按照数学角度是 = 2.5
            但由于 a / b 是表达式，Java表达式中，最终运算结果是由表达式中的最高类型决定
            a是int，b是int，所以结果为int类型，所以 2.5转为整数 = 2
         */
        int divide = a / b;
        // 如果你非要准确的结果，小技巧: 先乘以 1.0（注意：不要放后面乘，乘除属于同级运算，会从左往右乘）
        double divide2 = a * 1.0 / b;
        // 把 1.0 放后面乘
        double divide3 = a / b * 1.0;
        System.out.print("int类型：   a / b = ");
        System.out.println(divide);     // 2
        System.out.print("double类型：a * 1.0 / b = ");
        System.out.println(divide2);    // 2.5
        System.out.print("double类型：a / b * 1.0 = ");
        System.out.println(divide3);    // 2.0

        // 5.%：两个变量、数据做除法的余数
        int remainder = a % b;  // 10 / 4 = 8 余 2
        System.out.print("a % b = ");
        System.out.println(remainder);  // 2
    }
}

输出结果：
a + b = 14
a - b = 6
a * b = 40
int类型：   a / b = 2
double类型：a * 1.0 / b = 2.5
double类型：a / b * 1.0 = 2.0
a % b = 2

二、案例：数值拆分

需求：一个三位数，将其拆分为个位、十位、百位后，打印在控制台

例：
请输入整数：
123
整数123的个位为：3
整数123的十位为：2
整数123的百位为：1

package com.app.operator;

public class OperatorTest2 {
    public static void main(String[] args) {
        /*
            案例：数值拆分
            需求：一个三位数，将其拆分为个位、十位、百位后，分别打印在控制台
         */
        // 1.定义一个int类型的变量number，初始值为：678
        int number = 678;
        // 2.将 678 拆分为个位、十位、百位（除、取余）
        int ge = number % 10;       // 678 / 10 = 67 余8
        // 678 / 10 = 67 余8 再将 67 % 10 = 7（67 / 10 = 6 余 7）
        int shi = number / 10 % 10; 
        // 678 / 100 = 6.78，由于表达式最高类型是整数类型，所以最终结果是整数
        int bai = number / 100; 
        // 3.分别打印在控制台
        System.out.print("整数678的个位为：");
        System.out.println(ge);
        System.out.print("整数678的十位为：");
        System.out.println(shi);
        System.out.print("整数678的百位为：");
        System.out.println(bai);
    }
}

输出结果：
整数678的个位为：8
整数678的十位为：7
整数678的百位为：6

三、“+” 做连接符

• “+” 符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串。

• 独门秘籍

  • 能算则算，不能算就在一起。

package com.app.operator;

public class OperatorDemo3 {
    public static void main(String[] args) {
        // 目标：掌握“+”符号与字符串的连接操作
        // 1.定义一个int类型的变量，初始值随便给，用于识别 + 符号连接操作
        int a = 5;
        // 'A'的在ASCII码表对应的数字是：65
        System.out.println("三国五虎上将有" + a + "个人");   // 三国五虎上将有5个人
        System.out.println("张飞和关羽有" + 'a' + "个兄弟"); // 张飞和关羽有a个兄弟
        System.out.println(a + 'A');    // 70
        System.out.println("acd" + a + 'A');    // acd5A
        System.out.println(10 + "go" + 5);      // 10go5
        System.out.println(a + "" + 'A');       // 5A
        System.out.println(a + 'A' + "个张飞");  // 70个张飞
        System.out.println("关羽有个" + a + 'A');// 关羽有个5A
        System.out.println("关羽有" + ('A' - a) + "个兄弟");  // 关羽有60个兄弟
    }
}

输出结果：
三国五虎上将有5个人
张飞和关羽有a个兄弟
70
acd5A
10go5
5A
70个张飞
关羽有个5A
关羽有60个兄弟

四、自增自减运算符

注意

• ++ 和 – 既可以放在变量的后边，也可以放在变量的前边

• ++、-- 只能操作变量，不能操作字面量的

  • 例如：

    ++1、--1、1++、1--  // 这些都是错误的
        
    // 正确用法
    int a = 1;
    int b = a++;
    int c = a--;
    int d = ++a;
    int e = --a;
    
    

• 自增、自减运用场景，举例：抖音短视频双击红心功能

  例如：

  package com.app.operator;
  
  public class OperatorDemo4 {
      public static void main(String[] args) {
          // 目标：掌握自增、自减运算符：++、--
          // 定义一个int类型的变量love，用于存放用户点亮的红心，初始值为0
          int love = 0;
          // 用户觉得这个视频不错。点亮红心了 +1 (注意：++ 放在变量的前边或者后边，结果都一样)
  //        love++;	// love = love + 1;
          ++love;
          System.out.println(love);
          // 用户觉得被这个视频骗到了。取消了点亮的红心 -1 (注意：-- 放在变量的前边或者后边，结果都一样)
  //        love--;	// love = love - 1;
          --love;
          System.out.println(love);
      }
  }
  

  输出结果：
  1
  0
  
  

  

自增自减的使用注意事项

• ++、-- 如果不是单独使用（如在表达式中、或者同时有其它操作），放在变量前后会存在明显区别

  • 放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算

  • 放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1

    例如：

    package com.app.operator;
    
    public class OperatorDemo4 {
        public static void main(String[] args) {
            // 目标：掌握自增、自减运算符：++、--
            System.out.println("++、-- 单独使用时，放在变量前后不存在区别");
            // 定义一个int类型的变量love，用于存放用户点亮的红心，初始值为0
            int love = 0;
            // 用户觉得这个视频不错。点亮红心了 +1 (注意：++ 放在变量的前边或者后边，结果都一样)
    //        love++;
            ++love;
            System.out.println(love);
            // 用户觉得被这个视频骗到了。取消了点亮的红心 -1 (注意：-- 放在变量的前边或者后边，结果都一样)
    //        love--;
            --love;
            System.out.println(love);
    
            System.out.println("-----------------------------------");
            System.out.println("++、-- 不是单独使用时，放在变量前后会存在明显区别");
            // 1.++、-- 放在变量的前面，先+1、-1，再使用变量
            int i = 10;
            System.out.println("i = " + i);
            System.out.println("++放在变量前面，先+1，再使用变量");
            int j = ++i;
            System.out.println("i = " + i);
            System.out.println("j = " + j);
    
            System.out.println("-----------------------------------");
            int m = 10;
            System.out.println("m = " + m);
            System.out.println("--放在变量前面，先-1，再使用变量");
            int l = --m;
            System.out.println("m = " + m);
            System.out.println("l = " + l);
    
            System.out.println("-----------------------------------");
            // 2.++、-- 放在变量的后面，先使用变量，再+1、-1
            int number = 20;
            System.out.println("number = " + number);
            System.out.println("++放在变量后面，先使用变量，再+1");
            int number2 = number++;
            System.out.println("number = " + number);
            System.out.println("number2 = " + number2);
    
            System.out.println("-----------------------------------");
            int number3 = 20;
            System.out.println("number3 = " + number3);
            System.out.println("--放在变量后面，先使用变量，再-1");
            int number4 = number3--;
            System.out.println("number3 = " + number3);
            System.out.println("number4 = " + number4);
        }
    }
    

    ++、-- 单独使用时，放在变量前后不存在区别
    1
    0
    -----------------------------------
    ++、-- 不是单独使用时，放在变量前后会存在明显区别
    i = 10
    ++放在变量前面，先+1，再使用变量
    i = 11
    j = 11
    -----------------------------------
    m = 10
    --放在变量前面，先-1，再使用变量
    m = 9
    l = 9
    -----------------------------------
    number = 20
    ++放在变量后面，先使用变量，再+1
    number = 21
    number2 = 20
    -----------------------------------
    number3 = 20
    --放在变量后面，先使用变量，再-1
    number3 = 19
    number4 = 20
    
    

五、案例：自增、自减拓展案例（有些面试题会出现）

package com.app.operator;

public class OperatorTest5 {
    public static void main(String[] args) {
        // 目标：练习自增、自减拓展案例（有些面试题会出现）
        int c = 10;
        int d = 5;
        // c:10  11     12                  11  c————> 最终变成了 11
        // d:5                4     5           d————> 最终变成了 5
        // rs: = 10  +  12 -  4  -  5  +1 + 12  rs————>结果 = 26
        int rs = c++ + ++c - --d - ++d +1 + c--;
        System.out.println("c = " + c);     // 11
        System.out.println("d = " + d);     // 5
        System.out.println("rs = " + rs);   // 26
    }
}

输出结果：
c = 11
d = 5
rs = 26

六、赋值运算符

基本赋值运算符

• 就是 “=”（常用）

  int a = 10;	// 先看 “=” 右边，把数据10 赋值给 左边的int类型变量a存储
  

扩展赋值运算符（自带强制类型转换）

注意：扩展的赋值运算符隐含了强制类型转换

package com.app.operator;

public class OperatorDemo6 {
    public static void main(String[] args) {
        // 目标：掌握赋值运算符：=、+=、-=、*=、/=、%=
        int a = 10;
        int b = 200;
        // a = a + b; //以前的写法
        a += b; // 等价于 a = (int)(a + b);    会自带强制类型转换
        System.out.println("a+=b = " + a);

        byte i = 10;
        byte j = 20;
        // i = (byte) (i + j);
        i += j; // 等价于 i = (byte) (i + j);
        System.out.println("i+=j = " + i);

        int m = 30;
        int n = 5;
        m += n;     // 等价于 m = (int)(m + n);  // m = (int)(30 + 5)，m = 35;
        System.out.println("m+=n = " + m);
        m -= n;     // 等价于 m = (int)(m - n);  // m = (int)(35 - 5)，m = 30;
        System.out.println("m-=n = " + m);
        m *= n;     // 等价于 m = (int)(m * n);  // m = (int)(30 * 5)，m = 150;
        System.out.println("m*=n = " + m);
        m /= n;     // 等价于 m = (int)(m / n);  // m = (int)(30 / 5)，m = 30;
        System.out.println("m/=n = " + m);
        m %= n;     // 等价于 m = (int)(m % n);  // m = (int)(30 % 5)，m = 0;
        System.out.println("m%=n = " + m);
    }
}

输出结果：
a+=b = 210
i+=j = 30
m+=n = 35
m-=n = 30
m*=n = 150
m/=n = 30
m%=n = 0

七、关系运算符

• 是对数据进行条件判断的符号，最终会返回一个比较的布尔结果（true（真），false（假））

注意

• 在做相等判断时，千万不要把 == 误写成 =

package com.app.operator;

public class OperatorDemo7 {
    public static void main(String[] args) {
        /*
            目标：掌握关系运算符：==、!=、>、>=、<、<=
            返回结果为布尔类型（boolean），true或false
         */
        int a = 10;     // 定义int类型变量a，初始值为10
        int b = 10;     // 定义int类型变量b，初始值为10
        boolean rs = a == b;    // true，因为10 == 10
        boolean rs2 = a != b;   // false，因为10 == 10，所以10 != 10，不成立
        boolean rs3 = a > b;    // false，因为10 == 10，所以10 > 10，不成立
        boolean rs4 = a >= b;   // true，因为10 == 10，所以10 >= 10，满足等号，成立
        boolean rs5 = a < b;    // false，因为10 == 10，所以10 < 10，不成立
        boolean rs6 = a <= b;   // true，因为10 == 10，所以10 <= 10，满足等号，成立
        // 打印各比较结果
        System.out.println("a==b = " + rs);
        System.out.println("a!=b = " + rs2);
        System.out.println("a>b = " + rs3);
        System.out.println("a>=b = " + rs4);
        System.out.println("a<b = " + rs5);
        System.out.println("a<=b = " + rs6);

        System.out.println("--------------------------------");
        double d = 6.6;     // 定义double类型变量d，初始值为6.6
        double d2 = 99.8;   // 定义double类型变量d2，初始值为99.8
        boolean b1 = d == d2;   // false
        boolean b2 = d != d2;   // true
        boolean b3 = d > d2;    // false
        boolean b4 = d >= d2;   // false
        boolean b5 = d < d2;    // true
        boolean b6 = d <= d2;   // true
        // 打印各比较结果
        System.out.println("d==d2 = " + b1);
        System.out.println("d!=d2 = " + b2);
        System.out.println("d>d2 = " + b3);
        System.out.println("d>=d2 = " + b4);
        System.out.println("d<d2 = " + b5);
        System.out.println("d<=d2 = " + b6);
        
        System.out.println("！！！！！！！！！！！！！！注意！！！！！！！！！！！！！！！");
        // 注意点：不要把 == 误写成 =，= 是赋值
        System.out.println(d = d2);	// 输出结果为：99.8，因为 = 是把右边变量的值 赋值给 左边变量
    }
}

输出结果：
a==b = true
a!=b = false
a>b = false
a>=b = true
a<b = false
a<=b = true
--------------------------------
d==d2 = false
d!=d2 = true
d>d2 = false
d>=d2 = false
d<d2 = true
d<=d2 = true
！！！！！！！！！！！！！！注意！！！！！！！！！！！！！！！
99.8

八、逻辑运算符

• 可以把多个条件的布尔结果放在一起运算，最终返回一个布尔结果

  符号	介绍	说明
  &	逻辑与	必须都是true，结果才是true；只要有一个是false，结果一定是false
  |	逻辑或	只要有一个true，结果就是true
  !	逻辑非	你真我假、你假我真、非真既假。!true = false、!false = true
  ^	逻辑异或	如果两个条件都是false 或者 都是true 则结果是false。两个条件不同结果是true。

• 像京东、淘宝，你搜索一台笔记本或者一台手机，是不是要筛选品牌、屏幕尺寸、存储内存等等这些多个条件啊，这些都是要用到逻辑运算符的

package com.app.operator;

public class OperatorDemo8 {
    public static void main(String[] args) {
        /*
            目标：掌握逻辑运算符：&、|、!、^
            并能够选择合适的逻辑运算符解决问题
            最终返回结果是布尔类型（boolean）：true、false
         */
        // 1.定义两个double类型的变量，分别用于存储笔记本屏幕尺寸、存储内存容量
        double size = 14.3;
        double storage = 256;
        System.out.println("-------------  逻 辑 与   -------------");
        // 需求：尺寸要大于等于14.3，内存要大于等于128GB
        // 注意：&——逻辑与运算符 必须前后的条件都是true，结果才为true
        boolean logicalAnd = size >= 14.3 & storage >= 128;  // 屏幕尺寸与内存结果都为true，所以最终结果也为true
        boolean logicalAnd1 = size >= 14.3 & storage <= 128; // 屏幕尺寸为true，但是内存不为true，所以最终结果为false
        System.out.println("logicalAnd = " + logicalAnd);
        System.out.println("logicalAnd1 = " + logicalAnd1);

        System.out.println("-------------  逻 辑 或   -------------");
        // 需求：要么尺寸大于等于14.3，要么内存大于等于1TB=1024GB
        // 注意：|——逻辑或运算符 只要有一个条件是true，结果就为true
        boolean logicalOr = size >= 14.3 | storage >= 1024;
        System.out.println("logicalOr = " + logicalOr);     // 屏幕尺寸结果为true，内存结果为false，所以满足条件之一，最终结果为true

        System.out.println("-------------  逻 辑 非   -------------");
        // 注意：逻辑非是非真既假、你真我假、你假我真
        boolean logicalNot = !true;     // false
        boolean logicalNot1 = !false;   // true
        System.out.println("logicalNot = " + logicalNot);
        System.out.println("logicalNot1 = " + logicalNot1);

        System.out.println("-------------  逻辑异或   -------------");
        // 注意：逻辑异或：两个结果都为true 或 都为false，则最终结果为false；两个结果不同才为true
        boolean logicalXOR = true ^ true;       // false
        boolean logicalXOR1 = false ^ false;    // false
        boolean logicalXOR2 = true ^ false;     // true
        boolean logicalXOR3 = false ^ true;     // true
        System.out.println("logicalXOR = " + logicalXOR);
        System.out.println("logicalXOR1 = " + logicalXOR1);
        System.out.println("logicalXOR2 = " + logicalXOR2);
        System.out.println("logicalXOR3 = " + logicalXOR3);
    }
}

输出结果：
-------------  逻 辑 与   -------------
logicalAnd = true
logicalAnd1 = false
-------------  逻 辑 或   -------------
logicalOr = true
-------------  逻 辑 非   -------------
logicalNot = false
logicalNot1 = true
-------------  逻辑异或   -------------
logicalXOR = false
logicalXOR1 = false
logicalXOR2 = true
logicalXOR3 = true

短逻辑运算符

注意

• 逻辑与（&）、逻辑或（|）无论左边是 true 还是 false，右边都要执行！！

逻辑与（&）、逻辑或（|）、短路与（&&）、短路或（||）的区别

package com.app.operator;

public class OperatorDemo9 {
    public static void main(String[] args) {
        // 目标：理解逻辑与（&）、逻辑或（|）、短路与（&&）、短路或（||）的区别
        int a = 10;
        int b = 20;
        System.out.println("------------------ 逻 辑 与（&） ------------------");
        // 1.逻辑与：&——>无论左边判断结果是true还是false，右边依然会执行
        boolean logicalAnd = a > 2 & ++b > 10;  //左边判断结果为true，利用 ++b来改变b变量的值，方便观察 & 是否执行右边
        System.out.println("logicalAnd = " + logicalAnd);
        System.out.println("b = " + b); // 20变21，说明 & 左边判断结果为true时，依然执行右边判断

        boolean logicalAnd1 = a < 2 & ++b > 10;  //左边判断结果为false，利用 ++b来改变b变量的值，方便观察 & 是否执行右边
        System.out.println("logicalAnd1 = " + logicalAnd1);
        System.out.println("b = " + b); // 21变22，说明 & 左边判断结果为false，依然执行右边判断


        System.out.println("------------------ 短 路 与（&&） ------------------");
        // 2.短路与：&&——>左边判断结果为false，右边则不会执行，直接短路
        boolean dly = a < 2 && ++b > 10;    // 左边判断结果为false，利用 ++b来改变b变量的值，方便观察 && 是否执行右边
        System.out.println("dly = " + dly);
        System.out.println("b = " + b); // b的值依然是22，说明 && 左边判断结果为false，右边则不会执行

        boolean dly2 = a > 2 && ++b > 10;  // 左边判断结果为true，利用 ++b来改变b变量的值，方便观察 && 是否执行右边
        System.out.println("dly2 = " + dly2);
        System.out.println("b = " + b); // 22变23，说明 && 左边判断结果为true，右边会执行


        System.out.println("------------------ 逻 辑 或（|） ------------------");
        boolean logicalOr = a > 2 | ++b < 10;   // 左边判断结果为true，利用 ++b来改变b变量的值，方便观察 | 是否执行右边
        System.out.println("logicalOr = " + logicalOr);
        System.out.println("b = " + b); // 23变24，说明 | 左边判断结果为true，右边会执行

        boolean logicalOr2 = a < 2 | ++b > 10;  // 左边判断结果为false，利用 ++b来改变b变量的值，方便观察 | 是否执行右边
        System.out.println("logicalOr2 = " + logicalOr2);
        System.out.println("b = " + b); // 24变25，说明 | 左边判断结果为false，右边会执行


        System.out.println("------------------ 短 路 或（||） ------------------");
        boolean dlh = a > 2 || ++b < 10;    // 左边判断结果为true，利用 ++b来改变b变量的值，方便观察 || 是否执行右边
        System.out.println("dlh = " + dlh);
        System.out.println("b = " + b);     // b的值25没有改变，说明 || 左边判断结果为true，右边则不会执行

        boolean dlh2 = a < 2 || ++b > 10;   // 左边判断结果为false，利用 ++b来改变b变量的值，方便观察 || 是否执行右边
        System.out.println("dlh2 = " + dlh2);
        System.out.println("b = " + b);     // 25变26，说明 || 左边判断结果为false，右边会执行
    }
}

输出结果：
------------------ 逻 辑 与（&） ------------------
logicalAnd = true
b = 21
logicalAnd1 = false
b = 22
------------------ 短 路 与（&&） ------------------
dly = false
b = 22
dly2 = true
b = 23
------------------ 逻 辑 或（|） ------------------
logicalOr = true
b = 24
logicalOr2 = true
b = 25
------------------ 短 路 或（||） ------------------
dlh = true
b = 25
dlh2 = true
b = 26

九、三元运算符

• 格式：

  条件表达式 ? 值1 : 值2;
  

• 执行流程：首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2

package com.app.operator;

public class OperatorDemo10 {
    public static void main(String[] args) {
        // 目标：掌握三元运算符，理解其流程
        // 1.定义学生名字为小明，成绩为98分，使用三元运算符判断这个成绩是否考试通过或挂科
        String name = "小明";
        double score = 98;
        /*
            1、格式：条件表达式 ? 值1 : 值2;
            2、执行流程：三元运算符先判断 变量score的值 是否大于等于 60分及格线
              该值为98，所以是大于等于60分及格线的，判断结果为true，所以返回值1：“考试通过”
         */
        String result = score >= 60 ? "考试通过" : "挂科";
        System.out.println(name + "同学考得成绩：" + score + "，所以" + result + "了！");

        // 2.定义学生名字为晓东，成绩为59.5分，使用三元运算符判断这个成绩是否考试通过或挂科
        String name2 = "晓东";
        double score2 = 59.5;
        /*
            1、格式：条件表达式 ? 值1 : 值2;
            2、执行流程：三元运算符先判断 变量score的值 是否大于等于 60分及格线
              该值为59.5，所以是小于60分及格线的，判断结果为false，所以返回值2：“挂科”
         */
        String result1 = score2 >= 60 ? "考试通过" : "挂科";
        System.out.println(name2 + "同学考得成绩：" + score2 + "，所以" + result1 + "了！！！");
    }
}

输出结果：
小明同学考得成绩：98.0，所以考试通过了！
晓东同学考得成绩：59.5，所以挂科了！！！

小案例巩固

• 需求：从2个整数中找出较大值

package com.app.operator;

public class OperatorTest11 {
    public static void main(String[] args) {
        // 小案例：需求——>需要从2个整数中找出较大值
        // 1.定义两个int类型的变量存放两个整数
        int a = 100;
        int b = 2000;
        // 2.使用三元运算符将两个整数进行比较，假如：100 > 2000 如果为true，返回值100，否则返回值2000
        int max = a > b ? a : b;
        System.out.println("整数" + a + "与整数" + b + "中较大值为：" + max);

        // 3.定义两个int类型的变量存放两个整数
        int c = 10000;
        int d = 5000;
        // 4.使用三元运算符将两个整数进行比较，假如：10000 > 5000 如果为true，返回值10000，否则返回值5000
        int max1 = c > d ? c : d;
        System.out.println("整数" + c + "与整数" + d + "中较大值为：" + max1);
    }
}

输出结果：
整数100与整数2000中较大值为：2000
整数10000与整数5000中较大值为：10000

十、案例：

• 求三个整数的最大值

  • 分析：

  • （1）先用三元运算符获取前两个整数的最大值，并用临时变量存起来

  • （2）然后用三元运算符，让临时最大值与第三个整数进行比较，得出三个整数的最大值

  • （3）打印输出三个整数的最大值

    package com.app.operator;
    
    public class OperatorTest12 {
        public static void main(String[] args) {
            /*
                小案例：求三个整数的最大值
                分析：
                （1）先用三元运算符将前两个整数进行比较，用临时变量存起来
                （2）然后用三元运算符将临时最大值与第三个整数进行比较，得出三个整数的最大值
                （3）打印输出三个整数的最大值
             */
    
            // 1.定义三个int类型的变量，用于分别存放三个整数，用于求三个整数最大值
            int a = 1900;
            int b = 5;
            int c = 20000;
    
            // 2.先用三元运算符将前两个整数进行比较，用临时变量存起来
            int tempMax = a > b ? a : b;
    
            // 3.然后用三元运算符将临时最大值与第三个整数进行比较，得出三个整数的最大值
            int max = tempMax > c ? tempMax : c;
    
            // 4.打印输出三个整数的最大值
            System.out.println("整数" + a + "、整数" + b + "、整数" + c + "，这三个整数的最大值为：" + max);
        }
    }
    

    输出结果：
    整数1900、整数5、整数20000，这三个整数的最大值为：20000
    
    

三元运算符拓展知识

• 三元运算符的嵌套

• 求三个整数的最大值

  • 分析：

  • 用三元运算符嵌套比较——>

    假如：第一个 大于 第二个 问 (如果为true：属于第一个整数胜出，接着假如：第一个 大于 第三个 问 如果为true：则值1：第一个 : 值2：第三个) : (假如：第一个 小于 第二个：属于第二个整数胜出，接着假如：第二个 大于 第三个 问 如果为true：则值1：第二个 : 值2：第三个 );

    package com.app.operator;
    
    public class OperatorTest12 {
        public static void main(String[] args) {
            /*
                小案例：求三个整数的最大值
                分析：
                （1）先用三元运算符将前两个整数进行比较，用临时变量存起来
                （2）然后用三元运算符将临时最大值与第三个整数进行比较，得出三个整数的最大值
                （3）打印输出三个整数的最大值
             */
    
            // 1.定义三个int类型的变量，用于分别存放三个整数，用于求三个整数最大值
            int a = 1900;
            int b = 5;
            int c = 20000;
    
            // 2.先用三元运算符将前两个整数进行比较，用临时变量存起来
            int tempMax = a > b ? a : b;
    
            // 3.然后用三元运算符将临时最大值与第三个整数进行比较，得出三个整数的最大值
            int max = tempMax > c ? tempMax : c;
    
            // 4.打印输出三个整数的最大值
            System.out.println("整数" + a + "、整数" + b + "、整数" + c + "，这三个整数的最大值为：" + max);
    
            System.out.println("-------------------三元运算符拓展知识----------------");
            /*
                小案例：求三个整数的最大值
                分析：使用三元运算符嵌套：
                假如：第一个 大于 第二个 问
                (如果为true：属于第一个整数胜出，接着第一个 大于 第三个  问  如果为true：则值1：第一个 : 值2：第三个)
                 :
                (第一个  小于  第二个  问  如果为true：属于第二个整数胜出，第二个 大于 第三个  问  如果为true：则值1：第二个  :  值2：第三个 );
             */
            // 1.定义三个int类型的变量，用于分别存放三个整数，用于求三个整数最大值
            int i = 1900;
            int j = 5;
            int k = 20000;
            // 2.使用三元运算符嵌套： 条件表达式 ?      值1        :       值2      ;
            // 不拆分形式为：           i > j ? (i > k ? i : k) : (j > k ? j : k);
            int max1 = i > j ? i > k ? i : k : j > k ? j : k;  // 拆分形式
            // 4.打印输出三个整数的最大值
            System.out.println("整数" + i + "、整数" + j + "、整数" + k + "，这三个整数的最大值为：" + max1);
        }
    }
    

    输出结果：
    整数1900、整数5、整数20000，这三个整数的最大值为：20000
    -------------------三元运算符拓展知识----------------
    整数1900、整数5、整数20000，这三个整数的最大值为：20000
    
    

    十一、运算符优先级

• 在表达式中，哪个运算符先执行后执行是要看优先级的，例如 “*、/” 的优先级高于 “+、-”

  优先级	运算符
  1	()
  2	!、-、++、–
  3	*、/、%
  4	+、-
  5	<<、>>、>>>
  6	<、<=、>、>=、instanceof
  7	==、!=
  8	&
  9	^
  10	|
  11	&&
  12	||
  13	? :
  14	=、+=、-=、*=、/=、%=、&=

package com.app.operator;

public class OperatorDemo13 {
    public static void main(String[] args) {
        // 目标：看看Java是否存在优先级，大家以后需注意优先级问题

        //因为 && 的优先级比 || 的高，所以先比较 && 的左和右，很明显&&的结果为false
        //后比较 || 的左和右，左为true，所以不会执行右边，则||结果为true
        System.out.println(10 > 3 || 10 > 3 && 10 < 3);     // true

        //因为 () 的优先级是最高的，所以先比较 () 里的 || 的左和右，则||的结果为true
        //后比较 && 的左和右，左为true，则右为false，则&&结果为false
        System.out.println((10 > 3 || 10 > 3) && 10 < 3);   // false
    }
}

输出结果：
true
false

十二、总结

基本的算术运算符

1、基本的算术运算符有哪些？

• +、-、*、/、%

2、“/” 需要注意什么，为什么？

• 如果两个整数做除法，其结果一定是整数，因为最高类型是整数类型

“+”符号做连接符

1、+ 符号除了做基本的算术运算，还有哪些功能？

• 与字符串做 + 运算时会被当成连接符，其结果还是字符串
• 能算则算，不能算就在一起

自增自减

1、自增、自减运算符是什么，有什么作用？

• ++、–。对当前变量值+1、-1
• 例如：抖音短视频的点亮红心功能——>双击了，就红心++；取消了，就红心–；或 ++红心、–红心

2、自增、自减运算符在变量前后有区别吗？

• 如果单独使用方前后是没有区别的
• 非单独使用：++、-- 在变量前，先进行变量自增/自减，再使用变量
• 非单独使用：++、-- 在变量后，先使用变量，再进行变量自增/自减

赋值运算符

1、赋值运算符有哪些？

• =、+=、-=、*=、/=、%=

2、作用是什么？

• 基本作用是赋值
• += 可以实现数据的累加，把别人的数据加给自己

关系运算符

1、什么是关系运算符？

• 对数据进行条件判断的符号，最终会返回一个比较的布尔结果（true—>真，false—>假）

2、在做相等判断时，需注意什么呢？

• 不要将 == 误写成 = ，因为 = 是进行赋值操作，将右边的值 赋值给 左边

  例如：

  int a = 10;
  int b = 2;
  System.out.println(a = b);
  

  输出结果：
  2
  
  

逻辑运算符

1、逻辑运算符有哪些，有什么特点？

• 逻辑与（&）：有一个false，结果是false，两个都为true结果才为true
• 短路与（&&）：有一个false，结果是false。左边为false，则不会执行右边，因为满足不了两个都为true，所以直接短路（性能更好）
• 逻辑或（|）：有一个true，结果是true
• 短路或（||）：有一个为true，结果是true。左边为true，则不会执行右边，因为已经满足一个true，所以直接短路（性能更好）
• 逻辑非（!）：!true=false; !false=true;（非真既假）
• 逻辑异或（^）：相同是false，不同是true
• 注意：实际开发中，常用的逻辑运算符是：&&、||、!