一、算术运算符。
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、扩展赋值运算符： +=, -=, *=, /=, %=：不会改变变量本身的数据类型。
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、比较运算符：
，!=,>,<,>=,<=,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赋值
}
}
四、逻辑运算符。
说明：逻辑运算符操作的都是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、<<：在一定范围内，每向左移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);
}
}
例题：最高效方式的计算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);
}
}
}