尚学堂 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，这是为什么？