运算符与表达式

一、算术运算符

1. + 表示加法运算符

2. - 表示减法运算符

3. * 表示乘法运算符

4. / 表示除发运算符

5. % 表示取模/取余运算符

/*
	编程实现算术运算符的使用
 */
 public class ArithmeticTest {
	 
	public static void main(String[] args){
		 
		// 1.声明两个int类型的变量并初始化
		int a = 8;
		int b = 4;
		 
		// 2.打印变量的数值
		System.out.println("a = " + a);
		System.out.println("b = " + b);
		System.out.println("-----------------------------------------------");
		// 3.使用以上变量实现算术运算符的使用  + - * / %
		// 表示声明变量c来记录a与b的和   d e f g 同理
		// 方法1（推荐）
		int c = a + b;
        int d = a - b;
        int e = a * b;
        int f = a / b;
        int g = a % b;		 
		System.out.println(c); // c = 12
		System.out.println(d); // d = 4
		System.out.println(e); // e = 32
	    System.out.println(f); // f = 2
		System.out.println(g); // g = 0
		System.out.println("-----------------------------------------------");
	 
		//方法2
		System.out.println(a + b);  // 12
		System.out.println(a - b);  // 4
		System.out.println(a * b);  // 32
		System.out.println(a / b);  // 2
		System.out.println(a % b);  // 0
		// 其中a+b这个整体叫做表达式  a、b叫做 *** 作数  + - * / %叫做运算符
		 
		System.out.println("-----------------------------------------------");
		// 4.注意事项
		// 4.1 当两个整数相除时结果只保留整数部分，丢失小数部分
		System.out.println(3 / 2);  // 1
		
		System.out.println("-----------------------------------------------");
		// 4.2 若想保留小数部分处理方式
		// 处理方式一： 使用强制类型转换将其中一个 *** 作数转换为double类型再运算即可
		System.out.println((double)3 / 2); // 1.5
		System.out.println(3 / (double)2); // 1.5
		System.out.println((double) 3 / (double)2); //1.5
		System.out.println((double)(3 / 2)); // 1.0
		// 处理方式二： 让其中一个 *** 作数乘以1.0即可（推荐）
		System.out.println(3 * 1.0 / 2); // 1.5
		System.out.println(3.0 / 2); // 1.5  （不推荐）若 *** 作数是a.0则为错误的表示
		
		System.out.println("-----------------------------------------------");
		// 4.3 0不能做除数
		//System.out.println(3 / 0); // java.lang.ArithmeticException: / by zero
		System.out.println(3 / 0.0); // Infinty 无穷
		System.out.println(0 / 0.0); // NaN Not a Number
	 }
 }

DOS命令的结果：

二、字符串连接运算符

1. + 可以实现字符串的连接。同时可以实现与其他数据类型“相连”。

三、关系/比较运算符

1. > 表示是否大于运算符 ； >=表示是否大于等于运算符

2. < 表示是否小于运算符 ； <=表示是否小于等于运算符

3. == 表示是否等于运算符   ； ！= 表示是否不等于运算符

*所有以关系运算符作为最终运算的表达式结果一定是boolean类型。

/*
 *	编程实现关系/比较运算符的使用
 */
public class RelationTest {

    public static void main(String[] args) {

        // 1.声明两个变量
        int a = 1;
        int b = 2;
        // 2.使用关系运算符打印以上变量的结果
        System.out.println(a > b);  // F
        System.out.println(a >= b); // F
        System.out.println(a == b); // F
        System.out.println(a < b);  // T
        System.out.println(a <= b); // T
        System.out.println(a != b); // T
    }
}

三、自增减运算符

        1.  ++ 表示自增运算符，用于使得当前变量自身的数值加1的效果

        2.  -- 表示自减运算符，用于使得当前变量自身的数值减1的效果

       i++和后++i的区别：

                 i++是先参与运算然后自加1,++i是先自加1然后参与运算

/*
 *	编程实现自增减运算符的使用
 *  i++是先参与运算然后自加1,++i是先自加1然后参与运算
 */
public class SelfTest {

    public static void main(String[] args){

        // 1.声明一个int类型的变化并初始化
        int a = 10;
        // 2.打印变量的数值
        System.out.println(a); // 10

        System.out.println("=================================================================================");
        // 3.实现自增减运算符的使用
        // 表示让变量a自身的数值加1，并覆盖该变量原来的数值
        a++; // a = a + 1;
        System.out.println(a); // 11
        System.out.println("=================================================================================");
        // 表示让变量a自身的数值加1，并覆盖该变量原来的数值
        ++a;
        System.out.println(a); // 12
        System.out.println("=================================================================================");
        // 表示让变量a自身的数值减1，并覆盖该变量原来的数值
        a--;
        System.out.println(a); // 11
        System.out.println("=================================================================================");
        // 表示让变量a自身的数值减1，并覆盖该变量原来的数值
        --a;
        System.out.println(a); //10
        System.out.println("=================================================================================");
        // 4.简单的交换
        // 其中a++这个整体叫做表达式  其中a叫做 *** 作数/变量  也就是a++和a表示不同的含义，因此所占的内存空间应该不同
        // 后++表示先让变量a的数值作为表达式的最终结果，然后再让a变量自身的数值加1
        System.out.println(a++); // 10
        System.out.println(a);   // 11
        System.out.println("=================================================================================");
        // 前++表示先让变量自身的数值加1，然后再让变量的数值作为整个表达式的结果
        System.out.println(++a); // 12
        System.out.println(a);   // 12
        System.out.println("=================================================================================");
        // 后--表示先让变量a的数值作为表达式的最终结果，然后再让a变量自身的数值减1
        System.out.println(a--);  // 12
        System.out.println(a);    // 11
        System.out.println("=================================================================================");
        // 前--表示先让变量自身的数值减1，然后再让变量的数值作为整个表达式的结果
        System.out.println(--a);  // 10
        System.out.println(a);	   // 10
        System.out.println("=================================================================================");
        // 5.笔试考点
        int b = a++;
        System.out.println("b = " + b); // 10
        System.out.println("a = " + a); // 11
        int c = ++a;
        System.out.println("c = " + c); // 12
        System.out.println("a = " + a); // 12
        System.out.println("=================================================================================");
        System.out.println(a++ + ++a);  // 26
        System.out.println("a = " + a);

    }
}

四、逻辑运算符

                1. &&表示逻辑与运算符，相当于“并且”，同真为真，一假为假。

                2. || 表示逻辑运算符，“相当于或者”，一真为真，同假为假。

                3. ！表示非运算符，相当于“取反”，真为假，假为真。

                *逻辑运算符表达式是boolean类型。

/*
 *	编程实现逻辑运算符的使用
 */
public class LogicTest {

    public static void main(String[] args){

        // 1.声明两个boolean类型的变量并初始化
        boolean a = true;
        boolean b = false;
        // 2.打印变量的数值
        System.out.println("a =" + a); // a = true
        System.out.println("b =" + b); // b = boolean
        System.out.println("--------------------------------------------------------------------------------------");
        // 3.使用上述变量实现逻辑运算符的使用
        boolean c = a && b;                    // 并且
        System.out.println(c); // false
        System.out.println(a && b); // false
        boolean d = a || b;                    // 或者
        System.out.println(d); // true
        System.out.println(a || b); // true
        System.out.println(!b); // true        // 取反
        System.out.println(!a); // false
        System.out.println("--------------------------------------------------------------------------------------");
        // 4.测试一下短路特性
        int x = 3;
        int y = 5;
        // 对于逻辑与运算符来说，若第一个条件为假，则整个表达式为假，此时跳过第二个表达式不执行
        boolean z = (++x == 3) && (++y == 5);
        System.out.println("z = " + z); // false
        System.out.println("x = " + x); // 4
        System.out.println("y = " + y); // 5

        // 对于逻辑或运算符来说，若第一个条件为真，则整个表达式为真，此时跳过第二个表达式不执行
        boolean t = (++x == 5) || (++y == 5);
        System.out.println(" t = " + t); // true
        System.out.println(" x = " + x); // 5
        System.out.println(" y = " + y); // 5
    }
}

逻辑运算符图解：

短路特性：
        对于逻辑与运算符来说，若第一个条件为假，则整个表达式为假，此时跳过第二个表达式不执行

        对于逻辑或运算符来说，若第一个条件为真，则整个表达式为真，此时跳过第二个表达式不执行

五、条件/三目运算符         语法格式：条件表达式？ 表达式1：表达式2

           判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2。

import java.util.Scanner;

/*
 *  提示用户输入一个正整数，使用条件/三目与运算符判断该正整数是否为三位数
 */
public class IfTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个正整数
        System.out.println("请输入一个正整数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        // 2.使用条件运算符判断该正整数是否为三位数
        System.out.println(n + (n >= 100 && n <= 999 ? "是三位数":"不是三位数"));

    }
}

六、赋值运算符

               1. = 表示赋值运算符，用于将 = 右边的数据赋值给 = 左边的变量，覆盖变量原来的数值。

                2. 赋值表达式本身也有值，其本身之值即为所附之值。

                3.复合赋值运算符的使用（+= 、-= 、 *= 、/=、... ...）

/*
 *  编程实现赋值运算符的使用
 */
public class AssignTest {

    public static void main(String[] args) {

        // 1.声明一个int类型的变量并初始化
        int a = 1;
        // 2.打印变量的数值
        System.out.println("a =" + a);  // a = 1

        System.out.println("-----------------------------------------------");
        // 3.简单赋值运算符的使用
        // 表示将数值6赋值给变量a并且覆盖变量a原来的数值
        a = 6;
        System.out.println("a =" + a); // a = 6
        // 下面代码是在打印表达式的结果
        System.out.println(a = 6); //6
        System.out.println("a =" + a); // a = 6
        int b = a = 7;
        System.out.println("a =" + a); // a = 7
        System.out.println("b =" + b); // b = 7
        int c = b = a = 8;
        System.out.println("a =" + a); // a = 8
        System.out.println("b =" + b); // b = 8
        System.out.println("c =" + c); // c = 8

        System.out.println("-----------------------------------------------");
        // 4.复合赋值运算符的使用（+= 、-= 、 *= 、/=、... ...）
        // a = a + 2;  推荐初学者使用该方式
        a += 2; // a = a + 2;的简化写法
        System.out.println("a =" + a); // a = 10
    }
}

4.1

        

4.2

七、移位运算符（了解）

        1.  <<  左移运算符，用于将数据的二进制位向左移动，右边使用0补充

        2.  >>  右移运算符，用于将数据的二进制位向右移动，左边使用符号位补充

        3.  >>>  表示逻辑右移运算符（或无符运算符），用于将数据的二进制位向右移动，左边使用0补充。

public class MoveBitTest {

    public static void main(String[] args) {

        // 1.声明一个byte类型的变量并初始化
        byte b1 = 13;
        // 2.打印变量的数值
        System.out.println("b1 =" + b1);

        System.out.println("--------------------------------------------------------");
        // 3.移位运算符的使用
        // 13的二进制是： ... 0000 1101 => 左移1位的结果是： ... 0001 1010 => 转换为十进制整数是：26
        // byte b2 = b1 << 1; // 错误：不兼容的类型：从int转换到byte可能会有损失  自动提升为int类型，也就是32位二进制
        byte b2 = (byte)(b1 << 1);
        System.out.println("b2 =" + b2); // b2 = 26
        System.out.println("--------------------------------------------------------");
        System.out.println(b1 << 1); // 26  左移一位相当于当前整数的数值*2
        System.out.println(b1 << 2); // 52  左移一位相当于当前整数的数值*4

        System.out.println("--------------------------------------------------------");
        System.out.println((b1 >> 1)); // 6  右移一位相当于当前整数的数值/2
        System.out.println(b1 >> 2); // 3  右移一位相当于当前整数的数值/4

        System.out.println("--------------------------------------------------------");
        // 逻辑右移  对于非负数来说，逻辑右移和右移的效果一致
        System.out.println((b1 >>> 1)); // 6  右移一位相当于当前整数的数值/2
    }
}

八、位运算符（了解）

        1. & 表示按位与运算符，按照二进制位进行与运算，同1为1，一0为0.

        2. |  表示按位或运算符，按照二进制位进行与运算，一1为1，同0为0.

        3. ~ 表示按位取反运算符，按照二进制位进行取反，1为0,0为1.

        4.  ^ 表示按位异或运算符，按照二进制位进行异或运算符，同为0，不同为1.

/*
 *  编程实现位运算符的使用
 */
public class BitTest {

    public static void main(String[] args) {

        // 1.声明两个byte类型的变量并初始化
        byte b1 = 11;
        byte b2 = 13;
        // 2.打印变量的数值
        System.out.println("b1 =" + b1); // b1 = 11
        System.out.println("b2 =" + b2); // b2 = 13

        System.out.println("------------------------------------------------");
        // 3.实现位运算符的使用
        // b1的二进制为：0000 1011
        // b2的二进制为：0000 1101
        System.out.println(b1 & b2); // 按位与：同1为1，一0为0    按位与后的二进制为：0000 1001 => 转为十进制是：9
        System.out.println(b1 | b2); // 安慰或：一1为1，同0为0    按位或后的二进制为：0000 1111 => 转为十进制是：15
        System.out.println(~ b1);  // 按位取反：1为0,0为1         按位取反的二进制为：1111 0100
        // 二进制1111 0100转为十进制 => 先减1:1111 0011 => 按位取反：0000 1100 => 添加负号：-12
        System.out.println(b1 ^ b2); // 按位异或：相同为0，不同为1 按位异或的二进制为：0000 0110 => 转为十进制：6
    }
}

九、运算符优先级

        1.（）的优先级极高

        2.  =   的优先级极低

        3. 若无法确认优先级，则使用（）来确保即可。