8.运算符总结

运算符

1.二元运算符

package JavaOperator;

public class Operator01 {
    public static void main(String[] args) {
        /*
        运算符
        1、算数运算符：+ ，— ，* ， /， %（取余）， ++， ——。
        2、赋值运算符：=
        3、关系运算符：> , <, >=, <=, ==, !=
        4、逻辑运算符：&&， ｜｜， ！。
        5、位运算符：&， ｜， ^， ~， >>, <<, >>> 。
        6、条件运算符：？， ： 。
        7、扩展赋值运算符：+=， —=， *=， /= 。
             */

        //二元运算符
        int a = 14;
        int b = 64;
        int c = 34;
        int d = 68;

        System.out.println(a+b); // 78
        System.out.println(a-c); // -20
        System.out.println(a*d); //952
        System.out.println(c/d); //0 .精度问题。
        System.out.println((double)c/d); //0.5 .强制转换解决25行的精度问                        题。

        //不同数据类型相加会输出什么结果？
        long h = 20L;
        int m = 798;
        short o = 128;
        byte q = -1;
        double l = 10.0;
        System.out.println(q+l); //输出了double类型
        System.out.println(h+m+o+q); //输出了long类型
        System.out.println(m+o+q); //输出了int类型
        System.out.println(o+q); //输出了int类型
        System.out.println(h+l); //输出了double类型

        //多个数相加，有long类型，结果为long；否则为int类型。
        //多个数相加，有double类型，结果为double；否则为int类型。
        //double>long>int


    }
}

 

2.关系运算符

package JavaOperator;

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

        //关系运算符返回的结果：ture、false （布尔值）
        int a = 10;
        int b = 30;

        System.out.println(a>b); //f
        System.out.println(a<b); //t
        System.out.println(a==b); //f
        System.out.println(a!=b); //t

        //取余 %
        int d = 22;

        System.out.println(d%a); //2  成功取余2。


        //幂运算  如何算2^3 ? 要运用math工具类运算。
        double pow = Math.pow(2,3);
        double pow1 = Math.pow(3,3);
        System.out.println(pow);  // 8.0
        System.out.println(pow1); // 27.0


    }
}

 

3.自增自减运算符

package JavaOperator;

public class Operator03 {
    public static void main(String[] args) {
        //自增自减 ++ -- 。一元运算符号。

        //--a
        //该计算表达式产生的值是 x - 1
        //该表达式表达完毕之后，a的值也发生了变化 a = x - 1
        int a = 10;

        System.out.println(a);  //10
        System.out.println(--a);  //9
        System.out.println(a);  //9


        //a--
        // 该计算表达式产生的值是 x
        //该表达式表达完毕之后，a的值也发生了变化 a = x - 1
        int a1 = 10;

        System.out.println(a1); //10
        System.out.println(a1--); //10
        System.out.println(a1); //9


        //++a
        // 该计算表达式产生的值是 x + 1
        //该表达式表达完毕之后，a的值也发生了变化 a = x + 1
        int a2 = 10;

        System.out.println(a2); //10
        System.out.println(++a2); //11
        System.out.println(a2); //11


        //a++
        // 该计算表达式产生的值是 x
        //该表达式表达完毕之后，a的值也发生了变化 a = x + 1
        int a3 = 10;

        System.out.println(a3); //10
        System.out.println(a3++); //10
        System.out.println(a3); //11


        //实战
        int b = 10;
      
        System.out.println(b); //10
      
        int c = b++;
      
        System.out.println(b); //11
        System.out.println(c); //10 
        System.out.println(b); //11
      
        int d = ++b;
      
        System.out.println(d); //12
        System.out.println(b); //12 

    }
}

 

4.逻辑运算符 和 短路运算

package JavaOperator;

public class Operator04 {
    public static void main(String[] args) {
        //逻辑运算符 与& 或｜ 非！

        boolean a = true;
        boolean b = false;

        System.out.println(a && b); // false。辑与运算，变量都为真，结果才为真。
        System.out.println(a || b); // ture。逻辑或运算，变量有一真，结果直接为真。
        System.out.println(!(a && b)); // ture。如果是真输出假，如果是假输出真。

        //短路运算。
        int c = 5;
        boolean d = (c<4)&&(c++<4); //在&&与运算中，如果&&前面的数（c<4）为假，则不进行&&后面的数(C++<4)的运算.
      
        System.out.println(d); // false
        System.out.println(c); // 5 。从c输出5可以知道，c++并没有被执行，否则结果为6。证明了上面的运算出现短路。

        int x = 5;
        boolean l = (x>1)||(x-->2);

        System.out.println(l); // ture
        System.out.println(x); // 5. ||运算前的数据（x>1）为真，则结果直接为真，不再进行(x-->2)的运算，所以结果为5而不为4。


    }
}

 

5.位运算

package JavaOperator;

public class Operator05 {
    public static void main(String[] args) {
        //位运算： 是二进制的运算
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100  .上下都为1才得1，否则得0。
        A|B = 0011 1101  .上下都为0才得0，否则得1。
        A^B = 0011 0001  .上下相同得0，不相同得1。
        ~B = 1111 0010   .取反操作
        ~A = 1100 0011
         */

        // <<左移 ，>>右移

        System.out.println(2<<3);  // 16 why?
        /*         表示
        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8ß
        0001 0000   16

        得出：2在二进制中的1左移三位得到 16 的二进制。
        结论：<<意味着*2 ，>>意味着/2 。


         */
        System.out.println(2<<2); //8
        System.out.println(80>>1); //40



    }
}

 

6.扩展赋值运算符

package JavaOperator;

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

        /*
        a+=b; 从输出结果=30可以推出本式子表示的意思为 a = a+b
        b-=a;  b = a-b .
        //a-=b means a = b-a.
        //偷懒写法，在初学时不要使用。

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

        //字符串链接符
        System.out.println(a+b); //30
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30
        //字符串在前，链接后拼接。
        //字符串在后，前面的a+b正常计算。


    }

}

 

7.条件运算符

package JavaOperator;

public class Operator07 {
    public static void main(String[] args) {
        //三元运算符
        //偷懒算法，但是必须掌握。
        //开发中很常见。

        //x ？ y ：z
        //如果x==ture，则结果为y，否则为z。

        int score = 80;
        int score1 = 54;
        String ok = score < 60?"不及格":"及格";
        String ok1 = score1 < 60?"不及格":"及格";
        System.out.println(ok); //及格
        System.out.println(ok1); //不及格
    }
}

 

本文总结于：狂神说java：https://www.bilibili.com/video/BV12J41137hu?from=search&seid=13867334794067845764