Java的运算符和表达式（基础语法学习）

一、运算符

​ 在Java中用于程序计算的操作符统称为运算符，运算符分为如下几类

1、算数运算符

运算符	说明
+	加号两边是数值，可以运算，如果一边存在字符串，则当作连接符	a+b
-	两个数相加，减号也可以表示负号	a-b、-a
*	两个数相乘，其中*不能省略	a*b
/	两个数相除，必须保持数据类型一致，其中除数不能为0，否则出现算数异常	a*b
%	对一个数取余数	a%b
++	对一个数自加	a++、++a
--	对一个数自减	a--、--a

//总结 ++ --的优先级高于+、-、*、/、%

public static void main(String[] args){
    //+、-、*、/、%	所有运算符在计算时必须保证数据类型一致
    int num1 = 100;
    int num2 = 200;
    int sum = num1 + num2;
    int mul =  num1-num2;
    int num3 = -num2;   // -200
    System.out.println("两个数相加" +  sum); // + 表示连接符
    System.out.println("两个数相减" + mul);
    System.out.println( "num2: " + num2+ " ,num3:" + num3 );
    System.out.println("num1+num2="+ (num1+num2) );

    int sum2 = num1*num2;
        int sum3 = num1/num3;
        System.out.println(sum3);
       // System.out.println(num1/sum3); //算术异常：ArithmeticException: / by zero
        // 取模
        System.out.println( 10%2);//0
        System.out.println(1%5);// 1
        System.out.println(2%5);
}

public static void main(String[] args) {
// 自加  自减     ++  -- 只能对整数进行
        int i=1;
        i++ ;     // i = i + 1
        System.out.println("i:" + i);
        int j=1;
        ++j;    // j = j + 1
        System.out.println("j:" + j);

        int a =1;
        int sum = a++;  // 先将a的值赋值给sum  ，a再自加1
        int sum2 = ++a; // 先将a自加1 ，再将自加后的结果赋值给sum2
        System.out.println("sum:" + sum);
        System.out.println("sum2:" + sum2 );
        System.out.println("a:" +a);  // 3

        int sum3 = a++ + a++ ;
        System.out.println("sum3:"+sum3);
        System.out.println("a:"+a);

        // -- 操作  与++操作类似
        int b=1;
        int s1= b--;  // b = b -1     s1 的值为 先赋值再自减1   s1 = 1
        int s2 =  --b; // b = b -1   s2 的值为 先自减1 ，再赋值  s2 = -1
        System.out.println("b:"+b);
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);

        // ++  --  综合
        int x=1;
        int y=2;
        int s3 = x++ + --x * (y-- + ++x);
        System.out.println("x:"+x);// 2
        System.out.println("y："+y);// 1
        System.out.println("s3:"+s3);// 5
    }

2、比较运算符

用于比较两个表达式之间的 结果 ， 结果返回true 、false

比较运算符不能单独作为 一行代码运行 ，必须接收结果或者输出

比较运算符	说明	案例
>	比较左边的数是否大于右边的数，如果大于返回true，否则返回false	a>b ,3>5
<	比较左边的数是否小于右边的数，如果大于返回true，否则返回false	a<b
>=	比较左边的数是否大于等于右边的数，如果大于返回true， 否则返回false	1>=2
<=	比较左边的数是否小于等于右边的数，如果大于返回true ，否则返回false	1<=2
==	比较==两遍是否相等，如果相等则返回true ，否则返回false ，对于基本数据类型比较数值是否相等， 对于引用数据类型比较 它们的地址是否相等 （比较地址就是比较是否同一块内存）	1==2
!=	与== 相反， 比较左边和右边的数是否不相等 。如果不相等返回true ，如果相等返回false	1!=2

注意: 不能连写 例如 1<3<5

public static void main(String[] args) {
          // 比较运算符
        int a =1;
        int b =2;
       // a>b;  // 不能单独比较 必须接受结果或输出
        System.out.println(a>b);  //false
        System.out.println(a<b);  //true
        System.out.println(a==b); //false
        System.out.println(a!=b); //true
        // 增加逻辑判断
        // 如果 if 后面的条件成立，  则执行if里面的语句 ，如果不成立 则只需else语句
        if(a>b){
            System.out.println("a>b成立");
        }else{
            System.out.println("不成立");
        }

    }

3、赋值运算符

​ 将表达式 的结果 赋值给一个变量，只能赋值给变量 不能赋值给常量

​ 例如： a = 3

赋值运算符	说明	案例
=	将=右边的结果 赋值给左边的变量	int a = 2 ，将2赋值给变量a
+=	计算后的赋值，将+=右边的结果赋值给左边的变量	a+=2 等价于 a = a +2
-=	计算后赋值，将-=右边的结果赋值给左边的变量	a-=b 等价于 a = a-b
*=	同上， 将右边的结果赋值给左边的变量	a*=b 等价于 a = a * b
/=	同上，将右边的结果赋值给左边的变量	a /=b 等价于 a = a/b 其中b！=0
%=	同上，将右边的结果赋值给左边的变量	a %=b 等于 a= a%b 其中b！=0

// 赋值运算符 = +=  -= *=  /=  %=
        int a=2;
        a+=2;
        System.out.println(a);// 4
        a-=3;
        System.out.println(a);// 1
        a*=2;
        System.out.println(a); // 2
        a/=4;
        System.out.println(a);// 0

        a+=a-=3; // a+=（a-=3） -》 a=a +(a=a-3 )
        System.out.println("a="+a);

        int x=2;
        x+=x-=x*=x++;
        //x = x +(x = x -( x= x *(x++) ))
        // x = 2 + （ x = 2 - （x = 2 * 2））
        // x =  2 + ( 2 - 4)
        // x = 0
        System.out.println("x="+x);

        //赋值运算符的优先级最低，  从右往左计算
        int y=2;
        y*=y+=y; // 也是从右往左计算
        // y = y * (y = y + y);
        // y = 2 * (2+2)
        // y =8;
        System.out.println("y="+y);

4、逻辑运算符

在Java中用于两个或两个以上的表达式 取逻辑判断的结果 ，通常需要使用逻辑运算符

逻辑运算符	说明	案例
&	逻辑与 ，左右两边可以连接表达式 ，两个表达式都成立时，整个结果为true	true&true、 false&true false&false 、 true&false
|	逻辑或，左右两边的表达式，任意一个成立，整个结果为true	true|true false|true true|false false|false
!	逻辑非 对表达式取反	!false !true
&&	短路与 ， 与&类似 ，短路 特点： 符号左边为false，右边不再运算	true&&true true&&false ..
||	段落或， 与| 类似，段落特点： 符号左边为true ，右边不再运算	false||true false||false

  // 逻辑运算符
        System.out.println(true & true); // true
        System.out.println(true & false);// false
        System.out.println(false & true); // false
        System.out.println(false & false);// false
        // true&true
        System.out.println(1>0 & 3>1);
        System.out.println(1>0 && 3>1);
        // | 或
        System.out.println(true | true); //true
        System.out.println(true | false);// true
        System.out.println(false | true); // true
        System.out.println(false | false);// false
        // || 短路或
        System.out.println(true || false) ;// true

总结： &与&&的区别 |与||的区别？

回答 1、& 对于符号两边的表达式都会执行 && 符号左边为false，则右边不执行

​ | 对于符号两边的表达式都会执行， || 符号左边为true，则右边不执行

​ 2、 & 、| 两边可以直接写数字， 按位计算 ，短路符号 不能直接运算数字

int a=1;
        int b=2;
     //   System.out.println(a>b && b++>0);  // 符号右边的不运算
     //   System.out.println("b:"+b);

        System.out.println(a>b & b++>0); // 符号两边都运行
        System.out.println("b:"+b);

        // || 与 | 的区别
      //  System.out.println(a>=1 ||  a++<0); // a++ 不执行
      //  System.out.println("a:"+a);

        System.out.println(a>=1 | a++<0 );  // a++ 会执行
        System.out.println("再次输出a ：" + a);

十进制转二进制

十进制	转换	二进制
1	1*2的0次方	1
2	1*2的1次方	10
4	1*2的2次方	100
	对于2的倍数 ，1*2的n次方 转成二进制位1后面n个0
16	1*2的4次方	10000

对于任意十进制转二进制，先查找比它小的且离它最近的2的倍数 ，然后差值再计算二进制 ，（使用拆分法）

例如 28 = 16+8+4 = 11100

​ 34 = 32+2 = 100010

​ 96 = 64+32 = 1100000

二进制转十进制

公式： 从个位开始，每个位上的数 乘以2的n次方 累加之和

100100 = 1*2的2次方+1 * 2的5次方 = 36

5、位运算符

移位运算符	说明	案例
<<	左移： 将一个数转成二进制之后，整体往左移动n位 ,扩大倍数 ，一个数向左移动n位，结果为这个数乘以2的n次方	3<<2 = 3*2的2次方
>>	右移：将一个数转成二进制后，整体往右移动n位，缩小倍数，一个数向右移动n位，结果为这个数除以2的n次方（除不尽单独考虑）	8>>2 = 8/2的2次方
> > >	无符号的右移 ，不考虑符号位，将这个数整体往右移动n位。
^n	异或
~n	数值取反

//正整数的移位  <<   >>   >>>
        System.out.println(3<<2);  // 12
        System.out.println(7<<3); // 7*8=56

        // 对于正数的无符号右移和 右移 结果一样
        System.out.println(16>>2);// 4
        System.out.println(18>>2);// 4

        System.out.println(5^9);//12

        System.out.println(3>>2);
        System.out.println(3>>>2);

        System.out.println(~5);

// 负数的移位
        // 负数的左移位还是为负数
        System.out.println(-4<<2); // -4*2的2次方 =
        /**
         *   -4的原码： 1 0000... 00000100
         *          *   -4的反码： 1 1111... 11111011
         *          *   -4的补码： 1 1111... 11111100
         *          *   开始移位   2
         *             1 1111... 11110000
         *    最后结果 = 取反+1
         *             1 0000... 00001111  + 1
         *  ：
         *             1 0000... 00010000  =-16
         */

        // 补码 = 反码+1
        //负数是对于补码 进行移位   -4/2 =-2
        System.out.println(-4>>1);

        // -16无符号右移2位
        System.out.println(-16>>>2);   //1073741820
        // -16 的补码算出来
        /**
         * 原码  10000.. 0010000
         * 反码  11111.. 1101111
         * 补码  11111.. 1110000
         *      00111.. 1111100  由于不考虑符号，移动后高位全部补0 变成正数
         *      正数原码和补码一致 这个数即为所得
         *      1073741820
         */

6、三目运算符

​ 表达式 ? 结果1 ： 结果2

当？前面成立时， 整个表达式输出 结果1 ，如果？前面不成立，则输出结果2

// 生成100以内的随机数
        int n = (int)(Math.random()*100);
        System.out.println("n:"+n);
        System.out.println( n%2==0 ?"这个数是偶数":"这个数是奇数");

二、表达式、语句块

​ 表达式 ： 通过运算符 和 操作数组成的 元素 ， 表达式不能单独写在程序中，需要接受结果或输出。

表达式中可能同时存在多个操作符 ，此时需要考虑操作符的优先级问题

注意 ： 这里的（） 表示 方法的括号 ，点号表示小数点 ，[] 表示数组的下标

2-5 ： 用于得到结果值

6-12：用于运算得到ture、false

13,14：是赋值 。赋值的优先级最低

语句块：

在一个方法中，可以使用{} 表示一个语句块 ， 也可以放在方法的外面 ，类的里面，称为独立代码块

 public static void main(String[] args) {
         //定义一个方法中的代码块
        {
            // 局部变量只能使用在它所在的区域
            int a=1;
            a++;
            System.out.println("这是一个方法里面的代码块 "+a);
        }
       // a++;
        if(true){
            System.out.println("这是一个if代码块");
        }
    }