尚学堂 JAVA Day3 概念总结

java中的运算符

1、算术运算符 + - * / % Arithmetic operators
+ 运算符有三种身份 Additive Operator
1）加法：如 a + b;
2）连接：如 “北京” + 2008 ---》 北京2008
3）正号：如 +a; int a = 5, a = +5;

- 运算符有两种身份 Subtraction Operator

1）减法：如 a - b;

2）负号：如 -a; int a = 5, a = -5;

* 运算法有一种身份 Multiplication Operator
乘法 a * b;

/ 运算符有一种身份 Division Operator
除法 a / b;

注意：当/的左右两边都为整数时，结果也将为整数，即使真实结果是小数。

% 运算法有一种身份 Remainder Operator
取模运算。
如：a % b, 表示a/b然后取余数。

练习：请使用/ 和 % 运算符，将数字1234的各位数字分离出来。

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

        int a = 1234;
        int g;
        int s;
        int b;
        int q;

        q = a / 1000;
        System.out.println("1234的千位上是：" + q);

        b = (a % 1000) / 100;
        System.out.println("1234的百位上是：" + b);
        
        s = (a % 1200) / 10;
        System.out.println("1234的十位上是：" + s);

        g = (a % 1230);
        System.out.println("1234的个位上是：" + g);

    }
}

2、赋值运算符 = Asssignment Operators

格式:
变量 = 表达式；
作用：
将等号右边表达式的值赋给左边的变量存放。
如：int a = 5 * 6 +3；

3、自增、自减运算符 ++、 -- increment operator\decrement operator
格式：
变量++ 或 ++变量；
变量-- 或 --变量；
前加： ++a; 规则：先增加后使用（赋值）
后加： a++; 规则：先使用后增加
注意：无论是前加还是后加，a的值都会增加1

如：a = 5;
b = a++;
结果为：
b = 5, a = 6;

又如：
a = 5;
b = ++a;
结果为：
b = 6, a = 6;

练习1：a = 2;
a = a++;
结果为：
a = 2;
其运算过程为：
1） 将a中的内容取出，放在临时的存储单元中；
2） a本身的存储单元内容2自增1变成3；
3） 临时存储单元的值2，存入变量a的存储单元中，正号覆盖了原来的数值3；
所以a = 2；
练习2： a = 2,
b = a++ + a++ + a++;
其结果为：
a = 5;
b = 9;
其运算过程为：
1） 第一个a++运算，将a取出为2；然后a+1=3；
2） 计算第一个 + 双目运算符，左边为2 ，右边为3，结果为5；
3） 此时a = 3；重复第1） 2）步的操作，得到a = 5，b = 9.

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

        int a = 2;
        a = a++;
        System.out.println("a = " + a);


        int c = 2;
        int b;
        b = c++ + c++ + c++;
        System.out.println("c = " + c + "\n" + "b = " + b);
        
        
    }
}

4、关系运算符 >, <, >=, <=, ==, !=, instanceof ----- Relation operators

如：boolean flag = 'a' instanceof char;

public class OpTest1 {
    public static void main(String[] args) {
        int b = 200000;
        int a = 300;
        boolean bFlag;
        bFlag =  b > a;
        System.out.println(b + "大于" + a + "?\n" + bFlag);

        bFlag = b < a;
        System.out.println(b + "小于" + a +"? \n" + bFlag);

        bFlag = (b >= a);
        System.out.println(b + "大于等于" + a + "?\n" + bFlag);

        bFlag = (b <= a);
        System.out.println(b + "小于等于" + a + "?\n" + bFlag);

        bFlag = (b == a);
        System.out.println(b + "等于" + a + "?\n" + bFlag);

        bFlag = (b !=a );
        System.out.println(b + "不等于" + a + "?\n" + bFlag);
    }
}

5、逻辑运算符：&与、|或、！非、&&短路与、||短路非 ----- Logic operators

1) &与
格式： 表达式1 & 表达式2
规则：当&符号两边的表达式均为true时，与运算表达式的值为true;反之为false.
2) |或
格式：表达式1 | 表达式2
规则：当|符号两边的表达式有一个为true时，|运算表达式的值为true；反之为false.
3) !运算
格式：！表达式
规则：当表达式为true是，费运算结果为false;反之为true.
4) && 短路与
格式： 表达式1 && 表达式2
规则：当&&符号的两边表达式值都为true时，短路与的值为true；反之为false.
注意：当短路与的表达式1为false时，表达式2中的操作将不再执行。因此提高了代码的运行效率。
5）|| 短路或
格式： 表达式1 || 表达式2
规则：当短路或符号两边的表达式有一个为false时，短路或的值为false；反之为true.
注意：当短路或的表达式1为true时，短路或将直接被赋值为true，表达式2中的代码将不再执行。
从而提高了代码的运行效率。

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

        /*    
            逻辑运算符：&与、|或、！非、&&短路与、||短路非
                1) &与
                    格式： 表达式1 & 表达式2
                    规则：当&符号两边的表达式均为true时，与运算表达式的值为true;反之为false.
                2) |或
                    格式：表达式1 | 表达式2
                    规则：当|符号两边的表达式有一个为true时，|运算表达式的值为true；反之为false.
                3) !运算
                    格式：！表达式
                    规则：当表达式为true是，费运算结果为false;反之为true.
                4) && 短路与
                    格式： 表达式1 && 表达式2
                    规则：当&&符号的两边表达式值都为true时，短路与的值为true；反之为false.
                注意：当短路与的表达式1为false时，表达式2中的操作将不再执行。因此提高了代码的运行效率。
                5）|| 短路或
                    格式： 表达式1 || 表达式2
                    规则：当短路或符号两边的表达式有一个为false时，短路或的值为false；反之为true.
                注意：当短路或的表达式1为true时，短路或将直接被赋值为true，表达式2中的代码将不再执行。
                从而提高了代码的运行效率。

        */

        int a = 4;
        int b = 6;
        System.out.println("a = " + a);
        //boolean bl = (6 < a) & (6 > ++a);        // &运算符
        //boolean bl = (6 < a) | (6 == ++a);    // |运算符
        //boolean bl = !(6 > a);                // ！运算符
        //boolean bl = (6 < a) && (6 > ++a);    // &&短路与运算符
        boolean bl =  (6 < a) || (6 > ++a);        // ||短路或运算符

        System.out.println("b1 = " + bl);
        System.out.println("a = " + a);

    }
}

6、三目运算符 Ternary Operator

格式：
表达式0 = 表达式1 ？ 表达式2 ：表达式3
规则：
当表达式1的值为true时，表达式0的值为表达式2的值，否则，表达式0等于表达式3的值。

练习1：通过三目运算符，使用一个语句比较任意三个整数的大小，并将最大值赋给三目运算符。
练习2：写一个比较两个数大小的方法，并用该方法标胶任意三个整数的大小。

public class TernaryOp {
    
    /*
        三目运算符 Ternary Operator
        格式：
            表达式0 = 表达式1 ？ 表达式2 ：表达式3
        规则：
            当表达式1的值为true时，表达式0的值为表达式2的值，否则，表达式0等于表达式3的值。
    */

    public static void main(String[] args) {

        int a = 8;
        int b = 8887;
        int c = 8392884;

        //练习1的实现方法
        int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
        System.out.println(a + "," + b +","+ c + "中的较大者是：" + max);

        //练习2的实现方法
        int middleOne = maxNum(a,b);
        int theMax = maxNum(middleOne,c);
        System.out.println(a + "," + b +","+ c + "中的较大者是：" + max);
         

    }

    public static int maxNum(int x, int y) {

        int z = x > y ? x : y;
        return z;
    
    } 

}

7、扩展赋值运算符 +=, -=, *=, /=, %= Extended Assignment operators

public class AssignOp {
    public static void main(String[] args) {
        
        /*    
            扩展的赋值运算符 Extended Assignment Operators
            +=    -=    *=    /=    %=
            作用：可以自动对数据类型进行转换后参与计算。
        */

        byte b = 127;
        short s = 489;
        int a = 10000;
        float f = 3.14f;

        b += 1;
        //b = b + 1;     //将抛出异常 “不兼容的类型: 从int转换到byte可能会有损失”     因为这里试图将int型数据赋值给byte类型
        System.out.println("byte b 用 += 赋值运算符后 b = " + b);

        s -= 30;
        //s = s - 30;     //将抛出异常 "不兼容的类型: 从int转换到short可能会有损失”     因为这里试图将int型数据赋值给short类型
        System.out.println("short s 用 -= 赋值运算符后 s = " + s);

        a /= 1.0;
        System.out.println("int a 用 /= 赋值运算符后 a = " + a);

        f *= 2.0;
        //f = f * 2.0; //     将抛出异常 “不兼容的类型: 从double转换到float可能会有损失” 因为这里试图将double类型数据赋值给float类型
        System.out.println("float f 用 *= 赋值运算符后 f = " + f);

    }
}

8、数据类型的转换

1） 自动转换
小类型数据赋值给大类型时，将自动转换为大类型数据；
使用扩展复制运算符时，也会将等号右边的数据进行自动转换。
2） 强制转换
大类型数据赋值给小类型是，需要对大类型数据进行强制转换。
如：
byte b = 120;
int a = b; ---自动转换

int a = 120;
byte b = (byte)a; ---强制转换才行，否则将在编译时抛出损失精度异常

9、在java中，表达式的数据类型如何确定?
1) 表达式中有double数据时,表达式为double类型；
2) 表达式中没有double,但是有float时,表达式为float类型；
3) 表达式中没有double,也没有float, 但是有long时,表达式为long类型；
4) 表达式中没有double, float,和 long时, 表达式为int类型。

10、Math类
Math.abs();
Math.sqrt();
Math.pow(double a, double b);
Math.round(double a);
Math.ceil(double a);
Math.floor(double a);
Math.random();

练习1、产生一个[-100,100]之间的随机整数；
练习2、产生一个[321，9999]之间的随机整数；
练习3、产生一个四舍五入，保留两位小数的随机型数据，其范围是[0, 100]。

public class HomeWork1 {
    /*
         产生一个 [-100, 100] 范围的随机整数。

         注意：random产生的随机数是 [0,1) 一个左闭右开区间
    */

    public static void main(String[] args) {

        int temp = 0;
        
        temp += Math.floor( 201 * Math.random() - 100 );
        
        System.out.println("temp = " + temp);
        
    }

}

public class HomeWork2 {
    
    /*
        练习2：    产生一个 [321,   9999] 范围的随机整数。
    */
    
    public static void main(String[] args) {
         int temp = 0;
         temp += Math.floor( Math.random() * 10321 - 321 );
         System.out.println("temp = " + temp);
    }

}

public class HomeWork3 {
    /*
        练习3：产生一个四舍五入，保留两位小数的随机型的double数, 其范围是[0, 100] 。
    */
        
    public static void main(String[] args) {

        double temp = 0;
        temp += Math.round(  10000 * Math.random()  ) ;
        temp /= 100;

        System.out.println("temp = " + temp);

    }
}

练习三有一个疑问：

当随机数取出后，当两位小数的末尾为0时，最后一位0没有显示输出。

如：29.20会显示成29.2，这是为什么？