java修习之路--------------路漫漫其修远兮

Posted 2021-03-17 sgzslg

一、赋值运算符

/*
赋值运算符分为：

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
    int a = 30;

复合赋值运算符：
    +=    a += 1       相当于    a = a + 1
    -=    b -= 4       相当于    b = b - 1
    *=      c *= 5       相当于    c = c * 5
    /=    d /=6        相当于    d = d / 6
    %=    e %=7        相当于    e = e % 7
    
注意事项：
    1、只有变量才能使用赋值运算符，常量不能进行赋值.
    2、复合复制运算符其中隐含了一个强制类型转换。
*/
public class Demo07Operator{
    public static void main(String[] args){
        int a = 10;
        // 按照公式进行翻译： a = a +5
        // a = 10 + 5;
        // a = 15;
        // a 本来是10，现在重新赋值得到15
        a += 5;
        System.out.println(a);// 15
        
        int x = 10;
        // x = x % 3;
        // x = 10 % 3;
        // x = 1;
        // x本来是10，现在重新赋值得到1
        x %= 3;
        System.out.println(x);// 1
        
        //50 = 30;//常量不能进行赋值，不能写在赋值运算符的左边，错误写法！
        
        byte num = 30;
        // num = num + 5;
        // num = byte + int
        // num = int + int
        // num = int
        // num = (byte) int
        num +=5;
        System.out.println(num);// 35
        
    }
}

二、比较运算符

/*
比较运算符：
大于：        >
小于：        <
大于等于：    >=
小于等于：    <=
相等：        ==
不相等：    !=

注意事项：
1、比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2、如果进行多次判断，不能连着写。
数学当中的写法，例如：1 < x < 3
程序当中【不允许】这种写法。
*/
public class Demo08Operator{
    public static void main(String[] args){
        System.out.println(10 > 5);// true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2);// true
        System.out.println(num2 >= 100);// false
        System.out.println(num2 <= 100);// true
        System.out.println(num2 <= 12);// true
        System.out.println("===========");
        
        System.out.println(10 == 10);// true
        System.out.println(10 != 25);// true
        System.out.println(20 != 20);// false
        
        //int x = 2;
        //System.out.println(1 < x < 3);// 错误写法！编译报错！不能连着写
    }
}

三、逻辑运算符

/*
与（并且）    &&    全都是true,才是true：否则就是false
或（或者）    ||    至少一个是true，就是true：全都是false，才是false
非（取反）    !    本来是true，变成false：本来是false，变成true

与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项：
1、逻辑运算符只能用于boolean值。
2、与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3、与、或两种运算符，如果有多个条件，可以连续写。
连个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C

TIPS:
对于1 < x < 3 的情况，应该拆成两个部分，然后使用运算符连接起来。
*/
public class Demo09Logic{
    public static void main(String[] args){
        System.out.println(true && false);// false
        //true && true --> true
        System.out.println(3 < 4 && 10 > 5);// true
        System.out.println("============");
        
        System.out.println(true || false);// true
        System.out.println(true || true);// true
        System.out.println(false || false);// false
        System.out.println("================");
        
        System.out.println(true);// true
        System.out.println(!true);// false
        System.out.println("==============");
        
        int a = 10;
        //false && ....
        System.out.println(3 > 4 && ++a < 100);// false
        System.out.println(a);// 10
        System.out.println("================");
        
        int b = 20;
        // true || ...
        System.out.println(3 < 4 || ++b < 100);// true
        System.out.println(b);// 20
    }
}

四、三元运算符

/*
一元运算符：只需要一个数据就可以进行操作的运算符，例如：取反！、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符，例如：加法+、赋值=
三元运算符：需要单个数据才可以进行操作的运算符。

格式：
数据类型 变量名称 = 条件判断 ？ 表达式A  : 表达式B;

流程:
首先判断条件是否成立：
    如果成立为true，那么将表达式A的值赋值给左侧的变量；
    如果不成立为false,那么将表达式B的值赋值给左侧的变量;
二者选其一。

注意事项：
1、必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2、三元运算符的结果必须被使用。
*/
public class Demo10Operator{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        
        // 数据类型 变量名称 = 条件判断 ？ 表达式A  : 表达式B;
        // 判断a > b是否成立，如果成立将a的值赋值给max:如果不成立将b的值赋值给max，二者选其一
        int max = a > b ? a : b;// 最大值的变量
        System.out.println("最大值：" + max); // 20
        
        //int result = 3 > 4 ? 2.5 : 10;// 错误写法！
        
        System.out.println(a > b ? a : b);//正确写法
        
        //a > b ? a : b;//错误写法！
    }
}