文章目录

• 运算符
• 分类：
• 2.1.算术运算符
• 2.1.1基本算数运算
• 2.1.2 复合算数运算
• 2.1.3 类型转换
• 2.1.4 “+”的三种情况
• 2.2 自增自减运算符
• 2.3 赋值运算符
• 2.4 关系运算符
• 2.5 逻辑运算符
• 2.6短路逻辑运算符
• 2.7三元运算符
• 2.8运算的优先级

运算符

分类：

赋值运算符：=

算术运算符： + - * / % ++ – += -= /= %=

关系运算符：> < == >= <= != (也叫 比较运算符)

逻辑运算符：&& | | !

三元运算符： __ ?__ : __;

2.1.算术运算符

2.1.1基本算数运算

package code02.demo01;
public class test01 {
    public static void main(String[] args) {
        System.out.println(3 + 2);//5
        System.out.println(5 - 1);//4
        //* (shift + 数字8)
        System.out.println(7 * 9);//63
      
     //如果在计算的时候有小数参与
    //在代码中，如果有小数参与计算，结果有可能不精确的。
    System.out.println(1.1 + 1.1);//2.2
    System.out.println(1.1 + 1.01);//2.1100000000000003
    System.out.println(1.1 - 1.01);
    System.out.println(1.1 * 1.01);
      
    //====================================
      
      //1.整数参与计算，结果只能得到整数
    //2.小数参与计算，结果有可能是不精确的，如果我们需要精确计算，那么需要用到后面的知识点。
    public static void main(String[] args) {
        //除法
        System.out.println(10 / 2);//5
        System.out.println(10 / 3);//3
        System.out.println(10.0 / 3);//3.3333333333333335
      
      
    //取模，取余。实际上也是做除法运算，只不过得到的是余数而已。
    System.out.println(10 % 2);//0
    System.out.println(10 % 3);//1
    }
}

2.1.2 复合算数运算

2.1.3 类型转换

取值范围由小到大为：
byte < short < int < long < float < double

隐式转换：

• （自动类型提升）取值范围小的转成取值范围大的

• byte short char 三种类型的数据在运算的时候，会直接先提升为int然后在运算

  int i =10;
  long n =100L;
  double d = 20.0;
   double result = i+n+d;//i+n自动转成long类型，然后long类型与d运算转成double类型
  ===========================================
    byte b = 10;
  	short s = 20;
  	long n = 100L;
  // b和S先自动转成int,然后运算结果与long运算得long类型
  	long result = b+s+n;
  
  

强制转换：

• 取值范围大的转成取值范围小的；

  public class demo3 {
      public static void main(String[] args) {
          byte b1 = 10;
          byte b2 = 20;
          //现在我们要强转的是谁？
          //b1 + b2计算之后的结果。
          // (byte)b1 + b2 强转的是b1，并不是最终的结果
          byte result = (byte)(b1 + b2);
          System.out.println(result);//30
      }
  }
  

2.1.4 “+”的三种情况

数字相加

• 数字进行运算时，数据类型不一样不能运算，需要转成一样的 才能运算。

字符串相加

• 当“+”操作中出现字符串时，此时+ 是字符串连接符，而不是运算符

  "123"+123    //"123123"
   1+2+"你好"   // "3你好"
  

2.2 自增自减运算符

注意事项

public class Test05 {
    public static void main(String[] args) {
       int a = 10;
       int b = a++; //先用后加
        System.out.println(a);// 11
        System.out.println(b);//  10
    }

}


====================================================
  public class Test05 {
    public static void main(String[] args) {
       int a = 10;
       int b = ++a; // 先加后用
        System.out.println(a);// 11
        System.out.println(b);//  11
    }

}

public class Test05 {
    public static void main(String[] args) {
        int x = 10;
        //后++：先用后加
        //先把x变量中的值拿出来用，赋值给y，然后再进行自增。
        //赋值给y的值是自增前的。
        int y = x++;// x = 11  y = 10
        //先++：先加后用
        //先把x进行自增，然后把自增后的结果赋值给左边的变量
        //先把x自增，变成12，然后再把自增之后的12赋值给z
        int z = ++x;//x = 12 z = 12
        System.out.println("x:" + x);//12
        System.out.println("y:" + y);//10
        System.out.println("z:" + z);//12
    }

}

2.3 赋值运算符

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

2.4 关系运算符

• 关系运算符也称比较运算符

• 关系运算符的结果都是boolean类型，要么是true 要么是 false

2.5 逻辑运算符

        // & 并且
        // 两边都为真，结果才是真
        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(false & false);//false
        System.out.println(false & true);//false
        
        //  |  或者
        //两边都是假，结果才为假
        System.out.println(false |false);//false
        System.out.println(false | true);// true
        System.out.println(true | false);//true
        System.out.println(true | true);//ture

        // ^ 异或
        // 相同为false ,不同为true
        System.out.println(false ^ false);//false
        System.out.println(true ^ true);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true

        // ! 逻辑非 ，取反
        System.out.println(!true);//false
        System.out.println(!false);//true

2.6短路逻辑运算符

• & |无论左边true 还是false ,右边都执行
• && ||如果左边能确定整个表达式的结果，右边不执行
• &&左边为false,右边不管真假，整个表达式的结果一定是false，即右边不会执行
• ||左边为true 右边不管真假，整个表达式的结果一定是true,即右边不会执行

        // && 短路与， 运行结果跟单个&一样
        //两边结果都为真，结果才为真
        System.out.println(true && true);//true
        System.out.println(false && true);//false
        System.out.println(true && false);//false
        System.out.println(false && false);//false

        // || 短路或 ，运行结果和单个 | 一样
        // 两边结果都为假 结果才是假
        System.out.println(false||false);//false
        System.out.println(false|| true);// true
        System.out.println(true||false);//true
        System.out.println(true||true);//ture

        // 短路逻辑运算符具有短路效果，
     //可以理解为：当左边的表达式能最终确定结果，右边的表达式就不在执行
        int a = 10;
        int b = 10;
        boolean res = ++a < 5 && ++b<5;
        System.out.println(res);//false
        System.out.println(a);//11
        System.out.println(b);//10;如果&&改为& ,b输出为11

2.7三元运算符

格式：关系表达式？表达式1：表达式2；

• 首先计算关系表达式的值，
• 如果值为true，表达式1的值就是运算结果
• 如果值为false,表达式2 的值就是运算结果

 // 输出两个数的最大值
        int number = 10;
        int number2 = 20;
        int max = number>number2?number:number2;
        System.out.println(max);
-----------------------------------------------------------
       // 输出三个数的最大值
        int a = 165;
        int b = 212;
        int c = 150;
        // temp为临时变量  ctrl+alt+l:自动格式代码
        int temp = a > b ? a : b;
        int res = temp > c ? temp : c;
        System.out.println(res);

2.8运算的优先级

（）小括号优先所有