Java基础之运算符

Java基础之运算符

目录

• Java基础之运算符
  
  
  
  • 
    
    
    
    • 1.1 运算符介绍
      
      
      
      • 1.1.1 运算符介绍
        
      
      
    • 1.2 算术运算符
      
      
      
      • 1.2.1 介绍
        
      • 1.2.2 算术运算符一览表
        
      • 1.2.3 代码演示
        
      • 1.2.4 细节说明
        
      • 1.2.5 面试题
        
      • 1.2.6 小练习
        
      
      
    • 1.3 关系运算符（比较运算符）
      
      
      
      • 1.3.1 介绍
        
      • 1.3.2 关系运算符一览表
        
      • 1.3.3 案例演示
        
      • 1.3.4 细节说明
        
      
      
    • 1.4 逻辑运算符
      
      
      
      • 1.4.1 介绍
        
      • 1.4.2 逻辑运算符一览表
        
      • 1.4.3 && 和 & 基本规则
        
      • 1.4.4 && 和 & 案例演示
        
      • 1.4.5 && 和 & 使用区别
        
      • 1.4.6 || 和 | 基本规则
        
      • 1.4.7 || 和 | 案例演示
        
      • 1.4.8 || 和 | 使用区别
        
      • 1.4.8 ! 取反基本规则
        
      • 1.4.9 ! 案例演示
        
      • 1.4.10 ^ 基本规则
        
      • 1.4.11 练习题 写出输出结果
        
      
      
    • 1.5 赋值运算符
      
      
      
      • 1.5.1介绍
        
      • 1.5.2 赋值运算符的分类
        
      • 1.5.3 赋值运算符的特点
        
      
      
    • 1.6 三元运算符
      
      
      
      • 1.6.1 基本语法
        
      • 1.6.2 使用细节
        
      
      
    • 1.7 运算符的优先级
      
    
    
  
  

1.1 运算符介绍

1.1.1 运算符介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等，运算符可分为：
1）算术运算符
2）赋值运算符
3）关系运算符 [比较运算符]
4）逻辑运算符
5）位运算符 [需要二进制]
6）三元运算符
1.2 算术运算符

1.2.1 介绍

算术运算符是对数值类型的变量进行运算的，在Java程序中使用非常多
1.2.2 算术运算符一览表


1.2.3 代码演示

1. public class ArithmeticOperator {
2.     /**
3.      * 演示算数运算符的使用
4.      */
5.     public static void main(String[] args) {
6.         System.out.println(10 / 4); //2   两个数都是int类型，结果为int类型
7.         System.out.println(10.0 / 4); //2.5  有一个为double类型，结果为double类型
9.         double d = 10 / 4; //10 / 4 为int类型，会自动转换为double类型
10.         System.out.println(d); //2.0
12.         // % 取余（取模）
13.         //在Java中 % 的本质是：a % b = a - a / b * b
14.         //-10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
15.         //10 % -3 => 10 - 10 / (-3) * (-3) = 10 - 9 = 1
16.         //-10 % -3 => -10 - (-10) / (-3) * (-3) = -10 + 9 = -1
17.         System.out.println(10 % 3); // 1
18.         System.out.println(-10 % 3); // -1
19.         System.out.println(10 % -3); // 1
20.         System.out.println(-10 % -3); // -1
22.         // ++的使用
23.         /*
24.             作为语句独立使用：
25.             前++ 和 后++ 独立使用时都等价于 i = i + 1;
26.          */
27.         int i = 10;
28.         i++; //自增  等价于 i = i + 1; => i = 11;
29.         ++i; //自增  等价于 i = i + 1; => i = 12;
30.         System.out.println("i=" + i); //12
31.         /*
32.             作为表达式使用：
33.             前++: ++i 先自增后赋值
34.             后++: i++ 先赋值后自增
35.          */
36.         int j = 8;
37.         int k = ++ j; //等价于 j = j + 1; k = j;
38.         int n = j ++; //等价于 n = j; j = j + 1;
39.         System.out.println("k=" + k + "n=" + n + "j=" + j); // k=9  n=9  j=10
40.     }
41. }

复制代码

1.2.4 细节说明

• 对于除号"/"，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如： int x = 10 / 3; 结果为3。
  
• 当对一个数取余（取模），可以等价a % b = a - a / b * b ,根据这个公式，我们可以看到取余的一个本质运算。
  
• 当自增当做一个独立语言使用时，不管是++i 还是 i++ 都是一样的，等价于 i = i + 1。
  
• 当自增当做一个表达式使用时，前++: ++i 先自增后赋值；后++: i++ 先赋值后自增
  

1.2.5 面试题

1）面试题一
int i = 1;
i = i++;
System.out.println(i);
结果为多少？为什么？

• i = i++; 后++ 先赋值，后自增。这一过程中使用了临时变量来存放i的值
  （1）int temp = i;  // temp=1
  （2）i = i + 1;  // i=2
  （3）i = temp;  // i=1
  所以最后结果为：i = 1
  

2）面试题二
int i = 1;
i = ++i;
System.out.println(i);
结果为多少？为什么？

• i = ++i; 前++ 先自增，后赋值。这一过程中使用了临时变量来存放i的值
  （1）i = i + 1; // i=2
  （2）int temp = i; // temp=2
  （3）i = temp; // i=2
  所以最后结果为：i = 2
  

1.2.6 小练习

1）看看输出是什么?

1.   int i1 = 10;
2.   int i2 = 20;
3.   int i = i1++;
4.   System.out.print("i="+i); //10
5.   System.out.println("i2="+i2); //20
6.   i = --i2;
7.   System.out.print("i="+i); //19
8.   System.out.println("i2="+i2); //19

复制代码

• 步骤如下:
  

​     i1 = 10;
​     i2 = 20;
​     i = i1++; // 先赋值，后自增 i=10，i1=11，i2=20
​     i = --i2; // 先自减，后赋值 i2=19，i=19
2）假如还有 59 天放假，问：合 xx 个星期零 xx 天

1. public class ArithmeticOperatorExercise {
2.     public static void main(String[] args) {
3.         //假如还有 59 天放假，问：合 xx 个星期零 xx 天
4.         /*
5.              1）需求：
6.                假如还有 59 天放假，问：合 xx 个星期零 xx 天
7.              2）思路分析：
8.                使用int型变量来存放天数
9.                一星期有7天
10.                天数除以7 可得星期数
11.                天数对7取余 可得零几天
12.              3）走代码：
13.          */
14.         int days = 59;
15.         int weeks = days / 7;
16.         int leftDays = days % 7;
17.         System.out.println(days + "天合" + weeks + "个星期零" + leftDays + "天");
18.     }
19. }

复制代码

3）定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：
5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。 [234.5]

1. public class ArithmeticOperatorExercise {
2.     public static void main(String[] args) {     
3.         /*
4.              1）需求：
5.                定义一个变量保存华氏温度，请求出华氏温度对应的摄氏温度。
6.              2）思路分析：
7.                定义一个double变量fahrenheit保存华氏温度
8.                根据公式计算对应的摄氏温度
9.                定义一个double变量Celsius保存摄氏温度
10.              3）走代码：
11.          */
12.         double fahrenheit = 1234.6;
13.         double Celsius = 5.0 / 9 * (fahrenheit - 100);
14.         System.out.println("华氏温度" + fahrenheit + " 对应的摄氏温度="+ Celsius);
15.     }
16. }

复制代码

1.3 关系运算符（比较运算符）

1.3.1 介绍

1）关系运算符的结果都是boolean类型，要么是true，要么是false。
2）关系表达式经常用在if结构的条件或循环结构的条件中。
1.3.2 关系运算符一览表


1.3.3 案例演示

1. public class RelationalOperator {
2.     //编写一个 main 方法
3.     public static void main(String[] args) {
4.         int a = 9; // 开发中，不可以使用 a, b
5.         nt b = 8;
6.         System.out.println(a > b); //T
7.         System.out.println(a >= b); //T
8.         System.out.println(a <= b); //F
9.         System.out.println(a < b);//F 第 63页
10.         System.out.println(a == b); //F
11.         System.out.println(a != b); //T
12.         boolean flag = a > b; //T
13.         System.out.println("flag=" + flag);
14.     }
15. }

复制代码

在开发中不可以使用a、b这种简单的字符来命名变量
1.3.4 细节说明

1）关系运算符的结果都是boolean类型，要么是true，要么是false。
2）关系运算符组成的表达式，我们称为关系表达式。
3）比较运算符"= ="不能误写成"="。
1.4 逻辑运算符

1.4.1 介绍

用于连接多个条件（多个关系表达式），最终的结果也是一个boolean值。。
1.4.2 逻辑运算符一览表

1）短路与 &&，短路或 ||，取反 ！
2）逻辑与 &，逻辑或 |，逻辑异或 ^

3)运算规则说明：

• a & b：& 叫逻辑与。当a和b同时为true，则结果为true，否则为false
  
• a && b：&& 叫短路与。当a和b同时为true，则结果为true，否则为false
  
• a | b：| 叫逻辑或。当a和b有一个为true，则结果为true，否则为false
  
• a || b：|| 叫短路或。当a和b有一个为true，则结果为true，否则为false
  
• !a：叫取反。当a为true，则结果为false；当a为false，则结果为true
  
• a ^ b：叫逻辑异或。当a和b不同时，则结果为true，否则为false
  

1.4.3 && 和 & 基本规则

名称             语法                                    特点
短路与&&     条件1 && 条件2   当两个同时为true，则结果为true，否则为false。如果条件1为false，则不判断条件2，结果为false
逻辑与&      条件1 & 条件2    当两个同时为true，则结果为true，否则为false.如果条件1为false，继续判断条件2，结果为false
1.4.4 && 和 & 案例演示

1. public class LogicOperator01 {
2.     public static void main(String[] args) {
3.         // &&短路与 和 &逻辑与 演示
4.         /*
5.               && 规则: 两个条件都为true，结果为 true,否则为 false
6.               & 规则: 两个条件都为true，结果为 true,否则为 false
7.          */
8.         // &&短路与
9.         int age =50;
10.         if(age > 20 && age < 90){
11.             System.out.println("0k100");
12.         }
13.         // &逻辑与
14.         if(age > 20 & age < 90) {
15.             System.out.println("ok200");
16.         }
17.         //区别
18.         int a = 4;
19.         int b = 9;
20.         //对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断
21.         //对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断
22.         if(a < 1 & ++b < 50) {
23.             System.out.println("ok300");
24.         }
25.         System.out.println("a=" + a + " b=" + b);// a=4  b=10
26.     }
27. }

复制代码

1.4.5 && 和 & 使用区别

• &&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
  
• & 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
  
• 开发中， 我们使用的基本是使用短路与&&, 效率高
  

1.4.6 || 和 | 基本规则

名称             语法                                       特点
短路或||     条件1 && 条件2   当两个中有一个为true，则结果为true，否则为false。如果条件1为true，则不判断条件2，结果为true
逻辑或|      条件1 & 条件2    当两个中有一个为true，则结果为true，否则为false.如果条件1为true，继续判断条件2，结果为true
1.4.7 || 和 | 案例演示

1. public class LogicOperator02 {
2.     public static void main(String[] args) {
3.         // ||短路或 和 |逻辑或 演示
4.         /*
5.              ||短路或: 两个条件中只要有一个成立，结果为 true,否则为 false
6.              |逻辑或: 两个条件中只要有一个成立，结果为 true,否则为 false
7.          */
8.         int age = 50;
9.         if(age > 20 || age < 30) {
10.             System.out.println("ok100");
11.         }
12.         //&逻辑与使用
13.         if(age > 20 | age < 30) {
14.             System.out.println("ok200");
15.         }
16.         //区别
17.         int a = 4;
18.         int b = 9;
19.         //对于||短路或而言，如果第一个条件为 true ,后面的条件不再判断
20.         //对于|逻辑或而言，如果第一个条件为 true ,后面的条件仍然会判断
21.         if( a > 1 || ++b > 4) {
22.             // 可以换成 | 测试
23.             System.out.println("ok300");
24.         }
25.         System.out.println("a=" + a + " b=" + b); //4 9
27.     }
28. }

复制代码

1.4.8 || 和 | 使用区别

• ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
  
• | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
  
• 开发中，我们基本使用 ||
  

1.4.8 ! 取反基本规则

名称            语法                   特点
! 非（取反）      ! 条件     如果条件本身成立，结果为 false，否则为 true
1.4.9 ! 案例演示

1. public class InverseOperator {
2.     public static void main(String[] args) {
3.         // ! 操作是取反  T->F  F->T
4.         System.out.println(60 > 20); //T
5.         System.out.println(!(60 > 20)); //F
7.         // a^b:逻辑异或，当a和b不同时，则结果为true,否则为false
8.         boolean b = (10 > 1) ^ ( 3 > 5);
9.         System.out.println("b=" + b); //T
10.     }
11. }

复制代码

1.4.10 ^ 基本规则

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false
^逻辑异或，System.out.println( (4 < 1) ^ (6 > 3) );
1.4.11 练习题 写出输出结果

• 
  

1.         int x = 5;
2.         int y = 5;
3.         if(x++ == 6 & ++y == 6){ //①
4.             x = 11;  //②
5.         }
6.         System.out.println("x=" + x + "y=" + y);// x=6,y=6

复制代码

讲解：
​     在程序执行到①的时候，x++是后++，x先与6进行比较，结果为false,x加1之后x=6。
​     逻辑与第一个为false还要继续判断第二个条件。++y是先++，y先加1之后y=6,y与6进行判断，结果为true。
​     false & true 结果为false,不执行if语句里面的内容。

• 
  

1.         int x = 5;
2.         int y = 5;
3.         if(x++ == 6 && ++y == 6){ //①
4.             x = 11; //②
5.         }
6.         System.out.println("x=" + x + "y=" + y);// x=6,y=5

复制代码

讲解：
​     在程序执行到①的时候，x++是后++，x先与6进行比较，结果为false,x加1之后x=6。
​     短路与第一个条件为false,不用判断第二个条件，y没有进行自加操作y=5。

• 
  

1.         int x = 5;
2.         int y = 5;
3.         if(x++ == 5 | ++y == 5){ //①
4.             x = 11; //②
5.         }
6.         System.out.println("x=" + x + "y=" + y);// x=11,y=6

复制代码

讲解：
​     在程序执行到①的时候，x++是后++，x先与5进行比较，结果为true,x加1之后x=6。
​     逻辑或第一个为true还要继续判断第二个条件。++y是先++，y先加1之后y=6,y与5进行判断，结果为false。
​     true | false 结果为true,执行if语句里面的内容②，x=11。

• 
  

1.         int x = 5;
2.         int y = 5;
3.         if(x++ == 5 || ++y == 5){ //①
4.             x = 11; //②
5.         }
6.         System.out.println("x=" + x + "y=" + y);// x=11,y=5

复制代码

讲解：
​     在程序执行到①的时候，x++是后++，x先与5进行比较，结果为true,x加1之后x=6。
​     短路或第一个为true不需要继续判断第二个条件。
​     执行if语句里面的内容②，x=11。y没有进行自加操作y=5。

• 
  

1.         boolean x = true;
2.         boolean y = false;
3.         short z = 46;
4.         if((z++ == 46) && (y = true)) z++;  //①
5.         if((x = false) || (++z == 49)) z++;  //②
6.         System.out.println("z=" + z);  //z=50

复制代码

讲解：
​     在程序执行到①的时候，z++是后++，z先与46进行比较，结果为true，z加1之后z=47，判断条件二，y被赋值为true。执行z++操作,z=48.
​     在程序执行到②的时候，x=false为false,继续判断第二个条件,++z是先++，z加1之后z=49。然后再执行z++操作，z=50.
1.5 赋值运算符

1.5.1介绍

赋值运算符就是将某个运算后的值，赋给指定的变量
1.5.2 赋值运算符的分类

• 基本赋值运算符 =：int a = 10;
  
• 复合赋值运算符
  +=，-=，*=，/=，%= 等
  举例说明：
  a += b;    a = a + b;
  a -= b;    a = a - b;
  

1.5.3 赋值运算符的特点

1）运算顺序从右往左  int num = a + b + c;
2）赋值运算符的左边 只能是变量，右边可以是变量、表达式、常量
3）复合赋值运算符等价于下面的效果
a += 3 等价于 a = a + 3;
4）复合赋值运算符会进行类型转换

1.   byte b = 3;
2.   b += 2; // 等价于 b = (byte)(b + 2);  如果直接写成b=b+1,编译会报错
3.   b++; // b = (byte)(b + 1);

复制代码

1.6 三元运算符

1.6.1 基本语法

条件表达式 ? 表达式1 : 表达式2;
运算规则：
1）如果条件表达式为true,运算后的结果是表达式1；
2）如果条件表达式为false,运算后的结果是表达式2；
1.6.2 使用细节

• 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
  
• 三元运算符可以转成 if--else 语句
  

​    int res = a > b ? a++ : --b;
​    可以转换成：
​    if(a > b) res = a++;
​    else res = --b;

1. public class TernaryOperator {
2.     public static void main(String[] args) {
3.         //表达式 1 和表达式 2 要为可以赋给接收变量的类型 //(或可以自动转换/或者强制转换)
4.         int a = 3;
5.         int b = 8;
6.         int c = a > b ? (int)1.1 : (int)3.4;//可以
7.         double d = a > b ? a : b + 3;//可以，满足 int -> double
8.     }
9. }

复制代码

1.7 运算符的优先级


可以记住口诀：后单四移关，等位逻三赋
单目运算符，四则运算符，移位运算符，关系运算符，等值运算符，位运算符，逻辑运算符，三目运算符，赋值运算符