1 package cn.temptation;
2
3 public class Sample01 {
4 public static void main(String[] args) {
5 // 运算符：对常量 或是 变量进行操作的符号
6 // 分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符
7
8 // 1、算术运算符：+、-、*、/、%、++、--
9 int i = 7;
10 int j = 2;
11
12 System.out.println(i + j); // 9
13 System.out.println(i - j); // 5
14 System.out.println(i * j); // 14
15 // int类型的变量 和 int类型的变量做除法，得到的结果是int类型
16 System.out.println(i / j); // 3
17
18 // 要求：就想得到3.5的结果，怎么办？
19 // 下面的写法不会得到3.5的结果，只会得到3.0的结果，因为只是声明了一个double类型的变量来接收int类型变量和int类型变量相除的结果
20 // 对于相除的结果没有内容上的影响
21 double result = i / j;
22 System.out.println(result); // 3.0
23 System.out.println((double)(i / j)); // 3.0
24
25 // 做一个尝试：使用double类型的字面量常量 和 int类型的字面量常量做除法，会得到double类型的字面量常量
26 // 即int类型的字面量常量在做除法时进行了类型提升
27 System.out.println(7.0 / 2); // 3.5
28
29 // 类型的提升：把int类型的变量先和double类型的字面量常量1.0做乘法，让结果为double类型，再除以int类型的变量，得到的是double类型的结果
30 System.out.println(i * 1.0 / j); // 3.5
31
32 System.out.println(i % j); // 1
33 }
34 }
1 package cn.temptation;
2
3 public class Sample02 {
4 public static void main(String[] args) {
5 // 减号 - 还可以做负号
6 byte i = 1;
7 // Type mismatch: cannot convert from int to byte
8 // byte j = -i;
9 byte j = (byte) -i;
10 System.out.println(i);
11 System.out.println(j);
12
13 byte x = -128;
14 byte y = (byte) -x;
15 System.out.println(x); // -128
16 System.out.println(y); // -128
17
18 /*
19 * x： -128（没有超出byte范围）
20 * -x： 128（int类型）：0000 0000 0000 0000 0000 0000 1000 0000
21 * 因为强制类型转换为byte类型的变量y，所以要做截取
22 *
23 * 补码： 1000 0000 符号位的1表明是负数
24 * 反码： 1111 1111
25 * 原码： 1000 0000
26 */
27
28 // 产生异常：java.lang.ArithmeticException: / by zero
29 // int k = 123 / 0;
30 // System.out.println(k);
31
32 // 产生异常：java.lang.ArithmeticException: / by zero
33 // int k = 0 / 0;
34 // System.out.println(k);
35
36 // double k = 123.45 / 2;
37 // System.out.println(k); // 61.725
38 //
39 // double m = 123.45 / 0;
40 // System.out.println(m); // Infinity（正无穷大）
41 //
42 // double n = -123.45 / 0;
43 // System.out.println(n); // -Infinity（负无穷大）
44 //
45 // double result1 = 0.0 / 0;
46 // System.out.println(result1); // NaN（Not a Number 不是一个数）
47 //
48 // double result2 = -0.0 / 0;
49 // System.out.println(result2); // NaN（Not a Number 不是一个数）
50
51 // float k = 123.45F / 2;
52 // System.out.println(k); // 61.725
53 //
54 // float m = 123.45F / 0;
55 // System.out.println(m); // Infinity（正无穷大）
56 //
57 // float n = -123.45F / 0;
58 // System.out.println(n); // -Infinity（负无穷大）
59 //
60 // float result1 = 0.0F / 0;
61 // System.out.println(result1); // NaN（Not a Number 不是一个数）
62 //
63 // float result2 = -0.0F / 0;
64 // System.out.println(result2); // NaN（Not a Number 不是一个数）
65
66 int result1 = 11 % 4;
67 System.out.println(result1); // 3
68
69 double result2 = 11.0 % 3;
70 System.out.println(result2); // 2.0
71
72 double result3 = 11.0 % 3.5;
73 System.out.println(result3); // 0.5
74
75 // 产生异常：java.lang.ArithmeticException: / by zero
76 // int result4 = 11 % 0;
77 // System.out.println(result4);
78
79 double result5 = 11.0 % 0;
80 System.out.println(result5); // NaN（Not a Number 不是一个数）
81 }
82 }
1 package cn.temptation;
2
3 public class Sample03 {
4 public static void main(String[] args) {
5 // ++ 自增运算符 -- 自减运算符
6 int i = 2;
7 System.out.println(i); // 2
8
9 // 1、单独使用自增运算符：不论++放在需要自增的变量的后面还是前面，都会在操作后让变量的值自增1
10 // 自增运算符放在需要自增的变量的后面
11 // i++;
12 // 自增运算符放在需要自增的变量的前面
13 // ++i;
14
15 // System.out.println(i); // 3
16
17 // 2、非单独使用自增运算符
18 // 下句语句一上来先把i的值赋值给j，然后i自己做自增（先赋值再自增）
19 // int j = i++; // j = 2, i = 3
20 // 下句语句一上来先i自己做自增，然后把i的值（自增后的值）赋值给j（先自增再赋值）
21 int j = ++i; // j = 3, i = 3
22
23 System.out.println("j的值为：" + j);
24 System.out.println("i的值为：" + i);
25 }
26 }
1 package cn.temptation;
2
3 public class Sample04 {
4 public static void main(String[] args) {
5 // 关于自增的一道题
6 int i = 2;
7 int j = 3;
8
9 j = i++;
10
11 System.out.println("i的值为：" + i); // 3
12 System.out.println("j的值为：" + j); // 2
13
14 // j = i++ + ++i+i*4;
15 // 上句等价于
16 j = (i++) + (++i) + (i * 4);
17 /*
18 * 计算过程：
19 * i++这个表达式，此时i为3，首先是赋值，再让i自增，所以这个表达式(i++)的结果为3，i操作后的值为4
20 * ++i这个表达式，此时i为4，首先让i自增，再赋值，所以i操作后的值为5，这个表达式(++i)的结果为5
21 * i * 4这个表达式，此时i为5，进行乘法，所以这个表达式(i*4)的结果为20
22 *
23 * 最后三个表达式的结果相加：3 + 5 + 20 = 28
24 */
25
26 System.out.println(j);
27 }
28 }
1 package cn.temptation;
2
3 public class Sample05 {
4 public static void main(String[] args) {
5 // 加号 + 的用法：
6 /*
7 * 1、作为算术运算符的加号
8 * 2、作为正数的符号 +
9 * 3、作为字符串的连接符号
10 */
11 int result = 1 + 2;
12 System.out.println(result);
13
14 int x = +99;
15 System.out.println(x);
16
17 System.out.println("北京" + 2008);
18 }
19 }
1 package cn.temptation;
2
3 public class Sample06 {
4 public static void main(String[] args) {
5 // 2、赋值运算符：=、+=、-=、*=、/=、%=
6
7 // Java中的一个等号 = 表示的是将等号（赋值号）右侧的内容赋值给等号（赋值号）左侧的变量，习惯上称之为赋值号
8
9 int i = 2;
10 // 完整描述：把整型的字面量常量2 赋值给 整型类型的变量i
11 // 赋值号左侧的部分称为声明
12 // 赋值号右侧的部分称为赋值
13 System.out.println(i);
14
15 // 一行语句中声明多个变量
16 int x, y;
17
18 // 下句语句先把123赋值给变量y，再将y赋值给x，所以最后x和y的值均为123
19 x = y = 123;
20
21 System.out.println(x);
22 System.out.println(y);
23
24 // 以+=为例，表示的是将赋值号（+=）左侧的变量 和 右侧的内容按照=之前的运算符进行相应的运算，操作后的结果再赋值给左侧的变量
25 int j = 3;
26 System.out.println(j); // 3
27 // j += 4;
28 // 上句等价于
29 j = j + 4;
30 System.out.println(j); // 7
31
32 // byte k = 5;
33 // // Type mismatch: cannot convert from int to byte
34 // k = k + 3;
35 // System.out.println(k);
36
37 // 对于非默认数据类型的数据，使用带有算术运算符的赋值运算符时，会自动进行强制类型转换
38 byte k = 5;
39 // k += 3;
40 // 上句等价于
41 k = (byte) (k + 3);
42 System.out.println(k);
43 }
44 }
1 package cn.temptation;
2
3 public class Sample07 {
4 public static void main(String[] args) {
5 // 3、比较运算符：==、!=、>、<、>=、<=
6
7 // Java中使用 == 表示相等（内容相等）
8 // 比较的结果必然是一个boolean类型的值
9 int i = 2;
10 int j = 3;
11 int k = 2;
12
13 // System.out.println(i == j); // false
14 // System.out.println(i == k); // true
15 // System.out.println(i + j == j + k); // true
16 // 上句等价于
17 // System.out.println((i + j) == (j + k)); // true
18
19 System.out.println(i != j); // true
20 System.out.println(i != k); // false
21
22 System.out.println(i > j); // false
23 System.out.println(i < j); // true
24 System.out.println(i >= j); // false
25 System.out.println(i <= j); // true
26
27 System.out.println(k <= k); // true
28 }
29 }
1 package cn.temptation;
2
3 public class Sample08 {
4 public static void main(String[] args) {
5 // 逻辑运算符：&、|、!、^、&&、||
6 // 参与运算的变量或表达式的值均为boolean类型
7
8 /*
9 * &：逻辑与，有一个是false得到的结果就是false
10 * |：逻辑或，有一个是true得到的结果就是true
11 * !：逻辑非，颠倒黑白
12 * ^：逻辑异或，类似吸铁石
13 */
14 // System.out.println(true & true); // true
15 // System.out.println(true & false); // false
16 // System.out.println(false & true); // false
17 // System.out.println(false & false); // false
18
19 // System.out.println(true | true); // true
20 // System.out.println(true | false); // true
21 // System.out.println(false | true); // true
22 // System.out.println(false | false); // false
23
24 // System.out.println(!true); // false
25 // System.out.println(!false); // true
26
27 // System.out.println(true ^ true); // false
28 // System.out.println(true ^ false); // true
29 // System.out.println(false ^ true); // true
30 // System.out.println(false ^ false); // false
31
32 /*
33 * &&：逻辑与（聪明与/短路与）如果参与运算的第一个变量或表达式为false，得到的结果就是false，其他的变量或表达式就不去执行；如果多个逻辑与参与运算，以此类推
34 * ||：逻辑或（聪明或/短路或）如果参与运算的第一个变量或表达式为true，得到的结果就是true，其他的变量或表达式就不去执行；如果多个逻辑或参与运算，以此类推
35 */
36 // System.out.println(true && true); // true
37 // System.out.println(true && false); // false
38 // // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
39 // System.out.println(false && true); // false
40 // // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
41 // System.out.println(false && false); // false
42
43 // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
44 System.out.println(true || true); // true
45 // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
46 System.out.println(true || false); // true
47 System.out.println(false || true); // true
48 System.out.println(false || false); // false
49
50 // 在实际的开发中，常用的是：!、^、&&、||
51 }
52 }
1 package cn.temptation;
2
3 public class Sample09 {
4 public static void main(String[] args) {
5 // 结合自增 和 逻辑运算符的一道题
6 int i = 2;
7 int j = 3;
8
9 System.out.println((++i == 2) && (j++ == 3)); // false
10 // 因为++i先自增再赋值，表达式++i的结果为3，所以++i == 2这个表达式的结果为false
11 // 又因为使用聪明与，第一个表达式为false，后续的表达式不会执行，所以i = 3， j = 3
12
13 // 问：最终显示i和j的值为多少？
14 System.out.println(i); // 3
15 System.out.println(j); // 3
16 }
17 }
1 package cn.temptation;
2
3 public class Sample10 {
4 public static void main(String[] args) {
5 // 位运算符：&、|、~、^、>>、>>>、<<
6 /*
7 * 规则：（在二进制中）操作的是补码
8 * &：位与，进行操作的两个数的同一位上，有一个是0，该位运算的结果就是0
9 * |：位或，进行操作的两个数的同一位上，有一个是1，该位运算的结果就是1
10 * ~：位非，进行操作的数按位取反
11 * ^：位异或，进行操作的两个数的同一位上，两个相同为0，两个不同为1
12 */
13 // System.out.println(2 & 3); // 2
14 // System.out.println(2 | 3); // 3
15 // System.out.println(~2); // -3
16 // System.out.println(2 ^ 3); // 1
17 /*
18 * 2：0000 0010
19 * 3：0000 0011
20 *
21 * 2
22 * 原码：0000 0000 0000 0000 0000 0000 0000 0010
23 * 反码：0000 0000 0000 0000 0000 0000 0000 0010
24 * 补码：0000 0000 0000 0000 0000 0000 0000 0010
25 *
26 * ~2：（操作补码）
27 * 补码：1111 1111 1111 1111 1111 1111 1111 1101
28 * 反码：1111 1111 1111 1111 1111 1111 1111 1100
29 * 原码：1000 0000 0000 0000 0000 0000 0000 0011
30 */
31
32 // 位异或^的用法：
33 // 规律：一个数连续两次和另一个数做位异或运算，得到其本身的值
34 // 可以应用在简单的加密解密中，连续两次进行位异或的那个数可以设置为密钥
35 System.out.println(2 ^ 3 ^ 3); // 2
36
37 /*
38 * <<：左移，左边的高位删除，右边的低位补0
39 * >>：右移，因为左侧的最高位是符号位，所以要区分是0还是1：左侧的最高位是0，左侧补0；左侧的最高位是1，左侧补1
40 * >>>：无符号右移，不论左侧的最高位是0还是1，左侧补0
41 */
42 System.out.println(2<<1); // 4
43 System.out.println(2>>1); // 1
44 System.out.println(-2>>1); // -1
45 System.out.println(-2>>>1); // 2147483647
46 /*
47 * -2：
48 * 原码：1000 0000 0000 0000 0000 0000 0000 0010
49 * 反码：1111 1111 1111 1111 1111 1111 1111 1101
50 * 补码：1111 1111 1111 1111 1111 1111 1111 1110
51 *
52 * 右移1位操作（操作补码）
53 * 补码：1111 1111 1111 1111 1111 1111 1111 1111
54 * 反码：1111 1111 1111 1111 1111 1111 1111 1110
55 * 原码：1000 0000 0000 0000 0000 0000 0000 0001
56 *
57 * 无符号右移1位操作（操作补码）
58 * 补码：0111 1111 1111 1111 1111 1111 1111 1111
59 * 反码：0111 1111 1111 1111 1111 1111 1111 1111
60 * 原码：0111 1111 1111 1111 1111 1111 1111 1111
61 */
62 }
63 }
1 package cn.temptation;
2
3 public class Sample11 {
4 public static void main(String[] args) {
5 // 依据参与运算的元素个数分类：
6 // 1、一元运算符：!、~
7 // 2、二元运算符：+、-、*、/、%、&、|、&&、||、^等等
8 // 3、三元运算符：由两个符号组成的复合运算符 ? :
9
10 // 三元运算符：只有一个
11 // 格式：(比较表达式) ? (比较表达式为真值时，执行的内容) : (比较表达式为假值时，执行的内容);
12
13 int i = 2;
14 int j = 3;
15 int result = ((i > j) ? i : j);
16 System.out.println(result);
17 }
18 }
1 package cn.temptation;
2
3 public class Sample12 {
4 public static void main(String[] args) {
5 // 需求：取得给定的两个数字中较大的一个（使用三元运算符来做）
6 // int x = 28;
7 // int y = 17;
8 // int max = (x > y) ? x : y;
9 // System.out.println(max);
10
11 // 需求：取得给定的三个数字中最大的一个（使用三元运算来做）
12 /*
13 * 思路：
14 * 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
15 * 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较，如果剩下的那个数字比它大，那么剩下的那个数字就是最大的
16 * 否则，比较出来的较大的那个数字就是最大的
17 */
18 int a = 5;
19 int b = 4;
20 int c = 6;
21
22 // 分步操作
23 // // 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
24 // int temp = (a > b) ? a : b;
25 // // 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较
26 // int max = (temp > c) ? temp : c;
27 // System.out.println("最大的数字为：" + max);
28
29 // 如果就要在一行语句中写，如何实现？需要使用三元运算符的嵌套
30 // 如下写法，在实际开发中不要这样写，可读性很差，纯炫技耳！
31 int max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
32 System.out.println("最大的数字为：" + max);
33 }
34 }
1 package cn.temptation;
2
3 import java.util.Scanner;
4
5 public class Sample13 {
6 public static void main(String[] args) {
7 // 需求：通过键盘的录入，把输入的数据赋值给变量（交互操作的需求）
8
9 // 创建一个扫描器对象
10 Scanner input = new Scanner(System.in);
11 System.out.println("输入一个数字：");
12 // 接收用户的键盘的录入，并赋值给声明的变量
13 int i = input.nextInt();
14 // 扫描器对象使用完毕后，关闭
15 input.close();
16
17 System.out.println("用户通过键盘录入的数字为：" + i);
18 }
19 }
1 package cn.temptation;
2
3 import java.util.Scanner;
4
5 public class Sample14 {
6 public static void main(String[] args) {
7 // 需求：通过键盘录入三个数字，比较获取其中最大的一个
8
9 // 声明三个变量来接收键盘录入的三个数字
10 Scanner input = new Scanner(System.in);
11 System.out.println("输入第一个数字：");
12 int i = input.nextInt();
13 System.out.println("输入第二个数字：");
14 int j = input.nextInt();
15 System.out.println("输入第三个数字：");
16 int k = input.nextInt();
17 input.close();
18
19 // 分步操作
20 int temp = (i > j) ? i : j;
21 int max = (temp > k) ? temp : k;
22 System.out.println("输入的数字：" + i + "," + j + "," + k + "中，最大的数字为：" + max);
23 }
24 }
