JavaSE从入门到放弃.运算符

运算符

运算符就是参与运算的符号。Java提供的运算符有很多种

• 基本算术运算符
• 自增自减运算符
• 赋值运算符
• 关系运算符
• 逻辑运算符
• 三元运算符

算术运算符

算术运算符有 + - * / % ，其中*表示乘法，/表示除法，%表示取余数

注意：

1. 两个整数相除，结果也是一个整数
2. +符号除了用于加法运算，还可以作为连接符。+符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串。

public class OperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b); // 20
        System.out.println(a / b); // 5
        System.out.println(5 / 2); // 2.5 ==> 2
        System.out.println(5.0 / 2); // 2.5
        System.out.println(a % b); // 0
        System.out.println(3 % 2); // 1

        int i = 5;
        int j = 2;
        System.out.println(1.0 * i / j); // 2.5

        int a2 = 5;
        System.out.println(a2 + 5); //  10
        System.out.println("abc" + a2); // "abc5"  + 可用作字符串拼接
        System.out.println("itheima" + a2 + 'a'); // "itheima5a"
        System.out.println(a2 + 'a' + "itheima"); // 102itheima  5+a 会用a的 Asiic码值 97 计算
    }
}

自增自减运算符

++读作自增，--读作自减；

public class OperatorDemo {
    public static void main(String[] args) {
        // 单独使用：++或者--放在变量前面没有区别
        int a = 10;
        a++;  //11
        --a;  //10
        System.out.println(a); //10

        // ++在后：先做其他事情，再做自增和自减
        int a = 10;
        int b = a++; // 等价于 int b = a; a++; 

        // ++在前：先自增或者自减，再做其他运输
        int x = 10;
        int y = --x; // 等价于x--; int y = x;
    }
}

赋值运算符

基本的赋值运算符其实就是=号，意思就是把右边的数据赋值给左边的变量。
除了基本的赋值运算符，扩展的赋值运算符有+= -= *= /= %=

1. 基本赋值运算符： =符号含义： 把右边的值赋值给左边的变量
2. 扩展赋值运算符： +=-=*=/=%=符号含义：将右边的数据和左边的变量相加、相减、相乘、相除、取余数后，将结果重新赋值给左边的变量。

public class OperatorDemo {
    public static void main(String[] args) {
        int a = 10; // 将数据10赋值给左边的变量a
        a += 5;// +=解析：在a原来记录值10的基础上累加5，将结果重新赋值给a;
        System.out.println(a);// 15
    }
}

public class OperatorDemo {
    public static void main(String[] args) {
        byte x = 10;
        byte y = 30;
        x = x + y;  // 出错 因为两个byte类型数据相加，会提升为int类型;

        byte x = 10;
        byte y = 30;
        x += 3; //这句代码没有问题，因为这里有隐含的强制类型转换 x+=3; 等价于 byte x = (byte)(x+y);
    }
}

关系运算符

关系运算符在程序中常用于条件判断，根据条件判断的结果是true还是false，来决定后续该执行哪些操作。

public class OperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        boolean rs = a > b;
        System.out.println(rs);

        System.out.println(a >= b); // 要么a大于b,或者a等于b
        System.out.println(2 >= 2); // true
        System.out.println(a < b);
        System.out.println(a <= b); // false
        System.out.println(2 <= 2); // true
        System.out.println(a == b); // false
        System.out.println(5 == 5); // true

        System.out.println(a != b); // true
        System.out.println(10 != 10); // false

        System.out.println(false ^ true ^ false);
    }
}

逻辑运算符

逻辑运算符是用来将多个条件放在一起运算，最终结果是true或者false

• 与 & 前后的条件的结果必须都是true ,结果才是true.
• 或 | 只要多个条件中有一个是true,结果就是true.
• 非 !取反的意思
• ^ 前后条件的结果相同时返回false，不同时返回true.
• 短路与 && 左边为false，右边不执行。
• 短路或 6、|| 左边是true ，右边就不执行。

public class OperatorDemo {
    public static void main(String[] args) {
        double size = 6.8;
        int storage = 16;

        boolean rs = size >= 6.95 & storage >= 8;
        System.out.println(rs);

        boolean rs2 = size >= 6.95 | storage >= 8;
        System.out.println(rs2);

        System.out.println(!true); // false
        System.out.println(!false); // true
        System.out.println(!(2 > 1)); // false

        System.out.println(true ^ true); // false
        System.out.println(false ^ false); // false
        System.out.println(true ^ false); // true
        System.out.println(false ^ true); // true

        int i = 10;
        int j = 20;
        System.out.println(i > 100 & ++j > 99);
        System.out.println(j);

        int m = 10;
        int n = 30;
        System.out.println(m > 3 | ++n > 40);
        System.out.println(n);
    }
}

三元运算符

三元运算的执行流程：首先计算关系表达式的值，如果关系表达式的值为true，则返回值1；如果关系表达式的值为false, 则返回值2；

关系表达式?值1:值2;

public class OperatorDemo {
    public static void main(String[] args) {
        double score = 58.5;
        String rs = score >= 60 ? "成绩及格" : "成绩不及格";
        System.out.println(rs);

        // 需求2：找出2个整数中的较大值，并输出。
        int a = 99;
        int b = 69;
        int max = a > b ? a : b;
        System.out.println(max);

        // 需求3：找3个整数中的较大值。
        int i = 10;
        int j = 45;
        int k = 34;

        // 找出2个整数中的较大值。
        int temp = i > j ? i : j;
        // 找出temp与k中的较大值。
        int max2 = temp > k ? temp : k;
        System.out.println(max2);
    }
}

运算优先级

&&运算比||运算的优先级高，所以&&和||同时存在时，是先算&&再算||；

在实际开发中，其实我们很少考虑运算优先级， 因为如果你想让某些数据先运算，其实加()就可以了，这样阅读性更高。