03-运算符

运算符介绍

运算符是一种特殊的符号，用于表示数据的运算、赋值和比较。

运算符分为算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符、三元运算符。

1. 算术运算符

算术运算符是对数值类型的变量进行运算的，在Java程序中使用的非常多。

public class ArithmeticOperator{
    public static void main(String[] args){
        //1./除的使用
        System.out.println(10 / 4);   //输出2，这是因为10/4的结果是int类型
        System.out.println(10.0 / 4); //输出2.5，这是因为10/4的结果是double类型
        //思考
        double d = 10 / 4;
        System.out.println(d); //输出2.0，这是因为10/4的结果是int类型，然后转成double类型，从2变成2.0

        //2.%取模（取余）的使用
        //在%的本质，公式：a % b = a - a / b * b
        System.out.println(10 % 3);   //输出1
        System.out.println(10 % -3);  //输出-1
        System.out.println(-10 % 3);  //输出1
        System.out.println(-10 % -3); //输出-1

        //3.++的使用
        //作为独立的语句使用
        int i = 10;
        ++i; //自增(前)，等价于 i = i + 1;
        i++; //自增(后)，等价于 i = i + 1;
        System.out.println("i = " + i); //输出12

        //作为表达式使用
        //自增（前）：先运算后取值
        //自增（后）：先取值后运算
        int a1 = 10;
        int b1 = ++a1; //等价于，a1 = a1 + 1;b1 = a1;
        System.out.println("a1 = " + a1 + "\tb1 = " + b1); //输出a1 = 11    b1 = 11

        int a2 = 10;
        int b2 = a2++; //等价于，b2 = a2;a2 = a2 + 1;
        System.out.println("a2 = " + a2 + "\tb2 = " + b2); //输出a2 = 11    b2 = 10
        
    }
}

2.关系运算符（比较运算符）

关系运算符的结果都是boolean类型，也就是要么是true，要么是false。

关系运算符组成的表达式，我们称之为关系表达式。

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

        int a = 10;
        int b = 5;

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

        boolean flag = a > b;
        System.out.println(flag);   //true
    }
}

扩展："==" 和 equals()方法的区别

a) "=="是判断两个字符串在内存中的位置是否相同（完全相同）

b) equals()方法，是判断两个字符串的内容是否相同（内容相同）

import java.util.Scanner;

public class BreakExercise{
    public static void main(String[] args){
        //需求:实现登陆验证，有三次机会，如果用户名为：admin 密码为：123456
        //则提示登录成功，否则提示还有几次机会【for + break】

        Scanner sc = new Scanner(System.in);
        String name = "";
        String pwd = "";

        for(int i = 3; i >= 1; i--){
            System.out.println("请输入用户名：");
            name = sc.next();
            System.out.println("请输入密码：");
            pwd = sc.next();

            // "=="是判断两个字符串在内存中的位置是否相同（完全相同）
            System.out.println(name == "admin" && pwd == "123456"); //false
            // equals()方法，是判断两个字符串的内容是否相同（内容相同）
            System.out.println(name.equals("admin") && pwd.equals("123456")); //true

            if(name.equals("admin") && pwd.equals("123456")){
                System.out.println("登录成功！");
                break;
            }else{
                System.out.println("用户名或密码错误，请重新登录，该用户还有" + (i-1) + "次机会...");
            }

        }
    }
}

3.逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个boolean类型。

a) 逻辑与&，逻辑或|，逻辑异或^

逻辑与&：当a和b同时为true，则结果为true，否则结果为false

逻辑或|：当a和b有一个为true，则结果为true，否则结果为false

逻辑异或^：当a和b不同时，则结果为true，否则结果为false

b) 短路与&&，短路或||，取反！

短路与&&：当a和b同时为true，则结果为true，否则结果为false

短路或||：当a和b有一个为true，则结果为true，否则结果为false

取反！：当a为true，则结果为false；当a为false，则结果为true

这里需要注意：逻辑与& 和 短路与&& 的区别

逻辑与&：不管第一个条件是否为false，第二个条件都要判断（效率低）

短路与&&：如果第一个条件为false，则第二个条件不会判断，最终结果为false（效率高）

逻辑或| 和 短路或|| 的区别

逻辑或| :不管第一个条件是否为true，第二个条件都要判断（效率低）

短路或|| :如果第一个条件为true，则第二个条件不会判断，最终结果为true（效率高）

public class LogicOperator01{
    public static void main(String[] args){
        //&& 和 & 案例演示
        int age = 50;
        if(age > 20 && age < 90){
            System.out.println("ok100"); //输出ok100
        }

        //& 使用
        if(age > 20 & age < 90){
            System.out.println("ok200"); //输出ok200
        }

        //&& 和 & 区别
        //短路与&&：如果第一个条件为false，则第二个条件不会判断，最终结果为false
        int a = 5;
        int b = 10;
        if(a < 1 && ++b < 50){
            System.out.println("ok300");
        }
        String str1 = String.format("&&情况：a = %d\tb = %d",a,b);
        System.out.println(str1); //输出 &&情况：a = 5　　b = 10

        //逻辑与&：不管第一个条件是否为false，第二个条件都要判断
        if(a < 1 & ++b < 50){
            System.out.println("ok400");
        }
        String str2 = String.format("&情况：a = %d\tb = %d",a,b);
        System.out.println(str2); //输出 &情况：a = 5　　b = 11
    }
}

4.赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

a) 基本赋值运算符 =

b) 复合赋值运算符 += 、-= 、*= 、 /= 、%= 等

这里需要注意：

赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值

复合赋值运算符，会进行类型转换

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

        int n1 = 10;
        n1 += 4; //等价于 n1 = n1 + 4;
        System.out.println(n1); //14

        n1 /= 3; //等价于 n1 = n1 / 4;
        System.out.println(n1); //4

        //复合赋值运算符会进行类型转换
        byte b = 3;
        b += 2; //等价于 b = (byte)(b + 2)，这是因为 b + 2 的结果是 int类型
        b++;   //等价于 b = (byte)(b + 1)
    }
}

5.三元运算符

条件表达式?表达式1:表达式2;

a) 如果条件表达式为true，则运算后的结果是表达式1；

b) 如果条件表达式为false，则运算后的结果是表达式2；

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

        int a = 10,b = 99;
        //条件表达式?表达式1:表达式2;
        int result = a > b ? a++ : b--;
        //1.a > b为false
        //2.返回b--，先返回b的值，然后再b-1
        //3.返回的结果是99
        System.out.println("result = " + result); //result = 99
        System.out.println("b = " + b);  //b = 98

        //实现三个数的最大值
        int n1 = 55,n2 = 33,n3 = 123;
        //1.先得到n1 和 n2 中最大的数，保存到 max1
        //2.再得到n2 和 n3 中最大的数，保存到 max2
        int max1 = n1 > n2 ? n1 : n2;
        int max2 = max1 > n3 ? max1 : n3;
        System.out.println("最大的值为：" + max2);

        //扩展：使用一条语句实现
        int max = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3;
        System.out.println("最大的值为：" + max);
    }
}

运算符优先级