Java 算术运算符 关系运算符 逻辑运算符 赋值类运算符 字符串连接运算符 三元运算符

算术运算符

/*
    关于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

        // 以下以++为例，--运算符一样~
        // 关于++运算符【自加1】
        int k = 10;
        
        // ++运算可以出现变量的后面【单目运算符】
        k ++;
        System.out.println(k); // 1

        int y = 10;

        // ++运算可以出现变量的q前面【单目运算符】
        ++ y;
        System.out.println(k); // 1

        // 小结：
        // ++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后
        // 只要++运算结束，该变量中的值一定会自加1


        // ++ 出现在变量后
        // 规则：先做赋值运算，再对变量中保存的值进行自加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 xx = 500;
        System.out.println(xx);

        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(--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

        关系运算符的运算原理：
            int a = 10;
            int b = 10;
            a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
            a == b 也是如此。

*/
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
        System.out.println(a < b);    // false
        System.out.println(a <= b);    // true
        System.out.println(a == b); // true
        System.out.println(a != b);    // false

    }
}

逻辑运算符

/*
    关于逻辑运算符：
        &    逻辑与【并且】    （两边的算子都是true，结果才是true）
        |    逻辑或【或者】    （两边的算子只要有一个是true，结果就是true）
        ！    逻辑非            （取反，!false就是true，!true就是false,就是一个单目运算符）
        ^    逻辑异或        （两边的算子只要不一样，结果就是true）
        &&    短路与    
        ||    短路或
    1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
    2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象。
    3、短路或和逻辑或最终的运算结果是相同的，只不过短路与存在短路现象。
    4、什么情况下发生短路现象呢？
    5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？
    
*/
public class OperatorTest03
{
    public static void main(String[] args){
    
        // 运算符优先级不确定，加小括号
        System.out.println(5 > 3 & 5 > 2 );    // true
        System.out.println(5 > 3 & 5 > 6 );    // false
        System.out.println(5 > 3 | 5 > 6 );    // true

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

        System.out.println(true | false );    // true
        System.out.println(false & false );    // false

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

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

        // 逻辑与和短路与
        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

        /*
            1、从某个角度来看，短路与更智能，由于后面的表达式可能不执行，所以执行效率较高，这种方式在实际的开发中使用较多，短路与比逻辑与使用的多，短路与更常用。
            2、但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表达式不执行

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


    }
}

赋值类运算符

/*
    关于java中的赋值类运算符：
        赋值类运算符包括两种：
            - 基本的赋值运算符
                = 
            - 扩展的赋值运算符
                +=
                -=
                *=
                /=
                %=
            1、赋值类的运算符优先级，先执行等号右边的表达式，将执行结果赋值给左边的变量。
            2、注意以下代码：
                byte i = 10;
                i += 5; 等同于：i = (byte)(i + 5);

                int k = 10;
                k += 5; 等同于：k = (int)(k + 5);

                long x = 10L;
                int y = 20;
                y += x; 等同于：y = (int)(y + x);
            3、重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终改变量的数据类型还是byte类型。

*/

public class OperatorTest04
{
    public static void main(String[] args){
    
    // 基本的赋值运算符
    int i = 10;
    System.out println(i); // 10
    i = i + 5;
    System.out.println(i); // 15
    
    // 扩展的赋值运算符【+= 运算符可以翻译为“追加/累加”】
    i += 5;    // 等同于：i = i + 5;
    System.out.println(i); // 20

    i -= 5; // 等同于：i = i - 5;
    System.out.println(i); // 15

    i *= 2; // 等同于：i = i * 2;
    System.out.println(i);  // 30

    i /= 4; // 等同于：i = i / 4;
    System.out.println(i);  // 7
    
    i %= 2; // 等同于：i = i % 2;
    System.out.println(i);  // 1


    //--------------------------------------------------------
    // 10没有超出byte取值范围，可以直接赋值
    byte b = 10;
    // b = 15; // 可以编译通过，15没有超出byte取值范围
    // 编译错误，为什么？
    // 编译器只检查语法，不运行程序，编译器发现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),其实并不等同于：x = x + 5
    System.out.println(x); // 15

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

    z += 10000; // 等同于 z = (byte)(z + 10000);
    System.out.println(z); // -112 【损失精度】


    }
}

字符串连接运算符

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

        2、当“+”运算符两边的数据都是数字的话，一定是进行加法运算。
        3、当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算，并且，连接运算之后的结果还是一个字符串类型。
            数字 + 数字 ---> 数字【求和】
            数字 + "字符串" ---> "字符串"【字符串连接】
        4、在一个表达式当中可以出现多个“+”，在没有添加小括号的前提之下，遵循自左向右的顺序依次运算。
    
*/

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

        System.out.println(10 + 20);    // 30 这里的加号是求和
        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 = 10;

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

        // 注意：要求以动态的方式输出
        System.out.println("10 + 20 = " + a + b); // "10 + 20 = 1020"

        System.out.println("10 + 20 = " + (a + b)); 

        System.out.println("a + 20 = " + (a + b));
        
        System.out.println(a + " + 20 = " + (a + b));

        System.out.println(a + " + " + b + " = " + (a + b));


        // 引用类型String
        // String是SUN在JavaSE当中提供的字符串类型
        // String.class字节码文件

        // int是基本数据类型，i是变量名，10是int类型的字面值
        int i = 10;

        // String是应用数据类型，s是变量名，"abc"是String类型的字面值
        // String s = "abc";

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

三元运算符

/*
    三元运算符/三目运算符/条件运算符
        1、语法规则：
            布尔表达式 ? 表达式1 : 表示式2
        2、三元运算符的执行原理？
            当布尔表示的结果是true的时候，选择表达式1作为整个表达式的执行结果
            当布尔表示的结果是false的时候，选择表达式2作为整个表达式的执行结果
    
*/


public class OperatorTest06
{
    public static void main(String[] args){
    
        // 编译错误：不是一个完整的java语句
        // 10;

        // 编译错误：不是一个完整的java语句
        // '男';

        // 布尔类型的变量
        boolean sex = false;

        // 分析以下程序是否可以编译通过？
        // 编译报错，因为它不是一个完整的java语句
        // sex ? '男' : '女';

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

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

        // 语法错误，编译报错，结果可能是String，也可能是char，但是前边不能用char来接受数据。
        // char c1 = sex? "男" : '女';
        
        // 编译错误，类型不兼容
        /*
        sex = false;
        char c1 = sex? "男" : '女';
        */

        System.out.println(10);
        System.out.println("10");
        System.out.println('1');
        // 可以
        System.out.println(sex ? '男' : "女");

        String s = sex ?("男的" : "女的");
        System.out.println(s);
    
    }
}