算术运算符

//除号：/
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 result4 = num1 /num2 + 0.0;//2.0
double result5 = num1 /(num2 + 0.0);//2.4
double result6 = (double)num1 /num2;//2.4
double result7 = (double)(num1 /num2);//2.0
System.out.println(result5);
System.out.println(result6);

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

//(前)++ :先自增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);//a1: 11 b1: 10
int a3 = 10;
++a3;//a3++
int b3 = a3;
//注意点
short s1 = 10;
//s1 = s1 + 1;//编译失败
s1 = (short)(s1+1);//正确的
s1++;//自增1不会改变本身变量的数据类型
byte by1 = 127;
by1++;
System.out.println(by1);//-128

//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
int a4 = 10;
int b4 = a4--;
System.out.println("a4: " + a4 + " b4: "+ b4);//a4: 9 b4: 10
byte by2 = -128;
by2--;
System.out.println(by2);//127

赋值运算符

符号：=
- 当=两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
- 支持连续赋值
扩展赋值运算符：+=，-=，*=，/=，%=

//赋值符号：=
int i1 = 10;
int j1 = 10;
int i2,j2;
//连续赋值
i2=j2=10;
int i3=10,j3=10;
int num =10;
num += 2;
System.out.println(num);//12
int num2 = 12;
num2 %= 5;
System.out.println(num2);
//开发中，如果希望变量实现+2操作，有几种方法？(前提：int num = 10)
//方式一：num = num +2;
//方式二：num += 2;(推荐)
//开发中，如果希望变量实现+1操作，有几种方法？(前提：int num = 10)
//方式一：num = num +1;
//方式二：num += 1;
//方式三：num++;(推荐)
//练习一
short s1 = 10;
//s1 = s1 + 2;//编译失败
s1 += 2;//不会改变变量自身的数据类型
System.out.println(s1);
//练习二
int i =1;
i*=0.1;
System.out.println(i);//1
i++;
System.out.println(i);
//练习三
int m = 2;
int n = 3;
n *= m++;
System.out.println("m="+m);
System.out.println("n="+n);
//练习四
int n1 = 10;
n1 +=(n1++) + (++n1);
System.out.println(n1);//32

比较运算符

比较运算符的结果都是boolean型，也就是要么是true,要么是false
比较运算符“==”不能误写成“=”

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);//true

逻辑运算符

&：逻辑与。|：逻辑或。！：逻辑非
&&：短路与。||：短路或。^：逻辑异或
逻辑运算符操作的都是boolean类型的变量

//区分&与&&
//相同点1：&与&&的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点3：当符号左边是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);
//输出否
//num1: 11
boolean b2 = true;
b2=false;
int num2 =10;
if(b2&&(num2++>0)){
    System.out.println("是");
}else{
    System.out.println("否");
}
System.out.println("num2: " + num2);
//输出否
//num2: 10
//区分|与||
//相同点1：|与||的运算结果相同
//相同点2：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|会继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中推荐使用||
boolean b3 = true;
int num3 =10;
if(b3|(num3++>0)){
    System.out.println("是");
}else{
    System.out.println("否");
}
System.out.println("num3: " + num3);
//输出是
//num3: 11
boolean b4 = true;
int num4 =10;
if(b4 || (num4++>0)){
    System.out.println("是");
}else{
    System.out.println("否");
}
System.out.println("num4: " + num4);
//输出是
//num4: 10

位运算符

位运算符是直接对整数的二进制进行的运算
<<:在一定范围内，每向左移一位，相当于*2
:在一定范围内，每向右移一位，相当于/2

int i = 21;
i =-21;
System.out.println("i << 2 :"+(i<<2));//-84
System.out.println("i << 3 :"+(i<<3));//-168
System.out.println("i << 27 :"+(i<<27));//1476395008
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 k=6;
System.out.println(~k);//-7

//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1:"+num1+" num2: "+num2);
//方式一:定义临时变量的方式
int temp = num1;
num1 = num2;
num2 = temp;
//方式二：相加的方式
//好处：不用定义临时变量
//弊端：①相加操作可能超出存储范围②有局限性，只能适用于数值类型
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
//方式三：使用位运算符
//有局限性，只能适用于数值类型
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println("num1:"+num1+" num2: "+num2);

三元运算符

(条件表达式)?表达式1:表达式2
- 条件表达式为true,运算后的结果是表达式1
- 条件表达式为false,运算后的结果是表达式2
表达式1和表达式2为同种类型

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);//1.0
//三目运算符中的Integer型的数字1会自动提升为1.0.以与后面的类型相同

三元运算符与if-else的联系与区别
- 三元运算符可以简化if-else语句
- 三元运算符要求必须返回一个结果
- if后的代码块可有多个语句

//获取两个整数的较大值
int m = 12;
int n = 5;
int max = (m>n)? m : n;
System.out.println(max);//12
double num = (m>n)?2:1.0;
//(m>n)?2:"n大";//编译错误
int a=5;
int b=12;
String maxStr = (a>b)?"a大":((a==b)?"a和b相等":"b大");
System.out.println(maxStr);//b大
//获取三个数的最大值
int n1 = 12;
int n2 = 30;
int n3 = -23;
int max1 = (n1>n2)?n1:n2;
int max2 = (max1>n3)?max1:n3;
System.out.println("三个数中最大的是："+max2);//30
int max3 = (((n1>n2)?n1:n2)>n3)?((n1>n2)?n1:n2):n3;//不建议这样编写
System.out.println("三个数中最大的是："+max2);//30

运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总是优先于下一行
只有单目运算符，三元运算符，赋值运算符是从右向左运算的。

总结

运算符之一：算术运算符
	+ - * / (前)++ (后)++ (前)-- (后)-- +(连接符)
	%:取余运算
		结果的符号与被模数的符号相同
		开发中，经常使用%来判断能否被除尽的情况
	(前)++ :先自增1，后运算
	(后)++ :先运算，后自增1
	(前)-- :先自减1，后运算
	(后)-- :先运算，后自减1
		不会改变本身变量的数据类型
运算符之二：赋值运算符
	= += -= *= /= %=
	不会改变变量自身的数据类型
运算符之三：比较运算符
	== != < > <= >= instanceof
	1.比较运算符的结果是boolean类型
	2.区分==和=
运算符之四：逻辑运算符
	&,&&,|,||,^,!
	1.逻辑运算符操作的都是boolean类型的变量
运算符之五：位运算符
	<< >> >>> & | ^ ~
	1.位运算符操作的都是整型的数据
	2.<<:在一定范围内，每向左移一位，相当于*2
	  >>:在一定范围内，每向右移一位，相当于/2
	面试题：最高效的方式计算2*8？2<<3或8<<1
运算符之六：三元运算符
	(条件表达式)?表达式1:表达式2
	1.条件表达式的结果为boolean类型
	2.根据条件表达式真或假，决定执行表达式1还是表达式2
	3.表达式1和表达式2要求是一致的
	4.三元运算符可以嵌套使用
	5.凡是可以用三元运算符的地方都可以改写成if-else结构。
	反之不可以
	6.如果程序既可以用三元运算符还可以用if-else结构。
	那么推荐使用三元运算符。原因：简洁，执行效率高