// 除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1); //2
double result2 = num1 / num2;
System.out.println(result2); //2.0
double result3 = num1 / num2 + 0.0;
System.out.println(result3); //2.0
double result4 = num1 / (num2+0.0);
System.out.println(result4); //2.4
double result5 = (double)num1 / num2;
System.out.println(result5); //2.4
// 取模(取余)：%
// 结果的符号与被模数的符号相同（m % n 中的m就是被模数）
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);
/* 结果
m1 % n1 = 2
m2 % n2 = -2
m3 % n3 = 2
m4 % n4 = -2
*/
// 负负得正
int num1 = -1;
System.out.println(-num1); //1
++：对于自增变量本身来说，都会+1
? 但是++在前还是在后，对于整个表达式的计算来说是不一样的。
? ++在前，先自增，然后取自增后的变量值。
? ++在后，先取变量的值，然后变量自增。
public static void main(String[] args) {
int m = 1;
int n = ++m;
System.out.println(m);//2
System.out.println(n);//2
//m先自增，然后把m的值取出来赋值给n
System.out.println("-----------");
int a = 1;
int b = a++;
System.out.println(a);//2
System.out.println(b);//1
//（1）先取出a的值“1”，先放到一个“操作数栈”（2）然后a变量完成自增（3）把刚才放在“操作数栈中的值赋值给b”
System.out.println("-----------");
int z = 1;
z = z++;
System.out.println(z);//1
//（1）先取出z的值“1”，先放到一个“操作数栈”（2）然后z自增，变为2（3）把刚才放在“操作数栈”中的值赋值给z
}
自增1不会改变本身变量的数据类型
short s1 = 10;
// s1 = s1 + 1; // 报错 编译失败
s1 += 1 // 不会改变变量本身的数据类型
// 因为1是int类型，short和int运算之后是int类型，但是你赋给的s1还是short类型
s1 = (short)(s1 + 1); // 这样等他们运算完了吧他强转成short类型就好了
s1++; // 这样也可以，自增1不会改变本身变量的数据类型
System.out.println(s1);
//---------------------------
byte b1 = 127;
b1++;
System.out.println(b1); // -128
// 127的二进制是 0111 1111 加1之后二进制变成 1000 0000 就是-128
逻辑运算符操作的都是布尔类型的变量
&:逻辑与 对应python中的 and
|:逻辑或 对应python中的 or
^:逻辑非 对应python中的 not
&& -- || -- 的意思也是与和或，只不过这样写是 遵循 短路原则
^:逻辑异或 这个的意思就是 异 不同的
例子：如果a和b 同为true或false 那么 a^b 就是false
如果a和b 一个是true一个是false 那么a^b 就是true
（异嘛，就是a和b不同时为true）
位运算符操作的都是整型的数据
左移：<<
运算规则：<<几位，就乘以2的几次方
System.out.println(4 << 3);//等于4乘以2的3次方，结果是32
//0000 0100这个二进制表示的是4
//左移三位是0010 0000，这个二进制表示的是32
右移：>>
System.out.println(32 >> 4);//等于32除以2的4次方，结果是2
//0010 0000右移4位就是0000 0010等于2
System.out.println(-32 >> 4);//-2
/*
-32的二进制：
原码1010 0000
反码1101 1111
补码1110 0000
右移四位是 1111 1110（负数前面补1）（符号位是1就补1，符号位是0就补0）
补码1111 1110
反码1111 1101
原码1000 0010（到这就是完事了是-2）
*/
无符号右移：>>>
按为与：&
按位或：|
按位异或：^
^运算，结果是0： 1^1=0 0^0=0^运算，结果是1： 1^0=1 0^1=1按位取反：~
练习题：写出2 * 8最高效的实现方式。答：2 << 3 或 8 << 1
int max = x > y ? x:y; // 这是三元运算符
System.out.println(max);
/*等价于
if(x > y) {
max = x;
}else {
max = y;
}
*/
通用的方案：使用与任意的数据类型
? 借助于第三个同样类型的临时变量
int x = 1;
int y = 2;
int temp = x;
x = y;
y = temp;
System.out.println(x);
System.out.println(y);
方法二：（只适用于int等整数类型）
int x = 1;
int y = 2;
x = x ^ y;
y = x ^ y;
x = x ^ y;
System.out.println(x);
System.out.println(y);
方法三：（只适用于int等整数类型）
有风险，可能会溢出，有局限性，只能用于数值类型
x = x + y;
y = x - y;//（新的x）-原来的y=（原来的x + 原来的y） - 原来的y = 原来的x
x = x - y;//（新的x） -新的y = （原来的x + 原来的y）-原来的x =原来的y
条件判断
语法格式
if(条件表达式){
当该条件表达式成立时，需要执行的语句;
}else{
当该条件表达式不成立时，执行的语句;
}
if(条件表达式){
当该条件表达式成立时，需要执行的语句;
}
if(条件表达式){
当该条件表达式成立时，需要执行的语句;
}else if(条件表达式2){
}else if(条件表达式3){
}else{
}
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入你的分数：");
double Fraction = input.nextDouble();
if(Fraction >= 90){
System.out.println("A");
}else if(Fraction >= 80){
System.out.println("B");
}else if(Fraction >= 70){
System.out.println("C");
}else if(Fraction >= 60){
System.out.println("D");
}else{
System.out.println("不合格");
}
原文：https://www.cnblogs.com/libra-ziqing/p/14382459.html