day04_运算符

运算符概述

• 运算符：对常量或者变量进行操作的符号
• 表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。

算术运算符

常见的运算符如下图所示

​

​

注意事项: 

• /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。要想得到小数，必须有浮点数参与运算。
• 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。
• 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。

​代码示例

public class Test3 {
    //商*除数 + 余数 = 被除数
    public static void main(String[] args) {
        // 两个常量之间可以进行数学运算
        System.out.println(20 + 30);

        // 两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a - b); // -10

        // 变量和常量之间可以混合使用
        System.out.println(a * 10); // 200

        int x = 10;
        int y = 3;
        // 整数相除,结果只能得到整数,如果想要得到带有小数的结果,必须加入小数(浮点类型)的运算
        int result1 = x / y;
        
        System.out.println(result1); // 3
        //5 / 2 = 商2, 余数为1
        int result2 = x % y;
        System.out.println(result2); // 余数，模，1

        // int + double --> double + double --> double
        double result3 = x + 2.5;
        System.out.println(result3); // 12.5

        
    }

}

字符的“+”操作

拿字符在计算机底层对应的数值来进行计算的

• 'a' -- 97 a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加
• 'A' -- 65 A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加
• '0' -- 48 0-9是连续的，所以'1'对应的数值是49，'2'是50，依次递加

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。 提升规则：

• byte类型，short类型和char类型将被提升到int类型、
• 整个表达式的类型自动提升到表达式中最高等级操作数同样的类型等级顺序：

​

代码示例

/*
    字符的"+"操作
    char类型参与算术运算，使用的是计算机底层对应的十进制数值。我们记住三个字符对应的数值：
        'a' -- 97 a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加
        'A' -- 65 A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加
        '0' -- 48 0-9是连续的，所以'1'对应的数值是49，'2'是50，依次递加
*/
public class Demo02Operator {
    public static void main(String[] args) {
        //定义两个变量
        int i = 10;
        char c = 'A'; //'A'的值是65
        c = 'a'; //'a'的值是97
        c = '0'; //'0'的值是48
        System.out.println(i + c);

        //char ch = i + c;
        //char类型会被自动提升为int类型
        int j = i + c;
        System.out.println(j);

        //int k = 10 + 13.14;
        double d = 10 + 13.14;
    }
}

字符串的“+”操作

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。当连续进行“+”操作时，从左到右逐个执行。对于+两边至少有一边是字符串得话，+就是拼接的意思

/*
四则运算当中的加号“+”有常见的三种用法：

1. 对于数值来说，那就是加法。
2. 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo05Plus {
    public static void main(String[] args) {
        // 数据类型 变量名称 = 数据值;
        String str1 = "Hello";
        System.out.println(str1); // Hello

        System.out.println("Hello" + "World"); // HelloWorld

        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 20); // Java20

        // 优先级问题
        // String + int + int
        // String        + int
        // String
        System.out.println(str2 + 20 + 30); // Java2030

        System.out.println(str2 + (20 + 30)); // Java50
    }
}

自增自减运算符

 注意事项：

• ++和-- 既可以放在变量的后边，也可以放在变量的前边。
• 单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
• 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。
• 参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。

代码示例

/*
自增运算符：++
自减运算符：--

基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++
使用方式：
    1. 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
    2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
使用区别：
    1. 在单独使用的时候，前++和后++没有任何区别。也就是：++num;和num++;是完全一样的。
    2. 在混合的时候，有【重大区别】
        A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。    【先加后用】
        B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。    【先用后加】
        
注意事项：
    只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
*/
public class Demo07Operator {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        ++num1; // 单独使用，前++
        System.out.println(num1); // 11
        num1++; // 单独使用，后++
        System.out.println(num1); // 12
        System.out.println("=================");

        // 30++; // 错误写法！常量不可以使用++或者--

        // ++在前: 先对该变量做自增(++)或者自减(--)，然后再拿变量参与操作。
        int a = 10;
        int b = ++a;

        System.out.println(a);        // 11
        System.out.println(b);        // 11


        // ++在后:    先将该变量原本的值，取出来参与操作，随后再进行自增(++)，自减(--)。
        int aa = 10;

        int bb = aa++;    // aa = 11

        System.out.println(aa);    // 11
        System.out.println(bb); // 10

        int num = 123;
        System.out.println(num++);    // 123
        System.out.println(num);    // 124

    }
}

赋值运算符

赋值类的运算符包括基本赋值运算符（=）和扩展的赋值运算 符（+=、-=、*=、/=、%=）常见的如下图所示

​​

注意事项：

• =   将右边的值赋值给左边的变量 ，一定要等右边所有的代码运算完毕再进行赋值
• 扩展的赋值运算符隐含了强制类型转换。
• 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制 类型转换原则进行处理。
• 支持连续赋值。不建议使用，可读性不好

代码示例

/*
赋值运算符分为：

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

复合赋值运算符：
    +=        a += 3        相当于        a = a + 3
    -=        b -= 4        相当于        b = b - 4
    *=        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
    }
}

​关系运算符 

关系运算符主要是完成数据和数据之间的比较，比如：5>3，结果是 true（真），5>10， 结果是 false（假），那么关系运算符如下图所示：

​

注意事项：

• 关系（比较）运算符的结果都是boolean型，也就是要么是true，要么是false。
• 比较（关系）运算符“==”不能误写成“=” 。
• 如果进行多次判断，不能连着写。数学当中的写法，例如：1 < x < 3程序当中【不允许】这种写法。

代码示例

/*

两个等号连写才是相等，一个等号代表的是赋值

*/
public class Demo {
    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(20 != 25); // true
        System.out.println(20 != 20); // false
        
        int x = 2;
        // System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。
    }
}

​逻辑运算符 

逻辑运算符作用: 用于[整合]多个比较表达式的条件。逻辑运算符主要包括逻辑与（&），逻辑或（|），逻辑异或（^），短路与（&&），短路 或（||）。 常见的逻辑运算符如下图所示

​

​

注意事项

• 逻辑与&，无论左边真假，右边都要执行。
• 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或|，无论左边真假，右边都要执行。
• 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
• 所有逻辑运算符的特点是操作数都是布尔类型，并且最终的运算结果也是布尔类型。
• 异或运算  ^：相同则为false 不同则为 true
• 与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
• 在数学中，一个数据x，大于3，小于6，我们可以这样来进行表示：3<x<6。 在Java中，需要把上面的式子先进行拆解，再进行合并表达。 合并后：x>3 && x<6

代码示例

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

我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符（!除外） 。 当然，逻辑运算符也可以直接连接布尔类型的常量或者变量。

位运算符

位运算是直接对整数的二进制进行的运算

​

​

​代码示例

/*
位运算符 （了解）

结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2

面试题：最高效方式的计算2 * 8 ？  2 << 3  或 8 << 1
*/
class BitTest {
    public static void main(String[] args) {
        int i = 21;
        i = -21;
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 27 :" + (i << 27));

        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));
        System.out.println("m | n :" + (m | n));
        System.out.println("m ^ n :" + (m ^ n));

        //练习：交换两个变量的值
        int num1 = 10;
        int num2 = 20;
        System.out.println("num1 = " + num1 + ",num2 = " + num2);

        //方式一：定义临时变量的方式
        //推荐的方式
        int temp = num1;
        num1 = num2;
        num2 = temp;

        //方式二：好处：不用定义临时变量  
        //弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
        //num1 = num1 + num2;
        //num2 = num1 - num2;
        //num1 = num1 - num2;

        //方式三：使用位运算符
        //有局限性：只能适用于数值类型
        //num1 = num1 ^ num2;
        //num2 = num1 ^ num2;
        //num1 = num1 ^ num2;

        System.out.println("num1 = " + num1 + ",num2 = " + num2);

    }
}

三元运算符

​

​执行顺序

• 首先计算关系表达式的值   
• 如果值为true，表达式1的值就是运算结果
• 如果值为false，表达式2的值就是运算结果

注意事项：

• 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
• 三元运算符的结果必须被使用。

代码示例

public class Demo {
    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; // 错误写法！
    }
}

运算符的优先级

• 运算符有不同的优先级，所谓 优先级就是表达式运算中的运 算顺序。如下表，上一行运算 符总优先于下一行
• 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的。
• 那么如果不确定它们的优先级怎么办，其实很简单，直接加小括号就可以了，添加有小括号优先级一定是高的，所以优先级不需要死记硬背，不确定就加小括 号，例如：1 + 2 * 3，想确保先求和，你就需要这样写：(1+2)*3。        

​

​