由于 java 是一种强类型的语言，所以要进行有些运算的时候，是需要类型的转换的。运算中，不同的类型的数据类型先转换为同一类型（由低了-------> 到 高 类型），然后再进行运算的 除法 “ / ”
除法的运算中的**“坑”** 代码：
public class Study2 {
public static void main(String[] args) {
System.out.println(5/2); // 2
System.out.println(5.0/2); // 2.5
System.out.println((float)5/2); // 2.5
System.out.println((float)(5/2)); // 2.0
}
}
结果：
解析：
上述的第6 行代码：类型不一致，运算之前先把 2 转换为了 double 的类型，再进行计算为 ：5.0/2.0 = 2.5；上述的第 7 行代码：(float) 5 被强制类型转换为了**(float)** 的类型，类型不一致，把 2 转换为 （float）同一类型，最后计算：5.0/2.0 = 2.5；上述的第 8 行代码：（float）(5/2) 将（5/2）的结果强制类型转换为了**(float)** 的类型，最后结果为 ：
（5/2）= 2；2(结果)强制类型转换为：（float） = 2.0;
注意点：
在程序中 计算 10 / 0 会导致程序抛出异常
代码2：public class Study2 {
public static void main (String[] args) {
System.out.println(10/0); // 报错，异常，算术异常
}
结果2：
上述 结果：(Exception) 表示异常，上述结果： (java.lang.ArithmeticException:) 表示算术异常： 取余 （取模）：“%” 代码：
public class Study2 {
public static void main (String[] args) {
System.out.println(10%3); // 1
System.out.println(-10%3); // -1
System.out.println(10%-3); // 1
System.out.println(-10%-3); // -1
}
}
结果：
解析：
上述代码：第 5 行代码 (10 % 3) 10 / 3 余数 为 1；上述代码：第 6 行代码**（-10%3）** -10 /3 余数为 -1 ；上述代码：第 7 行代码**（10%-3）** 10 / -3 余数为 1；上述代码： 第8 行代码**（-10%-3）** -10 / -3 余数为 -1；
后置（x++，x–），前置(++x,–x)，递增，递减运算符 代码：
public class Study2 {
public static void main (String[] args) {
int a = 10;
int b = ++a;
System.out.println(b); // 11
int c = a++;
System.out.println(c); // 11
}
}
结果：
解析：
上述代码：第 6 行的 （++a） a= a+1 ; 所以a = 11 , b= 11；上述代码：第 7 行的 （a++） a= a+1; 所以 a = 12, b = 11;
代码2：
public class Study2 {
public static void main (String[] args) {
int i =10;
i = i++;
System.out.println(i); // 10
// 注意这里i还是等于 10 的
}
}
结果2：
关系运算符
**== ，！= ， < , >, >=, <= ** 代码：
public class Study2 {
public static void main (String[] args) {
int num = 10;
int num2 = 20;
System.out.println(num == num2); // false
System.out.println(num != num2); // true
System.out.println(num < num2); // true
System.out.println(num > num2); // false
System.out.println(num <= num2); // true
System.out.println(num >= num2); // false
}
}
结果2：
解析：
注意 在 java 当中boolean 类型： 假是 （false） ,真是 （true） ,没有 C语言中的 非0 为真, 0 为 假
注意：（!） 运算符 只能用于 boolean 类型 与 C语言不同； 代码：
public class Study2 {
public static void main (String[] args) {
int a = 10;
System.out.println(!a);// 报错：！ 只能用于 boolean 类型
boolean flag = true;
System.out.println(!flag);
}
}
结果：
代码2：
public class Study2 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(! a < b); // 报错 因为 ！ 非运算符，只能用于boolean;
}
}
结果2：
解析2：
（！a < b） 中 因为 ！ 非运算符，只能用于boolean; 而 ！只能与 boolean 的类型而这里 ！ 与**a ** 最近，优先级！高，！先算 ，而 a 是 int 类型的的，所以报错；
修改：
public class Study2 {
public static void main (String[] args) {
int a = 10;
int b = 20;
System.out.println(!(a < b));
}
}
加一个括号 ，优先级，！非运算； &&（与运算） || （或运算）的短路求值：
&& 与运算 ： 所有的表达式为真（true），才为真(true);|| 或运算： 所有的表达式中其中一个为 真 （true），就为真(true);
代码：
public class Study2 {
public static void main (String[] args) {
System.out.println( 10 > 20 && 10 / 0 == 0); // false
System.out.println(10 < 20 || 10 / 0 == 0); // true
}
}
结果：
解析：
我们都已经知道到了，计算 10 / 0 会导致程序抛出异常：
但是上述的代码却能正常运行，说明 10 / 0 并没有真正被求值
短路求值：
- 对于 &&（与运算） 如果左侧表达值为 false（假） ,则表达式的整体的值一定是false(假) ，无需计算右侧表达式了：对于 || （或运算） 如果左侧表达值为 true（真） ，则表达式的整体的值一定是 true(真) ，无需计算右侧表达式：
代码2：
再次证明 短路求值：
public class Study2 {
public static void main (String[] args) {
int num = 9;
int num2 = 10;
boolean flag = (num > num2) && (num++ < 10); // 假 （false）
boolean flag2 = (num < num2) || (num2++ < 10); // 真 (true)
System.out.println("falg是="+flag);
System.out.println("falg2是="+flag2);
System.out.println("num是="+num); // 9
System.out.println("num2是="+num2); // 10
}
}
结果2：
解析：
- 上述代码：第 7 行 （&& 与运算，全为真(true)，才为真(true）因为左侧的表达（num > num2）为假（flase），右侧表达式**(num++)** 不再计算了，所以仍然为：num = 9；上述代码：第 8 行（|| 或运算，有一个为真(true)，就为真（true） 因为左侧的表达（num < num2）为真(true)，右侧表达式**(num2++)** 不再计算了，所以仍然为：num2 = 10；
最后：
最后 ：限于自身的水平，对其中存在的纰漏甚至错误，希望各位朋友，能给予指教，我会加以改正，谢谢大家！
