11 java基础语法_4 _运算符

java基础语法_4 _运算符

基本运算符

1. 算数运算符：+、-、*、/、%(取余，模运算)、++、–
2. 赋值运算符： =
3. 关系运算符： >、<、>=、<=、==、!=、instancecof
4. 逻辑运算符：&&、||、!
5. 位运算符：<<、 >>、 ~、 |、 ^、 &、>>>
6. 条件运算符：?、:
7. 扩展赋值运算符：+=、-=、/=、*=

public class Demo01 {
    public static void main(String[] args) {
        long a = 132153231523L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a + b + c + d); //long
        System.out.println(b + c + d); //int
        System.out.println(c + d); //int ,结果是int类型

        int num1 = 10;
        int num2 = 21;
        System.out.println(num2 % num1); //取余 ，模运算 21/10=2.....1

        //关系运算符返回的结果是布尔值：false  true
    }
}

一元运算符

public class Demo02 {
    public static void main(String[] args) {
        // ++ -- 一元运算符
        int a = 3;

        int b = a++; //执行过程是：a先把值赋给b，之后a在自增（即执行下面一行语句）
        //a++ --->  a = a+1
        System.out.println(a); //4

        //a++ --->  a = a+1
        int c = ++a; //执行过程是：a先自增（即先执行上面一行语句），再把a的值赋给c

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

逻辑运算符*

public class Demo03 {
    //逻辑运算符 与&&（and）  或||(or)   非！(取反)
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:" +(b&&a));//逻辑与运算，必须全为真，结果才为真
        System.out.println("a || b:" + (a||b));//逻辑或运算，只要有一个真，结果就为真
        System.out.println("!(a && b):" +!(a&&b) );//如果真则变假，如果假则变真

        //短路运算（重点）
        /*
       	&&和||的短路运算，是指如果在进行前面的表达式的运算过程，通过判断已经明确的知道整个表达式的结		果，那么就不会进行后面表达式的运算判断。例如：

      	表达式1 || 表达式2 || 表达式3...|| 表达式n，如果表达式1的运算结果为true，则整个表达式的结果		 为true，同时不会再对后面的表达式2、表达式3到表达式n进行运算判断。如果表达式1的运算结果为             false，则根据表达式2的运算结果继续判断。

        表达式1 && 表达式2 && 表达式3...&& 表达式n，如果表达式1的运算结果为false，则整个表达式的结  		   果为false， 同时不会再对后面的表达式2、表达式3到表达式n进行运算判断。如果表达式1的运算结果为		  true，则根据表达式2的运算结果继续判断。
         */

        int c = 5;
        boolean d = (c<4) && (c++<10); //(5<4) && (6<10)
        System.out.println(d); //false
        System.out.println(c); //5,说明（c++<10）没有计算，前面(c<4)为false，与运算就可以直接得出结果
    }
}

位运算符*

public class Demo04 {
    //位运算
    public static void main(String[] args) {
        /*
            0代表false 1代表true
            A = 0011 1100
            B = 0000 1101

     A&B = 0000 1100 参加运算的两个数据，按二进制位进行“与”运算； 0&0=0;  0&1=0;  1&0=0; 1&1=1;
                        即：两位同时为“1”，结果才为“1”，否则为0
     A|B = 0011 1101 参加运算的两个对象，按二进制位进行“或”运算； 0|0=0;  0|1=1;  1|0=1; 1|1=1；
                        即 ：参加运算的两个对象只要有一个为1，其值为1。
     A^B = 0011 0001 参加运算的两个数据，按二进制位进行“异或”运算；0^0=0;  0^1=1; 1^0=1; 1^1=0；
                        即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。
     ~B = 1111 0010 参加运算的一个数据，按二进制位进行“取反”运算；~1=0；   ~0=1；
                        即：对一个二进制数按位取反，即将0变1，1变0。

            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
    }
}

拓展运算符

public class Demo05 {
    public static void main(String[] args) {
        //拓展运算符
        int a = 10;
        int b = 20;

        a+=b; //a = a+b;
        System.out.println(a); //30

        a-=b; //a = a-b;
        System.out.println(a); //30-20=10

        //字符串连接符 + ，String ,注意字符串在 + 的左边还是右边
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30
        System.out.println(a+b+""+a+b); //301020
    }
}

三元运算符（条件运算符）*

public class Demo06 {
    public static void main(String[] args) {
        //三元运算符
        // x ? y : z  如果 x==true，则结果为y，否则为z

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

运算符的优先级

优先级记忆方法：单目乘除为关系，逻辑三目后赋值。

单目运算符:一次作用一个变量的运算符，又叫一元运算符
单目：单目运算符+ –(正负数) ，++ --，！（逻辑非），~（按位取反）
乘除：算数运算符：* / % + - （* / %优先级肯定是大于±的）
为：位运算符：~（按位取反）<<(左移) >>(右移)，^（也可以位运算，二进制异或）
关系：关系运算符：> < >= <= == !=
逻辑：逻辑运算符（除！）&& || & | ^
三目：条件运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：= += -= *= /= %= |= &= ^=

说明：前优先级大于后，比如单目运算符 ~ 也是位运算符，~的优先级是单目级别的。至于赋值运算符中没有见过的自行测试

1. 该表中优先级按照从高到低的顺序书写，也就是优先级为1的优先级最高，优先级14的优先级最低。
2. 结合性是指运算符结合的顺序，通常都是从左到右。从右向左的运算符最典型的就是负号，例如3±4，则意义为3加-4，符号首先和运算符右侧的内容结合。
3. 注意区分正负号和加减号，以及按位与和逻辑与的区别
4. instanceof作用是判断对象是否为某个类或接口类型，后续有详细介绍。

其实在实际的开发中，不需要去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号去进行替代，示例代码：

   int m = 12;
   int n = m << 1 + 2;
   int n = m << (1 + 2); //这样更直观

这样书写代码，更方便编写代码，也便于代码的阅读和维护。