06-运算符

1.算术运算符： + - * / % (前)++ (后)++ (前)-- (后)-- +

【典型代码】

 1     //除号：/
 2 
 3         int num1 = 12;
 4 
 5         int num2 = 5;
 6 
 7         int result1 = num1 / num2;
 8 
 9         System.out.println(result1);//2
10 
11         // %:取余运算
12 
13         //结果的符号与被模数的符号相同
14 
15         //开发中，经常使用%来判断能否被除尽的情况。
16 
17         int m1 = 12;
18 
19         int n1 = 5;
20 
21         System.out.println("m1 % n1 = " + m1 % n1);
22 
23 
24 
25         int m2 = -12;
26 
27         int n2 = 5;
28 
29         System.out.println("m2 % n2 = " + m2 % n2);
30 
31 
32 
33         int m3 = 12;
34 
35         int n3 = -5;
36 
37         System.out.println("m3 % n3 = " + m3 % n3);
38 
39 
40 
41         int m4 = -12;
42 
43         int n4 = -5;
44 
45         System.out.println("m4 % n4 = " + m4 % n4);
46 
47         //(前)++ :先自增1，后运算
48 
49         //(后)++ :先运算，后自增1
50 
51         int a1 = 10;
52 
53         int b1 = ++a1;
54 
55         System.out.println("a1 = " + a1 + ",b1 = " + b1);
56 
57         
58 
59         int a2 = 10;
60 
61         int b2 = a2++;
62 
63         System.out.println("a2 = " + a2 + ",b2 = " + b2);
64 
65         
66 
67         int a3 = 10;
68 
69         ++a3;//a3++;
70 
71         int b3 = a3;
72 
73         //(前)-- :先自减1，后运算
74 
75         //(后)-- :先运算，后自减1
76 
77         
78 
79         int a4 = 10;
80 
81         int b4 = a4--;//int b4 = --a4;
82 
83         System.out.println("a4 = " + a4 + ",b4 = " + b4);

【特别说明的】

1》.//(前)++ :先自增1，后运算

　　//(后)++ :先运算，后自增1

2》.//(前)-- :先自减1，后运算

　　//(后)-- :先运算，后自减1

3》.连接符：+：只能使用在String与其他数据类型变量之间使用。

2.赋值运算符：= += -= *= /= %=

【典型代码】

 1 int i2,j2;
 2 
 3         //连续赋值
 4 
 5         i2 = j2 = 10;
 6 
 7         //***************
 8 
 9         int i3 = 10,j3 = 20;
10 
11         int num1 = 10;
12 
13         num1 += 2;//num1 = num1 + 2;
14 
15         System.out.println(num1);//12
16 
17 
18 
19         int num2 = 12;
20 
21         num2 %= 5;//num2 = num2 % 5;
22 
23         System.out.println(num2);
24 
25 
26 
27         short s1 = 10;
28 
29         //s1 = s1 + 2;//编译失败
30 
31         s1 += 2;//结论：不会改变变量本身的数据类型
32 
33         System.out.println(s1);

【特别说明的】

1》.运算的结果不会改变变量本身的数据类型

2》.

//开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)

//方式一：num = num + 2;

//方式二：num += 2; (推荐)

//开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)

//方式一：num = num + 1;

//方式二：num += 1;

//方式三：num++; (推荐)

3.比较运算符（关系运算符）: == != > < >= <= instanceof

【典型代码】

 1　　　　　 int i = 10;
 2 
 3         int j = 20;
 4 
 5 
 6 
 7         System.out.println(i == j);//false
 8 
 9         System.out.println(i = j);//20
10 
11 
12 
13         boolean b1 = true;
14 
15         boolean b2 = false;
16 
17         System.out.println(b2 == b1);//false
18 
19         System.out.println(b2 = b1);//true

【特别说明的】

1》.比较运算符的结果是boolean类型

2》.> < >= <= :只能使用在数值类型的数据之间。

3》. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。

Account acct1 = new Account(1000);

Account acct2 = new Account(1000);

boolean b1 = (acct1 == acct2);//比较两个Account是否是同一个账户。

boolean b2 = (acct1 != acct2);//

4.逻辑运算符：& && | || ! ^

【典型代码】

【特别说明的】

1.逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型

  1 //区分& 与 &&
  2 
  3         //相同点1：& 与  && 的运算结果相同
  4 
  5         //相同点2：当符号左边是true时，二者都会执行符号右边的运算
  6 
  7         //不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
  8 
  9         //开发中，推荐使用&&
 10 
 11         boolean b1 = true;
 12 
 13         b1 = false;
 14 
 15         int num1 = 10;
 16 
 17         if(b1 & (num1++ > 0)){
 18 
 19             System.out.println("我现在在北京");
 20 
 21         }else{
 22 
 23             System.out.println("我现在在南京");
 24 
 25         }
 26 
 27 
 28 
 29         System.out.println("num1 = " + num1);
 30 
 31         
 32 
 33 
 34 
 35         boolean b2 = true;
 36 
 37         b2 = false;
 38 
 39         int num2 = 10;
 40 
 41         if(b2 && (num2++ > 0)){
 42 
 43             System.out.println("我现在在北京");
 44 
 45         }else{
 46 
 47             System.out.println("我现在在南京");
 48 
 49         }
 50 
 51 
 52 
 53         System.out.println("num2 = " + num2);
 54 
 55 
 56 
 57         // 区分：| 与 || 
 58 
 59         //相同点1：| 与  || 的运算结果相同
 60 
 61         //相同点2：当符号左边是false时，二者都会执行符号右边的运算
 62 
 63         //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
 64 
 65         //开发中，推荐使用||
 66 
 67         boolean b3 = false;
 68 
 69         b3 = true;
 70 
 71         int num3 = 10;
 72 
 73         if(b3 | (num3++ > 0)){
 74 
 75             System.out.println("我现在在北京");
 76 
 77         }else{
 78 
 79             System.out.println("我现在在南京");
 80 
 81         }
 82 
 83         System.out.println("num3 = " + num3);
 84 
 85 
 86 
 87 
 88 
 89         boolean b4 = false;
 90 
 91         b4 = true;
 92 
 93         int num4 = 10;
 94 
 95         if(b4 || (num4++ > 0)){
 96 
 97             System.out.println("我现在在北京");
 98 
 99         }else{
100 
101             System.out.println("我现在在南京");
102 
103         }
104 
105         System.out.println("num4 = " + num4);

5.位运算符：<< >> >>> & | ^ ~

【典型代码】

 1 int i = 21;
 2 
 3         i = -21;
 4 
 5         System.out.println("i << 2 :" + (i << 2));
 6 
 7         System.out.println("i << 3 :" + (i << 3));
 8 
 9         System.out.println("i << 27 :" + (i << 27));
10 
11 
12 
13         int m = 12;
14 
15         int n = 5;
16 
17         System.out.println("m & n :" + (m & n));
18 
19         System.out.println("m | n :" + (m | n));
20 
21         System.out.println("m ^ n :" + (m ^ n));

【面试题】你能否写出最高效的2 * 8的实现方式？

答案：2 << 3 或 8 << 1

【特别说明的】

1》. 位运算符操作的都是整型的数据

2》. << ：在一定范围内，每向左移1位，相当于 * 2

>> :在一定范围内，每向右移1位，相当于 / 2

6.三元运算符：(条件表达式)? 表达式1 : 表达式2

【特别说明的】

1》. 说明

① 条件表达式的结果为boolean类型

② 根据条件表达式真或假，决定执行表达式1，还是表达式2.

如果表达式为true，则执行表达式1。

如果表达式为false，则执行表达式2。

③ 表达式1 和表达式2要求是一致的。

④ 三元运算符可以嵌套使用

2》.

凡是可以使用三元运算符的地方，都可以改写为if-else

反之，不成立。

3》. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。