Java基本运算符

自增自减运算符

运算符：

• 自增： ++ (默认加一)

• 自减： -- (默认减一)

自增展开：

• a++ 与 a=a+1相同

• a-- 与 a=a-1 相同

 package operator;
 ?
 public class Demo04 {
     public static void main(String[] args) {
         //增增运算  一元运算符
         int a = 5;
         int b = a++;   //执行代码时，先给b赋值，再进行自增
         //默认就是：a=a+1
         System.out.println(b);  //5   b=5  a=6
         System.out.println(a);  //6  已被加一
 ?
         //a再原先加一上，再加一
         int c = ++a;   //执行代码前，先自增，在给b赋值
         System.out.println(c);   //7  c=7  a=7
         System.out.println(a);   //7  a=7
 ?
         System.out.println("==============自减运算===============");
 ?
         //自减运算  一元运算符
         int d = 10;
         int e = d--;
         //默认就是：a=a-1
         System.out.println(e);   //结果10  先赋值，后自减
         System.out.println(d);   //结果9   已经被-1
 ?
         int f = --d;
         System.out.println(f);   //在原先已经被-1上，再减一
         System.out.println(d);   //8
 ?
 ?
     }
 }

总结：

• 运算符在前，先赋值，再自增

• 运算符在后，先自增，再赋值

逻辑运算符

运算符

• 与运算(and)：&&

• 或运算(or)：||

• 非运算(取反)：!

运算符含义：

• 与运算：两个表达式结果都为真，结果为True

• 或运算：两个表达式只有一个为真，结果为True

• 非运算：如果为真，则变为假，如果为假，则变为真，取反

实验例子：

 package operator;
 ?
 public class Demo05 {
     public static void main(String[] args) {
         //逻辑运算(and)   与  或(or)  非(取反)
         boolean a = true;
         boolean b = false;
 ?
         System.out.println("a && b: "+(a&&b));  //False  与运算
         System.out.println("a || b: "+(a||b));  //True   或运算
         System.out.println("!(a && b): "+!(a&&b));  //True   非运算
         System.out.println("!(a || b): "+!(a||b));  //False   非运算
 ?
         //短路运算
         int c = 7;
         int i = 9;
 ?
         boolean d = (c<4)&&(c++<4);  //第一条件：单纯对比大写
         System.out.println(c);  //7
         boolean e = (c++<4)&&(c<4);  //第一条件：自增加一
         System.out.println(c);  //8
 ?
         boolean f = (i++>4)||(i++>4);  //只加一
         System.out.println(i);
         boolean g = (i++<4)||(i++<4);  //加二
         System.out.println(i);
 ?
 ?
     }
 }

注意：

• 与运算时，在遇到一个条件为False时，后面的运算不会被执行

• 或运算时，在遇到一个条件为True时，后面的运算不会被执行

位运算

位运算直接操作计算机底层，效率极高，通常再要求效率中的程序中使用像：源码、汇编等

 package operator;
 ?
 public class Demo06 {
     public static void main(String[] args) {
         /*
         A = 0101 0011
         B = 0011 1100
         ===============================
         A&B = 0001 0000  两个都为1则为1，其余都为0
         A|B = 0111 1111  两个都为0则为0，其余都为1
         A^B = 0110 1111  两个值不同时为1，相同时为0
         ~B = 1100 0011   0变1，1变0，取反
 ?
         2*8 =16   可以看作：2*2*2*2 也就是2的4次方，也就是幂运算
         但是java中并没有幂运算符号，可以使用Math数学工具
         效率极高的方式是：使用位运算符。
 ?
         首先要明白：计算机原理中的二进制
         0000 0000  0
         0000 0001  1
         0000 0010  2
         0000 0011  3
          */
         System.out.println(2<<3);  //16  在2对应的二进制位上，向左位移三位
         System.out.println(64>>1);  //48  再64对应的二进制位上，向右位移一位
     }
 }

条件运算符

条件运算符是逻辑运算与if类似，比较简便使用熟练后，可以减少代码量加强代码可读性

语法与正常使用：

 // 变量 = 1值 >值2 ?"True值结果":"False结果";
 System.out.println(变量)

实验例子

 package operator;
 ?
 public class Demo07 {
 ?
     //三元运算符
     public static void main(String[] args) {
         // x ?  y:z
         //如果x为True，那么结果为y，否则为z
         int score1 = 35;
         int score2 = 61;
 ?
         //如果score1大于60为及格，否则不及格
         String type1 = score1 >60 ?"及格":"不及格";
         System.out.println(type1);  //不及格
 ?
         String type2 = score2 >60 ?"及格":"不及格";
         System.out.println(type2);  //及格
 ?
     }
 }