java基本语法——运算符_java 中算数运算符怎么表示

一、算术运算符。
1、算术运算符：+（加），-（减），+（正），-（负），*，/，%，(前)++，(后)++，(前)-- ，(后)–
2、除号：/
3、%:取余运算
结果的符号与被模数的符号相同
开发中，经常使用%来判断能否被除尽的情况

4、(前)++:先自增1，后运算
(后)++:先运算，后自增1
注意点：自增1不会改变本身变量的数据类型

5、(前)–:先自减1，后运算
(后)–:先运算，后自减1

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

class AriTest1{
	public static void main(String[] args){
		
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);//整型为：2

		int result2 = num1 / num2*num2;
		System.out.println(result2);//整型为：10

		//如何输出完全准确的数值，包含小数
		double result3 = num1 / num2;
		System.out.println(result3);//2.0

		double result4 = num1 / num2 + 0.0;//2.0
		double result5 = num1 / (num2 + 0.0);//2.4
		double result6 = (double)num1 / num2;//2.4
		double result6 = (double)(num1 / num2);//2.0
		System.out.println(result4);
		System.out.println(result5);
		System.out.println(result6);
		System.out.println(result7);

		//%:取余运算
		//结果的符号与被模数的符号相同
		//开发中，经常使用%来判断能否被除尽的情况
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2);

		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);

		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4);

		//(前)++:先自增1，后运算
		//(后)++:先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 +",b1 = " + b1);
		//a1=11;b1=11

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 +",b2 = " + b2);
		//a2=11;b2=10

		//注意点：自增1不会改变本身变量的数据类型
		short s1 = 10;
		//s1 = s1 + 1;编译失败，1为int型，大往小不行
		//s1 = (short)(s1 + 1);正确，进行了强转符
		s1++;//自增1不会改变本身变量的数据类型
		System.out.println(s1);
		
		//问题1：
		byte bb1 = 127;
		bb1++;
		System.out.println("bb1 = " + bb1);//-128

		//(前)--:先自减1，后运算
		//(后)--:先运算。后自减1
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

二、赋值运算符：=，+=, -=, *=, /=, %=
1、当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
2、支持连续赋值。
3、扩展赋值运算符： +=, -=, *=, /=, %=：不会改变变量本身的数据类型。

class SetValueTest{
	public static void main(String[] args){
		//赋值符号：=
		int i1 =10;
		int j1 = 10;

		int i2,j2;
		//连续赋值
		i2 = j2 = 10;

		int i3 = 10,j3 = 20;
		System.out.println(i2);

		//***************************
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2;
		System.out.println(num1);//12

		int num2 = 12;
		num2 %= 5;//num2 = num2 % 5;
		System.out.println(num2);

		short s1 = 10;
		//s1 = s1 +2; 编译失败
		s1 += 2;//不会改变变量本身的数据类型
		System.out.println(s1);

		//开发中，如果希望实现+2的操作，有几种方法？（前提：int num = 10;）
		//方式一：num = num + 2;
		//方式二：num += 2；（推荐）

		//开发中，如果希望实现+1的操作，有几种方法？（前提：int num = 10;）
		//式一：num = num + 1;
		//方式二：num += 1;（推荐）
		//方法三：num++;(推荐)

		//练习1
		int i = 1;
		i *= 0.1;
		System.out.println(i);//0
		i++;
		System.out.println(i);//1

		//练习2
		int m = 2;
		int n = 3;
		n *= m++; 
		System.out.println("m=" + m);//3
		System.out.println("n=" + n);//6

		//练习3
		int n1 = 10;
		n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);其中n1=10+10(n1先运算后+1变为11)+12(n1为11，先加1变为12后运算)
		System.out.println(n1);//32
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

三、比较运算符。
1、比较运算符：，!=,>,<,>=,<=,instanceof
2、比较运算符的结果都是boolean型，也就是要么是true，要么是false。
3、比较运算符“”不能误写成“=“。
4、“==”和“！=”：不仅可以使用在数值类型数据类型之间，还可以使用在其他引用类型变量之间。
Account acct1 = new Account(1000);
Account acct2 = new Account(1000);
acct1 == acct2;//比较两个Account是否是同一个账户，结果是：false。
acct1 != acct2;//true。
5、>,<,>=,<=：只能使用在数值类型的数据之间。

class CompareTest{
	public static void main(String[] args){
		int i = 10;
		int j = 20;
		System.out.println(i == j);//false不等
		System.out.println(i = j);//20赋值

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false不等
		System.out.println(b2 = b1);//ture赋值
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

四、逻辑运算符。
说明：逻辑运算符操作的都是Boolean类型的变量，结果也是boolean型。

区分&与&&
相同点1:&与&&的运算结果相同。
相同点2：当符号左边是true时，二者都会执行符号右边的运算。
不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
开发中，推荐使用&&。

区分|与||
相同点1：|与||的运算结果相同。
相同点2：当符号左边是false时，二者都会执行符号右边的运算。
不同点：当符号左边是true时，|继续执行符号右边的运算。||不再执行符号右边的运算。
开发中，推荐使用||。

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

		//区分&与&&
		//相同点1:&与&&的运算结果相同。
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算。
		//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		boolean b1 = true;
		//b1 = false;
		int num1 = 10;
		if (b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num1 = " + num1);
		
		boolean b2 = true;
		//b2 = false;
		int num2 = 10;
		if (b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		} 
		System.out.println("num2 = " + num2);

		//区分|与||
		//相同点1：|与||的运算结果相同。
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算。
		//不同点：当符号左边是true时，|继续执行符号右边的运算。||不再执行符号右边的运算。
		//开发中，推荐使用||
		boolean b3 = true;
		//b3 = false;
		int num3 = 10;
		if (b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);

		boolean b4 = true;
		//b4 = false;
		int num4 = 10;
		if (b4 || (num4++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

五、位运算符。
位运算是直接对整数的二进制进行的运算。
结论：
1、位运算符操作的都是整型的数据
2、<<：在一定范围内，每向左移1位，相当于*2
>>：在一定范围内，每向右移1位，相当于/2

class BitTest {
	public static void main(String[] args) {
		int i = 21;

		System.out.println("i<<2:" + (i << 2));//21*2*2==84
		System.out.println("i<<3:" + (i << 3));//21*2*2*2==168
		System.out.println("i<<26:" + (i << 26));//
		System.out.println("i<<27:" + (i << 27));//

		int m = 12;
		int n = 5;
		System.out.println("m & n =" + (m & n));//4
		System.out.println("m | n =" + (m | n));//13
		System.out.println("m ^ n =" + (m ^ n));//9
		
		//练习:交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " +num2);

		//方式一：定义临时变量的方式
		//推荐方式
		int temp = num1;
		num1 = num2;
		num2 = temp;
		System.out.println("num1 = " + num1 + ",num2 = " +num2);

		//方式二：
		//好处：不用定义临时变量
		//弊端：①相加操作可能超出存储范围 ②有局限性：只能适用于数值型。
		num1 = num1 + num2;
		num2 = num1 - num2;
		num1 = num1 - num2;
		System.out.println("num1 = " + num1 + ",num2 = " +num2);
		
		//方式三：使用位运算符
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		System.out.println("num1 = " + num1 + ",num2 = " +num2);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

例题：最高效方式的计算2*8？
2<<3 或 8<<1

六、三元运算符。
1、结构：（条件表达式）？表达式1：表达式2
2、说明：①条件表达式的结果为boolean类型；
②根据条件表达式真或假，决定执行表达式1，还是表达式2：如果表达式为true，则执行表达式1；如果表达式为false，则执行表达式2。
③表达式1和表达式2要求是一致的。
④三元运算符可以嵌套使用。
3、与if-else的联系：
①凡是可以使用三元运算符的地方，都可改写为if-else。
②反之不成立。
4、如果程序可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。

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

		//获取两个整数的最大值
		int m = 12;
		int n = 5;
		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n)? 2 : 1.0;
		//(m > n)? 2 : "n大"； 编译错误

		//***********************
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)?"m和n相等" : "n大");
		System.out.println(maxStr);

		//***********************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;

		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中最大的：" + max2);

		//不建议，可读性低
		int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中最大的：" + max3);

		//改写为if-else
		if (m > n)
		{
			System.out.println(m);
		}else{
			System.out.println(n);
		}

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41