运算符

算数运算符：

---------------------------------------------------------↓ 算数运算符 ↓----------------------------------------------------------

/*
    算数运算符：
     + 求和
     - 相减
     * 乘积
     / 商
     % 求余数（求摸）
     ++ 自加1
     -- 自减1

     对于++运算符来说：
         可以出现在变量前，也可以出现在变量后。
        不管出现在变量前还是变量后，总之++执行结束之后，变量的值会自动+1。
*/
public class OperatorTest01{
    public static void main(String[] args){
        int a = 10;
        int b = 3;
        System.out.println(a + b);// 13
        System.out.println(a - b);// 7
        System.out.println(a * b);// 30
        System.out.println(a / b);// 3
        System.out.println(a % b);// 1

        // 重点掌握 ++ 和 --
        // 这里重点讲解 ++，至于-- 大家可以照葫芦画瓢
        // ++ 等于自加1（++可以出现在变量前，也可以出现在变量后）
        int i = 10;
        // i变量自加1
        i++;
        System.out.println(i);// 11

        int k = 10;
        // k变量自加1
        ++k;
        System.out.println(k);// 11

        // 研究： ++出现在变量前和变量后有什么区别？
        // 先看++出现在变量后。
        // 语法：当++出现在变量后，会先做赋值运算，在自加1
        int m = 20;
        int n = m++;
        System.out.println(n);// 20
        System.out.println(m);// 21

        // ++出现在变量前呢？
        // 语法规则：当++出现在变量前的时候，会先进行自加1的运算，然后再赋值。
        int x = 100;
        int y = ++x;
        System.out.println(x);// 101
        System.out.println(y);// 101

        // 题目
        int c = 90;
        System.out.println(c++);//90   传，这个“传”在这里有一个隐形的赋值运算。
        // 把上面代码拆解开
        //int temp = c++;
        //System.out.println(temp);
        System.out.println(c);//91

        int d = 80;
        System.out.println(++d);//81
        // 拆解
        // int temp2 = ++d;
        // System.out.println(d);//81
        System.out.println(d);//81
        
        /*
        int e = 1;
        int f = e;// e赋值给f，表示将e"传"给了f
        */

        // 自己测试一下 --运算符

    }
}

关系运算符：

---------------------------------------------------------↓ 关系运算符 ↓----------------------------------------------------------

/*
    关系运算符
        >
        >=
        <
        <=
        ==
        !=

        一定要记住一个规则：
            所有的关系运算符的运算结果都是布尔类型，
            不是true就是false，不可能是其他值。

        在java语言中：
         = : 赋值运算符
         == ： 关系运算符，判断是否相等。

         注意： 关系运算符中如果有两个括号的话，两个符号之间不能有空格。
         >= 这是对的，> = 这是不对的。
         == 这是对的，= = 这是不对的。
*/
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
    }
}

逻辑运算符：

---------------------------------------------------------↓ 逻辑运算符 ↓----------------------------------------------------------

/*
    逻辑运算符：
        & 逻辑与（可以翻译成并且）
        | 逻辑或（可以翻译成或者）
        ! 逻辑非（取反）
        && 短路与
        || 短路非

    用普通话描述的话：100 大于 99 并且 100 大于 98，有道理
    用代码表述的话： 100 > 99 & 100 > 98   --> true

    非常重要：
        逻辑运算符两边要求都是布尔类型，并且最终的运算结果也是布尔类型。
        这是逻辑运算符的特点。
    
    100 & true 不行，语法错误。
    100 & 200 不行，没有这种语法。

    true & false 只能是这样的

    100 > 90 & 100 > 101 --> false

    & 两边都是true，结果才是true
    | 有一边是true，结果就是true


*/
public class OperatorTest03{
    public static void main(String[] args){
        // 对于逻辑与&运算符来说，只要有一边是false，结果就是false。
        // 只有两边同时为true，结果才是true。
        System.out.println( true & true);// true
        System.out.println( true & false);// false
        System.out.println( false & false);// false

        System.out.println(100 > 90 & 100 > 101);//false
        System.out.println((100 > 90) & (100 > 101));//false

        int a = 100;
        int b = 101;
        int c = 90;
        System.out.println(a < b & a > c);//true

        // 对于逻辑或呢？
        // 只有有一边是true，结果就是true。
        System.out.println(a < b | c > b);//true

        System.out.println(c > b | a < b);//true

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

        System.out.println(true | true);//true
        System.out.println(false | false);//false
        
        System.out.println(!false);//true
        System.out.println(!true);//false
        
        // 注意：这里需要加一个小括号。
        System.out.println(!(a > b));//true

        /*
            关于短路与 &&，短路或 ||
            其中重点学习 短路与，短路或照葫芦画瓢。

            短路与 && 和 逻辑与 & 有什么区别？
                首先这两个运算符的运算结果没有任何区别，完全相同。
                只不过"短路与&&"会发生短路现象。

            什么是短路现象呢？
                右边表达式不执行，这种现象被叫做段路现象。

            什么时候使用&&，什么是受使用&？
                从效率方面来说， && 比 & 的效率要高一些。
                因为逻辑与&不管第一个表达式的结果是什么，第二个表达式一定会执行。

            以后的开发中，短路与&&和逻辑与&还是需要同时并存的。
                大部分情况下都建议使用短路与&&
                只有当既需要左边表达式执行，又需要右边表达式执行的时候，才会选择逻辑与&。
        */

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

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

        // 接下来需要理解一下什么是短路现象，什么时候会发生“短路”。
        int x = 10;
        int y = 11;
        // 逻辑与什么时候结果为true（两边都是true，结果才是true）
        System.out.println(x > y & x > y++);// false  左边的 x > y  表达式结果已经是false了，
                                            // 其实整个表达式的结果已经确认是false了,按道理来说右边的表达式不应该执行。
        
        // 通过这个测试得出：x > y++ 这个表达式执行了。
        System.out.println(y); // 12
        
        // 测试短路与&&
        int m = 10;
        int n = 11;
        // 使用短路与&&的时候，当左边的表达式为false的时候，右边的表达式不执行，这种现象被称为短路。
        System.out.println(m > n && m > n++);
        System.out.println(n); // 11
        
        // 问题： 什么时候发生短路或|| 现象。
        // || 短路或
        // "或"的时候只要有一边是true，结果就是true。
        // 所以，当左边的表达式结果为true，右边的表达式不需要执行，此时会短路。


    }
}

赋值运算符：

---------------------------------------------------------↓ 赋值运算符 ↓----------------------------------------------------------

/*
    关于赋值运算符：
        1 赋值运算符包括基本赋值运算符和扩展赋值运算符：基本的、扩展的。
        2 基本赋值运算符？
            =
        3 扩展的赋值运算符？
            +=
            -=
            *=
            /=
            %=
            注意：扩展赋值运算符在编写的时候，两个符号之间不能有空格
                + = 是错误的。
                += 是正确的。
        
        4 很重要的语法机制：
            使用扩展赋值运算符的时候，永远都不会该变运算结果类型。
            byte x = 100;
            x += 1;
            x自诞生以来是byte类型，那么x变量的类型永远都是byte。不会变。
            不管后面是多大的数字。
*/
public class OperatorTest04{
    public static void main(String[] args){

        // 赋值运算符“=” 右边优先级比较高，先执行右边的表达式
        // 然后将表达式执行结束的结果放到左边的“盒子”当中。（进行赋值）
        int i = 10;
        i = 20;

        byte b = 10;
        b = 20;

        /*
            以+= 运算符作为代表，学习扩展赋值运算符。
            其他的运算符，录入：-= *= /= 和 += 原理相似。
        */
        int k = 10;
        k += 20;// k变量追加20
        System.out.println(k);// 30

        int m = 10;
        // += 运算符类似于下面的表达式
        m = m + 20;
        System.out.println(m);//30

        // 研究：
        // i += 10 和 i = i + 10 真的是完全一样的吗？
        // 答案: 不一样，只能说相似，其实本质上并不是完全相同。

        byte x = 100;//100没有超出byte类型取值范围，可以直接赋值
        System.out.println(x);//100
        
        // 分析：这个代码是否能编译通过？
        //x = x + 1;//编译器检测到 x + 1是int类型，int类型可以直接赋值给byte类型的变量吗? 不行的：错误: 不兼容的类型: 从int转换到byte可能会有损失
        
        // 使用扩展赋值运算符可以吗？
        // 可以的，所以得出结论：x += 1 和 x = x + 1 不一样
        // 其实 x += 1等同于： x = (byte)(x + 1);
        x += 1;
        System.out.println(x);//101

        //早就超出byte的取值范围了。
        x += 199;// x = (byte)(x + 199);
        System.out.println(x); // 44(当然会自动损失精度。)

        int z = 100;
        System.out.println(z); // 100

        z += 100; // z =(int)(z + 100);
        System.out.println(z); // 200

        z -= 100;// z = (int)(z - 100);
        System.out.println(z); // 100

        z *= 10;// z = (int)(z * 100);
        System.out.println(z); // 1000

        z /= 30;// z = (int)(z / 30);
        System.out.println(z);// 33

        z %= 10;// z = (int)(z % 3);
        System.out.println(z); // 3
    }
}

条件运算符：

---------------------------------------------------------↓ 条件运算符 ↓----------------------------------------------------------

 

/*
    条件运算符：（三目运算符）
        语法格式：
            布尔表达式（要么是true 要么是false）? 表达式1 : 表达式2
        执行原理是什么？
            布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
            布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。
            
*/
public class OperationTest05{
    public static void main(String[] args){
        // 合法的java语句
        // 表示声明一个变量，起名i
        int i = 100;

        // 这里会编译出错吗？
        // 错误: 不是语句
        // 100;
        
        // 错误: 不是语句
        //'男';
        
        boolean sex = false;
        
        //分析以下代码是否存在语句错误？
        // 错误: 不是语句
        //sex ? '男' : '女';
        
        // 前面的变量的c的类型不能随意编写。
        // 最终的计算结果是字符型，所以便令也需要使用char类型。
        char c = sex ? '男' : '女';
        System.out.println(c);

        // 实际开发中不会这样，故意的
        // 错误: 不兼容的类型: 条件表达式中的类型错误
        //char x = sex ? '男' : "女";
        //System.out.println(x);
        
        //这个可以
        System.out.println(sex ? '男' : "女");

        /*System.out.println(这里很牛，因为这里什么类型的数据都能放);
        System.out.println(100);
        System.out.println("100");
        System.out.println('a');
        System.out.println(3.1415926);*/
    }
}

字符串连接运算符：

---------------------------------------------------------↓ 字符串连接运算符 ↓----------------------------------------------------------

 

/*
    + 运算符：
        1 + 运算符在java语言中有两个作用。
            作用1 求和
            作用2 字符串拼接
        
        2 什么时候求和？什么时候进行字符串的拼接呢？
            当 + 运算符两边都是数字类型的时候，求和。
            当 + 运算符两边的“任意一边”是字符串类型，那么这个 + 会进行字符串拼接操作。
        
        3 一定要记住：字符串拼接完之后的结果还是一个字符串。
*/
public class OperationTest06{
    public static void main(String[] args){
        //定义一个年龄的变量
        int nianLing = 35;

        // + 在这里会进行字符串的拼接操作。
        System.out.println("年龄 = " + nianLing);// “年龄 = 35”

        int a = 100;
        int b = 200;
        
        // 这里的 + 两边都是数据，所以加法运算
        int c = a + b;
        System.out.println(c); // 300

        // 注意：当一个表达式当中有多个加号的时候
        // 遵循自左向右的顺序依次执行。（除非额外添加了小括号，小括号的优先级高）
        // 第一个+号先运算，由于第一个+ 左右两边都是数字，所以会进行求和。
        // 求和之后结果是300，代码就变成了：System.out.println(300 + "110");
        // 那么这个时候，由于+右边的是字符串"110"，所以此时的+会进行字符串拼接。
        System.out.println(a + b + "110");//300110
        
        // 先执行小括号当中的程序：b + "110",这里的+会进行字符串的拼接，
        // 拼接之后的结果是："200110"，这个结果是一个字符串类型。
        // 代码就变成了System.out.println(a + "200110");
        // 这个时候的+还是进行字符串的拼接。最终结果是："100200110"
        System.out.println(a + (b + "110"));//"100200110"


        // 在控制台上输出"100 + 200 = 300"
        // 以下有效的运算符加号一共有4个，这4个加号都是字符串拼接操作
        System.out.println(a + "+" + b + "=" + (a + b));
        
        // 分析这个结果是多少？
        // 以下表达式中没有小括号，所以遵循自左向右的顺序依次执行。
        // 第1,2,3,4个加号都是进行字符串拼接，拼接之后的结果是："100 + 200 = 100"
        // 前4个加号运行之后是一个字符串"100 + 200 = 100"
        // 然后这个字符串在和最后一个b变量进行字符串的拼接："100 + 200 = 100200"
        System.out.println(a + "+" + b + "=" + a + b);

        // 在java语言中，怎么定义字符串类型的变量呢？
        // int 是整数型 i 是变量名 10 是字面量
        // int i = 10;
        // String是字符串类型，并且String类型不属于基本数据类型范畴，属于引用类型。
        // "jack" 是一个字符串型字面量。
        String name = "jack";// String类型是字符串类型，其中S是大写，不是:String
        
        // 会进行字符串的拼接
        System.out.println("登陆成功欢迎"+ name +"回来");

        // 口诀：加一个双引号""，然后刷您好之间加两个加号："++", 然后两个加号中间加变量名："+name+"
        System.out.println("登陆成功欢迎"+ name +"回来");
        
        // 错误：类型不兼容。
        //String name = 100;


    }
}