运算符

算数运算符:
---------------------------------------------------------↓ 算数运算符 ↓----------------------------------------------------------
/*
    算数运算符:
     + 求和
     - 相减
     * 乘积
     / 商
     % 求余数(求摸)
     ++ 自加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;


    }
}
posted @ 2020-06-05 23:13  xlwu丶lz  阅读(175)  评论(0编辑  收藏  举报