Java基本语法——运算符的那些Tips

运算符

运算符是一种特殊的符号，用以表示数据的运算，赋值和比较等。

算数运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4；-b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模（取余）	7%5	2
++	自增（前），先运算后取值。自增（后），先取值后运算	a=2; b=++a; a=2; b=a++;	a=3; b=3; a=2; b=3
- -	自减（前），先运算后取值。自减（后），先取值后运算	a=2; b=- -a; a=2; b=a- -;	a=1; b=1; a=1; b=2
+	字符串链接	”He”+”llo”	”Hello”

对于除法“/”我们需要注意的就是做除法的时候的数据类型的判断了，不好好琢磨透的话考试的时候真的太容易错了

下面我们通过代码来看看这些需要注意的点吧

		int num1 = 12;
		int num2 = 5;
		int result = num1 / num2;
		System.out.pirntln(result); //2
		// int 和 int做运算，结果也是int型的
		
		int result2 = num1 / num2 * num2;
		System.out.println(result2); //10
		// 按照步骤来，先算num1/num2得到2，然后再乘num2，2乘5得10
		
		double result3 = num1 / num2;
		System.out,println(result3); //2.0
		//哈哈，我估计肯定有猜2.4的，但是这个result3是怎么算的呢，先算num1/num2，两个int型运算得出int型的结果，最后赋值给一个double型的数据，所以在2后面加个.0变成2.0

		//那么怎么样才能算出一个结果为2.4的答案呢
		double result4 = num1 / num2 + 0.0; //2.0 显然这个结果还是2.0，因为num1/num2还是得到2，2加0.0（整型和浮点型运算结果转换成符点型）就得到2.0
		double result5 = num1 / (num2 + 0.0); //这样结果就是2.4了吧，咱们来分析一下，首先算括号内的num2+0.0（整型和浮点型运算转换成浮点型）得到5.0，然后num1/（num2+0.0）还是整型和浮点型运算（12/0.5得到的是浮点型）结果是2.4
		double result6 = (double)num1 / num2; //这样写的话结果也为2.4吧，应该可以推出来了。当然double result6 = num1 / (double)num2;这个结果也是一样的。
		double result7 = (double)(num1 / num2); //你们可以猜猜这个result7的结果的值吗，评论区咱们讨论讨论
		System.out.println(result5); //2.4
		

然后我们说说取模“%”运算, 取模就是求余数

同样是通过代码来体现一下

		//取模结果的符号和被模数（m1，m2，m3，m4）的符号相同
		//在开发中，我们经常用%来判断能否被除尽的情况，也就是取模的结果为0则能被除尽，不为0则反之。
		int m1 = 11;
		int n1 = 5;
		System.out.println(“m1 % n1 = ” + m1 % n1); //1

		int m2 = -11;
		int n2 = 5;
		System.out.println(“m2 % n2 = ” + m2 % n2); //-1

		int m3 = 11;
		int n3 = -5;
		System.out.println(“m3 % n3 = ” + m3 % n3); //1

		int m4 = -11;
		int n4 = -5;
		System.out.println(“m4 % n4 = ” + m4 % n4); //-1

接下来说说我们非常容易搞错的++，- - 的情况，前后++，前后- -这些傻傻分不清

As the same, here goes the codes.

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

		int a1 = 10; //把10赋值给a1，所以a1为10
		int b1 = ++a1; //a1先自增1，变成11，然后11再赋值给b1，所以b1也为11
		System.out.println(“a1 = ” + a1 + “,b1 = ” + b1); //a1 = 10，b1 = 11

		int a2 = 10; //把10赋值给a2，所以a2为10
		int b2 = a2++; //先把a2的值赋给b2，所以b2为10，然后a2再自增1，所以a2为11.
		System.out.println(“a2 = ” + a2 + “,b2 = ” + b2); //a2 = 11，b2 = 10

		int a3 = 10;
		++a; //a++;
		int b3 = a3; //这样的话，不管是++a还是a++，b3的结果都为11，因为他单独运行一次，只有自增没有运算，平常的时候，我给一个数自增1通常写成a++的形式，经常放在循环语句中。


		//注意点：
		short s1 = 10;
		//s1 = s1 + 1; //编译失败
		//s1 = (short)(s1 + 1); //正确的
		s1++; //自增1不会改变本身变量的数据类型，所以如果往后代码中某个变量要自增，我们尽量写成++形式，抛弃这种s1 = s1 + 1; 的形式
		System.out.println(s1); //11

		//老师提到有一个有点意思的题
		byte c1 = 127;
		c1++