运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

  • 算术运算符

  • 赋值运算符

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

  • 逻辑运算符

  • 位运算符

  • 三元运算符

算术运算符

  1. class AriTest{
  2.     public static void main(String[] args){
  3.         //除号
  4.         int num1 = 12;
  5.         int num2 = 5;
  6.         int result1 = num1/num2;
  7.         System.out.println(result1);//2
  9.         int result2 = num1 / num2 * num2;
  10.         System.out.println(result2);//10
  12.         double result3 = num1 / num2;//先运算为int型，值为2，在自动转换成double
  13.         System.out.println(result3);//2.0
  15.         double result4 = num1 / num2 + 0.0;//2.0
  16.         double result5 = num1 / (num2 + 0.0);//2.4
  17.         double result6 = (double)num1 / num2;//2.4
  18.         double result7 = (double)(num1 / num2);//2.0
  19.         System.out.println(result5);
  20.         System.out.println(result6);
  22.         //%取余运算
  23.         //结果的符号与被模数的符号相同，被模数是12或-12
  24.         //开发中经常使用%来判断能否被除尽的情况
  25.         int m1 = 12;
  26.         int n1 = 5;
  27.         System.out.println("m1 % n1 = " + m1 % n1);//2
  29.         int m2 = -12;
  30.         int n2 = 5;
  31.         System.out.println("m2 % n2 = " + m2 % n2);//-2
  33.         int m3 = 12;
  34.         int n3 = -5;
  35.         System.out.println("m3 % n3 = " + m3 % n3);//2
  37.         int m4 = -12;
  38.         int n4 = -5;
  39.         System.out.println("m4 % n4 = " + m4 % n4);//-2
  41.         //++(A)：先自增1，后运算
  42.         //(A)++：先运算，后自增1
  43.         int a1 = 10;
  44.         int b1 = ++a1;
  45.         System.out.println("a1= " + a1 + ",b1 = " + b1);//11 11
  47.         int a2 = 10;
  48.         int b2 = a2++;
  49.         System.out.println("a2= " + a2 + ",b2 = " + b2);//11 10
  51.         //注意点
  52.         short s1 = 10;
  53.         //s1 = s1 + 1;//编译失败
  54.         //s1 = (short)(s1 + 1 );//正确的
  55.         s1++;//自增1不会改变变量类型
  56.         System.out.println(s1);
  58.         //问题
  59.         byte bb1 = 127;
  60.         bb1++;
  61.         System.out.println("bb1 = " + bb1);
  63.         //(前)--:先自减1，后运算
  64.         //(后)--：先运算，后自减1
  65.     }
  66. }

赋值运算符

符号：=

  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理

  • 支持连续赋值

  • 扩展赋值运算符： +=, -=, *=, /=, %=

    1. /*
    2. 运算符之二： 赋值运算符
    3. = += -= *= /= %=
    4. */
    5. class SetValueTest {
    6.   public static void main(String[] args) {
    7.       //赋值符号： =
    8.       int i1 = 10;
    9.       int j1 = 10; 
    11.       //连续赋值
    12.       int i2,j2;
    13.       i2 = j2 = 10;
    15.       int i3 = 10,j3 = 20; 
    17.       //***************
    18.       int num1 = 10;
    19.       num1 += 2;//num1 = num1 + 2;
    20.       System.out.println(num1);//12
    22.       int num2 = 10;
    23.       num2 %= 5;//num2 = num2 % 5;
    24.       System.out.println(num2);//0
    26.       short s1 = 10;
    27.       //s1 = s1 + 2;//编译失败
    28.       s1 += 2;//不会改变变量本身的数据类型
    29.       System.out.println(s1);
    31.       //开发中,如果希望变量实现+2的操作，有几种方法？(前提int num = 10;)
    32.       //方式1： num = num + 1;
    33.       //方式2：num += 2;(推荐)
    35.       //开发中,如果希望变量实现+1的操作，有几种方法？(前提int num = 10;)
    36.       //方式1： num = num + 1;
    37.       //方式2：num += 1;
    38.       //方式3：num ++;（推荐）
    40.       //练习1
    41.       int i = 1;
    42.       i *= 0.1;//不改变数据类型
    43.       System.out.println(i);//0
    44.       i++;
    45.       System.out.println(i);//1
    47.       //练习2
    48.       int m = 2;
    49.       int n = 3;
    50.       n *= m++;//n = n * m++;
    51.       System.out.println("m=" + m);//3
    52.       System.out.println("n=" + n);//6
    54.       //练习3
    55.       int n3 = 10;
    56.       n3 += (n3++) + (++n3);//n3 = n3 + (n3++) + (++n3);
    57.       System.out.println(n3);//32
    59.   }
    60. }

比较运算符

  • 比较运算符的结果都是boolean型，也就是要么是true，要么是false。

  • 比较运算符“==”不能误写成“=” 。

    • 1.> < >= <=:只能使用在数值类型的数据之间

    • == 和 !=：不仅可以使用在数值类型的数据之间，还可以使用在其他引用类型变量之间

      1. Account acct1 = new Account(1000);
      2. Account acct2 = new Account(1000);
      3. acct1 == acct2;//比较两个Account是否是同一个账户
      4. boolean b2 = (acct1 != acct2);//
  1. /*
  2. 运算符之三：比较运算符
  3. == ！= > < >= <= instanceof
  4. 结论：
  5. 1.比较运算符的结果是boolean类型
  6. 2.区分 == 和 =
  7.  */
  8. class CompareTest {
  9.     public static void main(String[] args) {
  10.         int i = 10;
  11.         int j = 20;
  13.         System.out.println(i == j);//false
  14.         System.out.println(i = j);//20
  16.         boolean b1 =  true;
  17.         boolean b2 = false;
  18.         System.out.println(b2 == b1);//false
  19.         System.out.println(b2 = b1);//true
  21.     }
  22. }

逻辑运算符

  • &—逻辑与 | —逻辑或 ！—逻辑非 && —短路与 || —短路或 ^ —逻辑异或

  • 逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 & x<6 。

  • “&”和“&&”的区别：

    • 单&时，左边无论真假，右边都进行运算；

    • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
      “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
      理解：异或，追求的是“异”!

  1. class  LogicTest {
  2.     public static void main(String[] args) {
  4.         //& 和 &&
  5.         //相同点1：& 与 && 的运算结果相同
  6.         //相同点2：当符号左边是true时，二者都会执行符号右边的运算
  7.         //不同点3：当符号左边是false时，&继续执行符号右边的运算。&&不在执行(短路)
  8.         //推荐使用&&
  9.         boolean b1 = false;
  10.         int num1 = 10;
  11.         if(b1 & (num1++ > 0)){
  12.             System.out.println("我现在在北京");
  13.         }else {
  14.             System.out.println("我现在在南京");
  15.         }
  17.         System.out.println("num1 = " + num1);
  19.         boolean b2 = false;
  20.         int num2 = 10;
  21.         if(b2 && (num2++ > 0)){
  22.             System.out.println("我现在在北京");
  23.         }else {
  24.             System.out.println("我现在在南京");
  25.         }
  27.         System.out.println("num2 = " + num2);
  29.         //区分： |与||
  30.         //相同点1：& 与 && 的运算结果相同
  31.         //相同点2：当符号左边是false时，二者都会执行符号右边的运算
  32.         //不同点3：当符号左边是true时，|继续执行符号右边的运算。||不在执行(短路)
  33.         //推荐使用||
  34.         boolean b1 = false;
  35.         boolean b3 = false;
  36.         b3 = true;
  37.         int num3 = 10;
  38.         if(b3 || (num3++ > 0)){
  39.             System.out.println("我现在在北京");
  40.         }else {
  41.             System.out.println("我现在在南京");
  42.         }
  44.         System.out.println("num3 = " + num3);
  46.         boolean b4 = false;
  47.         b4 = true;
  48.         int num4 = 10;
  49.         if(b4 | (num4++ > 0)){
  50.             System.out.println("我现在在北京");
  51.         }else {
  52.             System.out.println("我现在在南京");
  53.         }
  55.         System.out.println("num4 = " + num4);
  56.     }
  57. }

特别说明：

  • 逻辑运算符操作的都是boolean类型的变量，而且结果也是boolean类型

位运算符

运算符之五：位运算符（了解）

结论：

  1. 位运算符操作的都是整型的数据
  2. <<:在一定范围内，每向左移1位，相当于*2;
    <<:在一定范围内，每向右移1位，相当于/2;

面试题：最高效的方式计算2*8？ 2 << 3 或 8 <<1

  1. /*
  2. 运算符之五：位运算符（了解）
  4. 结论：
  5. 1.位运算符操作的都是整型的数据
  6. 2.<<:在一定范围内，每向左移1位，相当于*2;
  7.   <<:在一定范围内，每向右移1位，相当于/2;
  9.  面试题：最高效的方式计算2*8？ 2 << 3 或 8 <<1
  10. */
  11. class  BitTest {
  12.     public static void main(String[] args) {
  13.         int i = 21;
  14.         i = -21;
  15.         System.out.println("i << 2 :" + (i << 2));
  16.         System.out.println("i << 3 :" + (i << 3));
  18.         //练习:交换两个变量的值
  19.         int num1 = 10;
  20.         int num2 = 20;
  22.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  24.         //方式一：定义临时变量的方式
  25.         //int temp = num1;
  26.         //num1 = num2;
  27.         //num2 = temp;
  30.         //方式二：好处：不用定义临时变量
  31.         //弊端：1.相加操作可能超出存储范围 2.有局限性，只能适用于数值类型
  32.         //num1 = num1 + num2;//和
  33.         //num2 = num1 - num2;//原来num1的值
  34.         //num1 = num1 - num2;//和 - 原来num1的值
  36.         //方式三：使用位运算符
  37.         //2.有局限性，只能适用于数值类型
  38.         num1 = num1 ^ num2;
  39.         num2 = num1 ^ num2;//原来num1的值
  40.         num1 = num1 ^ num2;
  42.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  43.     }
  44. }

三元运算符

运算符之六：三元运算符

  1. 结构：(条件表达式)？表达式1：表达式2

  2. 说明

    • 条件表达式的结果为boolean类型
    • 根据条件表达式的真或假，决定执行表达式1，还是表达式2
      如果表达式为true，则执行表达式1
      如果表达式为false，则执行表达式2
    • 表达式1和表达式2要求是一致的
    • 三元运算符可以嵌套使用

  3. 凡是可以使用三元运算符的地方，都可以改写成if-else，反之，不成立

  4. 如果程序既可以使用三元运算符又可以使用if-else语句，使用三元运算符，执行效率高，简洁

  1. /*
  2. 运算符之六：三元运算符
  3. 1.结构：(条件表达式)？表达式1：表达式2
  5. 2.说明
  6. ①条件表达式的结果为boolean类型
  7. ②根据条件表达式的真或假，决定执行表达式1，还是表达式2
  8.     如果表达式为true，则执行表达式1
  9.     如果表达式为false，则执行表达式2
  10. ③表达式1和表达式2要求是一致的
  11. ④三元运算符可以嵌套使用
  13. 3.
  14. 凡是可以使用三元运算符的地方，都可以改写成if-else
  15. 反之，不成立
  17. 4.如果程序既可以使用三元运算符又可以使用if-else语句，使用三元运算符，执行效率高，简洁
  18. */
  19. class SanYuanTest {
  20.     public static void main(String[] args) {
  21.         //获取两个整数的较大值
  22.         int m = 12;
  23.         int n = 5;
  25.         int max = (m > n)?m : n;
  26.         System.out.println(max);
  28.         double num = (m > n)?2 : 1.0;
  29.         //表达式1和表达式2没有统一类型，编译错误
  30.         //(m > n)? 2 : "n大";
  32.         //***********************
  33.         String maxStr = (m > n)? "m大" : "n大";
  34.         String maxStr1 = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
  35.         System.out.println(maxStr);
  37.         //***********************
  38.         //获取三个数的最大值
  39.         int n1 = 12;
  40.         int n2 = 30;
  41.         int n3 = -42; 
  43.         int max1 = (n1 > n2)? n1 : n2;
  44.         int max2 = (n3 > max1)? n3 : max1;
  45.         System.out.println("三个数的最大值为：" + max2);
  46.     }
  47. }