Java基础语法——运算符

运算符

1. 概述

• 运算符：对常量或者变量进行操作的符号
• 表达式：用运算符把常量或者变量连接起来符合java语法的式子

int a = b + c;
// + 是运算符  b + c 是表达式

2. 算术运算符

2.1 符号 & 作用

符号	作用
+	加
-	减
*	乘
/	处
%	取余

2.2 注意点

• 算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升

• char类型参与数据算数运算，使用的是计算机底层对应的十进制数值，需要记住三个字符对应的数值

  • ‘a’ —— 97 ：a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
  • ‘A’ —— 65 ：A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
  • ‘0’ —— 48：0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

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

  System.out.println("123" + 1) //输出 1231
  // " " 在前 直接j
  System.out.println("123" + 2 + 3)//输出12323
  // " " 在后 先进行 2+3 的运算，再与字符串拼接
  System.out.println(2 + 3 + "123");//输出5132
  

2.3 代码示例

public class Demo01 {
    public static void main(String[] args) {
        // 二元运算符
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b); // 30
        System.out.println(a-b); // -10
        System.out.println(a*b); // 200
        /*因为a和b都是int类型 所以在做除法时计算出来的结果仍然是int类型，
        会导致精度丢失，如果这里不进行类型转换，所输出的结果为 0 */
        System.out.println(a/(double)b); // 0.5 注意除法或产生小数
        System.out.println(c%a); // 5 模运算  取余
    }
}

public class Demo02 {
    public static void main(String[] args) {
    //算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升 ★
        long a = 123456456465L;
        int b = 123;
        short c = 10;
        byte d = 8;

        /*
        abcd相加，a是Long类型，容量比其他类型大，
        所以输出结果也是Long类型。同理...
         */
        System.out.println(a+b+c+d); //123456456606 Long类型
        System.out.println(b+c+d); //141 Int类型
        System.out.println(c+d); //18 Int类型
    }
}

3. 赋值运算符

3.1 符号 & 作用

符号	作用
=	赋值	a = b 将"="右边的值赋值给左边
+=	加后赋值	a += b --> a = a + b
-=	减后赋值	a -= b --> a = a - b
*=	乘后赋值	a *= b --> a = a * b
/=	除后赋值	a /= b --> a = a / b
%=	取余后赋值	a %= b --> a = a % b

3.2 注意点

• “=” 左边必须是可修改的，不能是常量

• 除了 “=” ,其他都是扩展的运算符

• 扩展的运算符隐含了强制类型转换

  short a = 1;
  //a = a +10; 报错，因为10是整数，默认为int类型，运算结果为int赋值给short可能损失精度
  a += 10; //不会报错，因为隐含了强制转换，等同于a = (short)(a+10)
  

4. 自增自减运算符

4.1 符号 & 作用 & 说明

符号	作用	说明
++	自增	变量的值加一
–	自减	变量的值减一

4.2 注意点

• 符号既可以在变量后，也可以在变量前

  a++     或 ++a
  

• 在单独使用时，符号位于变量前后的结果是相同的

• 参与操作时

  • a++ 即先拿变量参与操作，再进行++
  • ++a 即先进行++，再拿变量参与操作

4.3 代码示例

单独使用
int a = 10;
a++;
System.out.println(a); // 11

//参与操作
public class Demo04 {
    public static void main(String[] args) {
        // ++ 自增  --  自减  一元运算符
        int a = 3;

        int b = a++; //执行完这行代码后，先给b赋值，再自增
        // a++  a = a + 1

        System.out.println(a); // 4
        int c = ++a; // 先进行a = a + 1,在将运算后a的值赋值给c

        System.out.println(a); // 5
        System.out.println(b); // 3
        System.out.println(c); // 5

        //幂运算 2^3 2*2*2 = 8 很多运算会使用一些工具类来操作！
        double pow = Math.pow(2,3);
        System.out.println(pow); //8.0
    }
}

5. 关系运算符

5.1 符号 & 说明

符号	说明
==	a==b 判断a与b的值是否相等，成立为true，不成立为false
!=	a！=b 判断a与b的值是否不相等，成立为true，不成立为false
>	a>b 判断a的值是否大于b，成立为true，不成立为false
>=	a>=b 判断a的值是否大于等于b，成立为true，不成立为false
<	a<b 判断a的值是否小于b，成立为true，不成立为false
<=	a<=b 判断a的值是否小于等于b，成立为true，不成立为false

5.2 注意事项

• 关系运算符的结果都是boolean类型，只有两个结果，true和false
• “=” 和 “==” 是两种运算符是不一样的作用，一个是赋值，一个是判断是否相等

5.3 代码示例

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  布尔值
        //常与if一起使用

        int a = 10;
        int b = 20;

        System.out.println(a>b); //false
        System.out.println(a<b); //true
        System.out.println(a==b); //false
        System.out.println(a!=b); //true
    }
}

6. 逻辑运算符 & 短路逻辑运算符

6.1 概述

• 逻辑运算符把各个运算的关系表达式连接在一起组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 和 false

6.2 逻辑运算符

6.2.1 符号 & 作用 & 说明

符号	作用	说明
&	逻辑与	a&b ：a，b都是true，结果为true，否则false<有假即假>
|	逻辑或	a|b ：a，b都是false，结果为false，否则true<有真即真>
^	逻辑异或	a^b ：a,b的结果不同为true，相同为false
!	逻辑非	!a ：结果和a的结果正好相反

6.2.2 代码示例

public class Demo05 {
    public static void main(String[] args) {
        // 与(and)  或(or)  非(取反)
        boolean a = true;
        boolean b = false;
        
        System.out.println("a&b:"+(a & b)); //false 有一个值为假，结果就为假
        System.out.println("a|b:"+(a | b)); //true 有一个值为真，结果就为真
        System.out.println("!a:"+(!a)); //false 结果相反
    }
}

6.3 短路逻辑运算符

6.3.1 符号 & 作用

符号	作用
&&	短路与
||	短路或

6.3.2 代码示例

public class Demo05 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;

        System.out.println((a>b) && (a<b)); //false 因为 a>b 为false 所以 a<b不会运行，直接返回判定结果false
        System.out.println((a<b) || (a>b)); //true 因为 a<b 为true 所以 a>b不会运行，直接返回判定结果true
    }
}

6.4 区别

• 在编写代码的过程中通常使用 && 和 || 运算符进行运算

&（| 同理）	&&（|| 同理）
无论左边的表达式是否为false，右边的表达式都要运算	如果左边的表达式为false，则右边的表达式不会进行运算，直接返回判定结果false

7. 三元运算符

7.1 语法

关系表达式 ? 表达式1 : 表达式2

7.2 说明

• 如果关系表达式判定结果为true，则调用表达式1
• 如果关系表达式判定结果为false，则调用表达式2

7.3 代码示例

public class Demo {
    public static void main(String[] args) {
       int a = 1;
       int b = 2;
       //  x ? y : z
       //如果x==true,则结果为y，否则结果为z
       int c = a>b ? a+b : b-a; //a>b -- false 进行b-a
       System.out.println(c);

        int d = a<b ? a+b : b-a;
        System.out.println(d); //a<b -- true 进行a+b
    }
}

public class Demo08 {
    public static void main(String[] args) {
        //  x ? y : z
        //如果x==true,则结果为y，否则结果为z

        int score = 50;
        String type = score < 60 ?"不及格":"及格";
        System.out.println(type); // 不及格
    }
}

8. 二进制的运算<代码示例>

//位运算
public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

      A&B = 0000 1100 有0则为0
      A|B = 0011 1101 有1则为1
      A^B = 0011 0001 相同为0，不同为1
       -B = 1111 0010

    2*8怎么运算最快
    2*8 = 16 2*2*2*2
    效率极高
    <<  左移 *2
    >>  右移 /2

    0000 0000    0
    0000 0001    1
    0000 0010    2
    0000 0011    3
    0000 0100    4
    0000 1000    8
    0001 0000    16
     */
        System.out.println(2<<3); //16

    }
}