算数运算符

/*
    关于java编程中的算术运算符：
        + 求和
        - 相减
        * 乘积
        / 商
        % 求余数【取模】
        ++ 自加1
        -- 自减1
        注意：
            运算符有优先级，不确定的时候添加小括号
*/
public class OperatorTest01
{
    public static void main(String[] args){
        
        int i = 10;
        int j = 3;

        System.out.println(i + j); //13
        System.out.println(i - j); //7
        System.out.println(i * j); //30
        System.out.println(i / j); //3
        System.out.println(i % j); //1

        //++运算符可以出现在变量前面/后面【单目运算符】
        int k = 10;
        k ++;
        System.out.println(k);
        int y = 10;
        ++ y;
        System.out.println(y);

        //++出现在变量后
        //规则：先做赋值运算，再对变量中保存的值进行自加1
        int a = 100;
        int b = a ++;
        System.out.println(a); //101
        System.out.println(b); //100

        //++ 出现在变量前
        //规则：先进行自加1运算，然后再进行赋值操作
        int m = 20;
        int n = ++ m;
        System.out.println(m); //21
        System.out.println(n); //21

        int mm = 500;
        System.out.println(mm); //500

        int e = 100;
        System.out.println(e ++); //100
        System.out.println(e); //101

        int s = 100;
        System.out.println(++s); //101
        System.out.println(s); //101

        System.out.println("--------");
        System.out.println(--s); //100
        System.out.println(s++); //100
        System.out.println(s--); //101
        System.out.println(s--); //100
        System.out.println(s--); //99
        System.out.println(s); //98
    }
}

/*
    关系运算符：
        >    大于
        >=    大于等于
        <    小于
        <=    小于等于
        ==    等于
        !=    不等于

    = 是赋值运算符
    == 是关系运算符

    关系运算符的运算结果一定是布尔类型：true/false
*/
public class OperatorTest02
{
    public static void main(String[] args){
        
        int a = 10;
        int b = 10;

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

/*
    逻辑运算符：
        &    逻辑与
        |    逻辑或
        !    逻辑非（取反，!false就是true，!true就是false）
        ^    逻辑异或（两边的算子只要是不一样，结果就是true）

        &&    短路与
        !!    短路或

        短路与和逻辑与（短路或和逻辑或）的最终运算结果
        都是相同的，只不过短路与（或）存在短路现象
*/
public class OperatorTest03
{
    public static void main(String[] args){
        
        System.out.println(5 > 3 & 5 > 4); //true
        System.out.println(5 > 3 & 5 > 6); //false
        System.out.println(5 > 3 | 5 > 4); //true

        /*
        //逻辑与和短路与
        int x = 10;
        int y = 8;
        //逻辑与
        System.out.println( x < y & ++x < y);
        System.out.println(x); //11
        */

        //逻辑与和短路与
        int x = 10;
        int y = 8;
        //短路与
        //x < y 结果是false，整个表达式结果已经确定是false
        //所有后面的表达式没再执行，这种现象称为短路现象
        System.out.println( x < y && ++x < y);
        System.out.println(x); //10

        /*
            从某角度来看，短路与更智能。
            由于后面的表达式可能不执行，
            所以执行效率较高。这种方法在实际开发中使用较多

            但是，在某些特殊的业务逻辑当中，需要使用逻辑与
        */

        /*
            什么情况下发生短路或？
                在第一个表达式执行结果是true，会发生短路或
            什么情况下发生短路与？
                在第一个表达式执行结果是false，会发生短路与
        */
    }
}

/*
    关于java中的赋值运算符：

        赋值类运算符包括：
            
            基本的赋值运算符
                =
            扩展的赋值运算符
                += -= *= /= %=

        1、赋值类的运算符优先级：先执行等号右边的表达式，
            将执行结果赋值给左边的变量
        2、结论：扩展类型的赋值运算不改变运算结果类型，
            假设最初变量是byte类型，无论怎样追加或追减，
            最终该变量的数据类型还是byte类型
*/
public class OperatorTest04
{
    public static void main(String[] args){
        //基本的赋值运算符
        int i = 10;
        i = i + 5;
        System.out.println(i); //15

        //扩展的赋值运算符
        i += 5;
        System.out.println(i); //20

        byte b = 10;
        //编译错误，编译器发现b+5的类型是int类型，
        //b变量的数据类型是byte
        //大容量向小容量转换需添加强制类型转换符，报错
        //b = b + 5
        //错误纠正
        b = (byte)(b + 5);
        System.out.println(b); //15

        byte x = 10;
        x += 5; //等同于：x = (byte)(x + 5)
        System.out.println(x); //15

        byte z = 0;
        z += 128; //等同于：z = (byte)(z + 128)
        System.out.println(x); //-128【损失精度】
    }
}

/*
    关于java中的“+”运算符：
        1、+运算符在java语言当中有两个作用：
            加法运算，求和
            字符串的链接运算

        2、当“+”运算符两边的数据都是数字，进行加法运算

        3、当“+”运算符两边的数据只要有一个数据是字符串，
            一定会进行字符串连接运算，
            并且连接运算之后的结果还是一个字符串类型

        4、在一个表达式当中可以出现多个“+”，
            在没有添加小括号的前提下，
            遵循自左向右的顺序依次运算
*/
public class OperatorTest05
{
    public static void main(String[] args){
        
        System.out.println(10 + 20 + 30); //60
        System.out.println(10 + 20 + "30"); //"3030"
        System.out.println(10 + (20 + "30")); //102030

        int a = 10;
        int b = 20;

        //要求在控制台输出“10 + 20 = 30”
        System.out.println(a + " + " + b + " = " + (a + b));

        //定义一个String类型的变量，
        //起名username，赋值"zhangsan"
        String username = "zhangsan";
        System.out.println("欢迎" + username + "回来");
    }
}

/*
    三元运算符/三目运算符/条件运算符
        
        1、语法规则：
            布尔表达式 ? 表达式1 : 表达式2

        2、三元运算符的执行原理
            当布尔表达式的结果是true【false】的时候，
            选择表达式1【表达式2】作为整个表达式的执行结果
*/
public class OperatorTest06
{
    public static void main(String[] args){
        
        boolean sex = false;

        char c = sex ? '男' : '女';
        System.out.println(c);

        //语法错误，结果可能是String，也可能是char，
        //但前面不能用char来接收数据
        //char c1 = sex ? "男" : '女';
    }
}