day03_Java

在Java中提供了丰富的运算符

其按照功能分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符...。
按照操作数个数分：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）。

我们又称用运算符连接起来的式子就是表达式。下面我们来具体学习一下每个运算符的作用吧。、

算数运算符

代码示例

public class Demo01Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 4;

        // + - * 和我们小学的规则一样
        System.out.println(a + b); //14
        System.out.println(a - b);//6
        System.out.println(a * b);//40

        //2个整数相除，结果就是商
        System.out.println(a / b);//2

        //int * double / int ==> double /	int ==> double / double ==> double
        System.out.println((a * 1.0) / b);// 2.5
   
        //结果是0 说明10是偶数，结果是 1 说明11是奇数
        System.out.println(10 % 2);//0 
        System.out.println(11 % 2);//1
        
        //结果是0 说明100可以被25整除，否则说明100不可以被26整除
        System.out.println(100 % 25);//0 
        System.out.println(100 % 26);//22 
    }
}

注意事项:

Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
/ 和%的区别：两个整数做除法，/取结果的商，%取结果的余数。取模的结果只和被除数的正负号相同。

案例：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

import java.util.Scanner;

public class Demo04Operator {
    public static void main(String[] args) {
        // 1：使用Scanner键盘录入一个三位数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int num = sc.nextInt();
        // 2：个位的计算：数值 % 10
        int ge = num % 10;						// 123 % 10 = 3
        // 3：十位的计算：数值 / 10 % 10
        int shi = num / 10 % 10;				// 123 / 10 = 12		12 % 10 = 2
        // 4：百位的计算：数值 / 100
        int bai = num / 100;					// 123 / 100 = 1
        // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
        System.out.println("整数:"+num+" 个位为:" + ge);
        System.out.println("整数:"+num+" 十位为:" + shi);
        System.out.println("整数:"+num+" 百位为:" + bai);

    }
}

“+”号的两种用法

第一种：对于+两边都是数值的话，+就是加法的意思。char类型参与算术运算，使用的是计算机底层对应的十进制数值。
第二种：对于+两边至少有一边是字符串得话，+就是拼接的意思。字符串可以使用 +号, 跟任意数据类型拼接，结果就是字符串。当连续进行“+”操作时，从左到右逐个执行。

代码示例

public class Demo02Operator {
    public static void main(String[] args) {
        
        //数学中的加法运算(数字相加,字符相加)
        System.out.println(5 + 5);// 10
		
        System.out.println(5 + 'A');// 70
		
        System.out.println('A' + 'B');// 131

        
        //字符串的拼接(把两个字符串连在一起),从左向右计算
        System.out.println("Hello" + "World"); //HelloWorld

        //先计算"5+5="+5: 此处+号代表字符串的连接 结果是"5+5=5"
        //然后"5+5=5"+5: 此处+号代表字符串的连接 结果是"5+5=55"
        System.out.println("5+5=" + 5 + 5);//5+5=55

        //()的优先级是比较高的,所以先计算5+5 结果10
        //然后"5+5="+10: 此处+号代表字符串的连接 结果是"5+5=10"
        System.out.println("5+5=" + (5 + 5));//5+5=10

    }
}

自增自减运算符

++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。只能操作变量，不能操作常量

单独使用（推荐使用）

变量在单独运算的时候，变量前++和变量后++，是没有任何区别的；

变量前++ ：例如 ++a
变量后++ ：例如 a++

public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}

复合使用

和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

变量前++ ：变量先自身加1，然后再取值。
变量后++ ：变量先取值，然后再自身加1。

public class Demo04Operator {
    public static void main(String[] args) {
        // 其他变量放在一起使用
        int x = 3;
        //int y = ++x;  y的值是4，x的值是4，

        // y的值是3，x的值是4
        int y = x++;

        System.out.println(x);//4
        System.out.println(y); //3


        // 和输出语句一起
        int z = 5;

        System.out.println(++z);//6
        System.out.println(z++);// 6
        System.out.println(z);//7

        int a = 1;
        //(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1
        a = a++;
        System.out.println(a);//1

    }
}

小练习

通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！

public static void main(String[] args) {
        int x = 4; //5 6
		
        int y = (x++) + (++x) + (x * 10);
        // 4 + 6 +
        System.out.println(x);//6
        System.out.println(y);//70

    }

赋值运算符

赋值运算符，就是将符号右边的值，赋给左边的变量。所有的赋值运算符的左边一定是一个变量，不能是常量。

代码示例


public class Demo03Operator {
    public static void main(String[] args) {
        //基本赋值运算符
        int a = 10, b = 20;

        //复合赋值运算符:
        a += b;//a = a + b
        System.out.println(a);//30
        System.out.println(b);//20

        int c = 30, d = 20;
        c %= d;//c = c % d

        System.out.println(c);//10
        System.out.println(d);//20

        short s = 1;
		
        s += 1;//s = (short)(s + 1);
        System.out.println(s);//2

    }
}

注意事项：

扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。
整数常量只要不超出所赋值的整数变量的取值范围,可以直接赋值,内部隐藏强制类型转换
运算的顺序：把右边的整个表达式先算完，才会做最后的赋值操作。

关系运算符

关系运算符又可以叫比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false`。

代码示例

public class Demo05Operator {
    public static void main(String[] args) {
        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); // false 
        System.out.println(a < b); // true
        System.out.println(a <= b); // true 
        // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
        boolean flag = a > b;
        System.out.println(flag);// 输出false
    }
}

注意事项：

其中>,<,>=,<=不支持boolean，String类型。==和!=支持boolean和String。
千万不要把“==”误写成“=”，"=="是判断是否相等的关系，"="是赋值。

逻辑运算符

逻辑运算符，是用来连接两个布尔类型结果的运算符（!除外），运算结果一定是boolean值true或者false。逻辑运算符作用: 用于整合多个比较表达式的条件

代码示例

public class Demo6Operator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        & “与”，并且的关系，只要表达式中有一个值为false，结果即为false
        System.out.println((a > b) & (a > c));  //false
        System.out.println((a > b) & (a < c));  //false
        System.out.println((a < b) & (a > c)); //false
        System.out.println((a < b) & (a < c)); //true

        // | “或”，或者的关系，只要表达式中有一个值为true，结果即为true
        System.out.println((a > b) | (a > c)); //false
        System.out.println((a > b) | (a < c)); //true
        System.out.println((a < b) | (a > c)); //true
        System.out.println((a < b) | (a < c)); //true


        // ^ 异或；相同为false，不同为true
        System.out.println((a > b) ^ (a > c)); //false
        System.out.println((a > b) ^ (a < c));//true
        System.out.println((a < b) ^ (a > c));//true
        System.out.println((a < b) ^ (a < c));  //false


        // ! 非；非false则true，非true则false
        System.out.println(!false);   //true
        System.out.println(!true); //false
    }
}

短路逻辑运算符

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

&& 和& 区别：

&&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。

|| 和 | 区别：

||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。

代码示例

package demo01;


public class Demo08Operator {
    public static void main(String[] args) {

        int a = 2;
        
        System.out.println((3 > 5) && (++a > 2));//false
        System.out.println(a);//2: 说明++a没有计算,&&右侧的表达式没有执行

        int b = 2;
        
        System.out.println((3 > 5) & (++b > 2));//false
        System.out.println(b);//3: 说明++b进行计算,&右侧的表达式执行了

        System.out.println("-------------------");
        int c = 2;
        
        System.out.println((3 < 5) || (++c > 2));//true
        System.out.println(c);//2: 说明++c没有计算,||右侧的表达式没有执行

        int d = 2;
        
        System.out.println((3 < 5) | (++d > 2));//true
        System.out.println(d);//3: 说明++d进行计算,|右侧的表达式执行了

    }
}

三元运算符语法格式：

数据类型变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;

执行流程:

计算布尔表达式1的结果,看是true还是false
如果布尔表达式1的结果为true,就把表达式2的结果赋值给左侧的变量
如果布尔表达式1的结果为false,就把表达式3的结果赋值给左侧的变量

执行流程图解:

代码示例

public class Demo08Operator {
    public static void main(String[] args) {
        //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
        int h1 = 150;
        int h2 = 210;
        int h3 = 165;
        //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int temp = h1 > h2 ? h1 : h2;
        //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int max = temp > h3 ? temp : h3;
        //4：输出结果
        System.out.println("这三个和尚中身高最高的是：" + max + "cm");
    }
}

位运算（了解）

效率很高，但是可读性不好。因为它是基于二进制补码直接运算的。关于&,|,^，看左右两边的操作数是boolean值，还是整数，来决定是逻辑运算符还是位运算符。常见的有以下几种位运算符

左移：<<

运算规则：<<几位，就乘以2的几次方
二进制补码左移n位，右边补0

右移：>>

运算规则：>>几位，就除以2的几次方
二进制补码右移n位，左边补0还是1，看最高位

无符号右移：>>>

运算规则：二进制补码右移n位，左边补0，对于负数来说，移完后，变为正数

运算符优先级

我们遵循一个原则：

表达式不要写太复杂，可以分为多行
实际开发中都是使用小括号来调整运算优先级

day03

Java相关栏目本月热门文章