运算符和表达式

6. 运算符和表达式

在Java中，运算符用于执行各种数学、逻辑和位运算操作，而表达式则是由运算符、操作数和操作符组成的结构，可以用来完成特定的计算和逻辑操作。

6.1运算符

6.1.1.算术运算符

算术运算符：

• 加法运算符：+
• 减法运算符：-
• 乘法运算符：*
• 除法运算符：/
• 取余运算符（求模运算）：%
• 自增运算符：++
• 自减运算符：–

+ - * / %  这些操作跟小学数学几乎是一模一样的。

注意点：

• / 和 % 的区别：他们两个都是做除法运算，/取结果的商。% 取结果的余数。
• 整数操作只能得到整数，如果想要得到小数，必须有浮点数参与运算。

6.1.1.1 自增自减运算符

分类：

++  自增运算符
--  自减运算符

++：就是把变量里面的值+1

--：就是把变量里面的值-1

使用方式：

• 放在变量的前面，我们叫做先++。 比如：++a
• 放在变量的后面，我们叫做后++。 比如：a++

注意点：

? 不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。

例如：

//++
int a = 10;
a++;//就是让变量a里面的值 + 1
System.out.println(a);//11
++a;//就是让变量a里面的值 + 1
System.out.println(a);//12

6.1.2 赋值运算符

最为常用的： =

运算过程：就是把等号右边的结果赋值给左边的变量

案例：

public class OperatorDemo6 {
    public static void main(String[] args) {
        //1.最为简单的赋值运算符用法
        int a = 10;//就是把10赋值给变量a
        System.out.println(a);

        //2.如果等号右边需要进行计算。
        int b = 20;
        int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(c);

        //3.特殊的用法
        a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(a);//20
    }
}

6.1.2.1 扩展赋值运算符

分类：+=、-=、*=、/=、%=

赋值运算符：

• 简单赋值运算符：=
• 加法赋值运算符：+=
• 减法赋值运算符：-=
• 乘法赋值运算符：*=
• 除法赋值运算符：/=
• 取余赋值运算符：%=
• 位运算赋值运算符：&=、|=、^=、>>=、<<=、>>>=

运算规则：

? 就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

例如：

public class OperatorDemo7 {
    public static void main(String[] args) {
        //扩展赋值运算符
        int a = 10;
        int b = 20;
        a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响
        // 相当于 a = a + b;
        System.out.println(a);//30
        System.out.println(b);//20
    }
}

注意点：扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

a += b ;实际上相当于 a = (byte)(a + b);

public class OperatorDemo8 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        //a += b;
        a = (byte)(a + b);
        System.out.println(a);//30
    }
}

6.1.3 关系运算符

又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。

关系运算符：

• 相等运算符：==
• 不等运算符：!=
• 大于运算符：>
• 小于运算符：<
• 大于等于运算符：>=
• 小于等于运算符：<=

符号	解释
==	就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false
!=	就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false
>	就是判断左边是否大于右边，如果成立就是true，如果不成立就是false
>=	就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false
<	就是判断左边是否小于右边，如果成立就是true，如果不成立就是false
<=	就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false

注意点：

• 关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
• 在写==的时候，千万不要写成=

6.1.4 逻辑运算符

逻辑运算符：

• 逻辑与运算符：&&
• 逻辑或运算符：||
• 逻辑非运算符：!

6.1.4.1 & 和 | 的使用

&：逻辑与（而且）

• 两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者）

• 两边都为假，结果才是假，只要有一个为真，那么结果就是真。

代码示例：

// &  //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false

System.out.println("===================================");

// | 或  //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true

6.1.4.2 ^（异或）的使用

计算规则：如果两边相同，结果为false，如果两边不同，结果为true

代码示例：

//^   //左右不相同，结果才是true，左右相同结果就是false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true

6.1.4.3 !（取反）的使用

是取反，也叫做非。

计算规则：false取反就是true，true取反就是false

温馨提示：**取反最多只用一个。**

代码示例：

System.out.println(!false);//true
System.out.println(!true);//false

System.out.println(!!false);//注意点：取反最多只用一个。

6.1.5 短路逻辑运算符

分类：

• &&
• ||

6.1.5.1 &&

运算结果跟&是一模一样的，只不过具有短路效果。

6.1.5.2 ||

运算结果跟|是一模一样的。只不过具有短路效果。

6.1.5.3 逻辑核心

• 当左边不能确定整个表达式的结果，右边才会执行。
• 当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。

6.1.5.4 总结

? && 和 & 、||和|的运行结果都是一模一样的。

? 但是短路逻辑运算符可以提高程序的运行效率。

最为常用： &&   ||   ！

6.1.6 三元运算符

又叫做：三元表达式或者问号冒号表达式。

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

计算规则：

• 计算关系表达式的值。

• 如果关系表达式的值为真，那么执行表达式1。

• 如果关系表达式的值为假，那么执行表达式2。

    注意点：三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。
  

例如：

public class OperatorDemo12 {
    public static void main(String[] args) {
        //需求：求两个数的较大值
        int a = 10;
        int b = 20;

        //格式：关系表达式 ？ 表达式1 ： 表达式2 ；
        //注意点：
        //三元运算符的最终结果一定要被使用。
        //要么赋值给一个变量，要么直接输出。
       int max =  a > b ? a : b ;
        System.out.println(max);


        System.out.println(a > b ? a : b);
    }
}

6.1.7 位运算符

位运算符：

• 与运算符：&
• 或运算符：|
• 异或运算符：^
• 左移运算符：<<
• 右移运算符：>>
• 无符号右移运算符：>>>

位运算符是一种用于对操作数的二进制位进行操作的运算符。

在Java中，位运算符可以用于整数类型（byte、short、int、long）和char类型的操作数。

下面介绍常见的位运算符：

1. 按位与运算符（&）：

   对操作数的每个二进制位进行逻辑与运算，如果两个操作数对应位都为1，则结果为1，否则为0。

2. 按位或运算符（|）：

   对操作数的每个二进制位进行逻辑或运算，如果两个操作数对应位至少有一个为1，则结果为1，否则为0。

3. 按位异或运算符（^）：

   对操作数的每个二进制位进行逻辑异或运算，如果两个操作数对应位不相同，则结果为1，否则为0。

4. 取反运算符（~）：

   对操作数的每个二进制位进行逻辑非运算，将每个1变为0，将每个0变为1。

5. 左移运算符（<<）：

   将操作数的二进制位左移指定的位数，低位补0。相当于乘以2的n次方，其中n为左移的位数。

6. 右移运算符（>>）：

   将操作数的二进制位右移指定的位数，高位用符号位填充。相当于除以2的n次方，其中n为右移的位数。

7. 无符号右移运算符（>>>）：

   将操作数的二进制位右移指定的位数，高位补0。不考虑符号位的影响，常用于无符号数的位移。

例如：

int a = 10; // 二进制表示为 1010
int b = 6; // 二进制表示为 0110

int bitwiseAnd = a & b; // 二进制 0010 -> 十进制 2
int bitwiseOr = a | b; // 二进制 1110 -> 十进制 14
int bitwiseXor = a ^ b; // 二进制 1100 -> 十进制 12
int bitwiseComplement = ~a; // 二进制 0101 -> 十进制 -11
int leftShift = a << 2; // 二进制 101000 -> 十进制 40
int rightShift = a >> 2; // 二进制 10 -> 十进制 2
int unsignedRightShift = a >>> 2; // 二进制 10 -> 十进制 2

需要注意的是，位运算符只能用于整数类型和字符类型，不能用于浮点数类型。

此外，位运算符在处理负数时要小心，符号位的影响可能导致结果不可预测。

6.1.8 比较运算符

比较运算符：用于比较两个操作数的大小关系，并返回一个布尔值（true或false）。

常见的比较运算符包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。

6.1.9 instanceof运算符

instanceof运算符：用于检查一个对象是否属于某个类或其子类的实例。

它的语法是 object instanceof className，如果object是className的一个实例，则返回true，否则返回false。

String str = "Hello";
boolean isString = str instanceof String; // 返回true，因为str是String类的实例

6.2 表达式

在Java中，表达式由操作数和操作符组成，用于执行计算、进行条件判断和赋值操作等。

表达式可以包含常量、变量、运算符、方法调用和表达式的组合。

下面详细介绍一些常见的表达式：

6.2.1 算术表达式

算术表达式用于执行基本的算术运算，如加法、减法、乘法和除法等。

它们使用算术运算符（+、-、*、/）和括号来表示优先级。

例如：int result = (5 + 3) * 2;

6.2.2 关系表达式

关系表达式用于比较两个值的大小关系，并返回一个布尔值（true或false）。

它们使用关系运算符（==、!=、>、<、>=、<=）表示。

例如：boolean isGreater = 5 > 3;

6.2.3 逻辑表达式

逻辑表达式用于执行逻辑运算，并返回一个布尔值。

逻辑与（&&）和逻辑或（||）用于组合多个条件，逻辑非（!）用于对条件取反。

例如：boolean result = (x > 0) && (y < 10);

6.2.4 条件表达式（三元表达式）

条件表达式是一种简洁的条件判断语句，根据一个条件选择两个值中的一个。

它的语法是 condition ? value1 : value2。

例如：int max = (x > y) ? x : y;

6.2.5 赋值表达式

赋值表达式用于将一个值赋给一个变量。

它使用赋值操作符（=）表示。

例如：int x = 10;

6.2.6 方法调用表达式

方法调用表达式用于调用一个方法并获取返回值。

它的语法是 methodName(arguments)。

例如：int sum = calculateSum(5, 3);

6.2.7 数组访问表达式

数组访问表达式用于访问数组中的元素。

它的语法是 arrayName[index]。

例如：int value = array[0];

6.2.8 对象创建表达式

对象创建表达式用于创建一个新的对象。

它使用new关键字后跟构造函数来创建对象。

例如：MyClass obj = new MyClass();

表达式是程序运行过程中的核心部分，它们用于计算和处理数据，控制程序的流程。