共计 7655 个字符，预计需要花费 20 分钟才能阅读完成。
1. 运算符和表达式
运算符：
就是对常量或者变量进行操作的符号。
比方：+ – * /
表达式：
用运算符把常量或者变量连接起来的，合乎 Java 语法的式子就是表达式。
比方：a + b 这个整体就是表达式。
而其中 + 是算术运算符的一种，所以这个表达式也称之为算术表达式。
2. 算术运算符
分类：
+ - * / %运算特点：
+ - * : 跟小学数学中截然不同没有任何区别./：1. 整数相除后果只能失去整除，如果后果想要是小数，必须要有小数参数。2. 小数直接参与运算，失去的后果有可能是不准确的。案例：System.out.println(10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335%：取模、取余。他做的也是除法运算，只不过获取的是余数而已。案例：System.out.println(10 % 2);//0
System.out.println(10 % 3);//1
利用场景：// 能够利用取模来判断一个数是奇数还是偶数
System.out.println(15 % 2);//1 奇数 练习：数值拆分
需要：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
代码示例：
//1. 键盘录入一个三位数
// 导包 --- 创建对象 --- 接收数据
Scanner sc = new Scanner(System.in);
System.out.println("请输出一个三位数");
int number = sc.nextInt();//123
//2. 获取这个三位数的个位、十位、百位并打印进去
// 公式：// 针对于任意的一个数而言
// 个位：数字 % 10
int ones = number % 10;
// 十位：数字 / 10 % 10
int tens = number / 10 % 10;
// 百位：数字 / 100 % 10
int hundreds = number / 100 % 10;
// 输入后果
System.out.println(ones);
System.out.println(tens);
System.out.println(hundreds);公式：
获取任意一个数上每一位数。
个位：数字 % 10
十位：数字 / 10 % 10
百位：数字 / 100 % 10
千位：数字 / 1000 % 10
。。。以此类推。。。
3. 隐式转换
概念：
也叫主动类型晋升。
就是把一个取值范畴小的数据或者变量，赋值给另一个取值范畴大的变量。此时不须要咱们额定写代码独自实现，是程序主动帮咱们实现的。
简略记忆：
就是小的给大的，能够间接给。
两种晋升规定：
- 取值范畴小的，和取值范畴大的进行运算，小的会先晋升为大的，再进行运算。
- byte、short、char 三种类型的数据在运算的时候，都会间接先晋升为 int，而后再进行运算。
取值范畴从小到大的关系：
byte short int long float double
4. 隐式转换的练习
请看上面案例是否有误，如果有问题，请说出起因，如果没有问题，请说出运算过程和运算后果
案例一：
double d = 10;
System.out.println(d);//10.0解释：
10 是整数，整数默认是 int 类型的。
而在取值范畴的程序中：byte short int long float double
在赋值的时候把一个 int 类型的赋值给了一个 double 类型的。把一个小的赋值给一个大的是能够间接给的。
案例二：
byte b = 100;
int i = b;// 能够胜利赋值 解释：
因为 byte 的取值范畴是小的，int 的取值范畴是大的，在底层进行了隐式转换，不须要咱们额定写代码独自实现，是能够间接赋值。
案例三：
int i = 10;
long n = 20L;
??? result = i + n;
问变量 result 是什么类型的？解释：
变量 i 是 int 类型的，变量 n 是 long 类型的。
而在取值范畴的程序中：byte short int long float double
变量 i 外面的值会主动晋升为 long 类型的，最终的后果其实就是两个 long 相加，那么最终的 result 是 long 类型的。
案例四：
int i = 10;
long n = 100L;
double d = 20.0;
??? result = i + n + d;
问变量 result 是什么类型的？解释：
变量 i 是 int 类型，变量 n 是 long 类型，变量 d 是 double 类型。
而在取值范畴的程序中：byte short int long float double
所以变量 i 和变量 n 外面的值在参加运算的时候，都会进行类型晋升，变成 double。
最终其实就是三个 double 进行相加，那么最终的后果就是 double 类型的。
案例五：
byte b1 = 10;
byte b2 = 20;
??? result = b1 + b2;//int
问变量 result 是什么类型的？解释：
因为 b1 和 b2 都是 byte 类型的。所以在参加计算的时候，变量 b1 和变量 b2 外面的值都会主动晋升为 int 类型的。最终其实就是两个 int 类型的相加，最终后果也是 int 类型的。
案例六：
byte b = 10;
short s = 20;
long n = 100L;
??? result = b + s + n;
问变量 result 是什么类型的？long解释：
变量 b 是 byte 类型的，变量 s 是 short 类型的，变量 n 是 long 类型的。
byte，short，char 类型的变量在参加运算的时候，变量外面的值会间接先晋升为 int。
第一步：变量 b 和变量 s 外面的值会先晋升为 int 参加运算。
int + int + long
第二步：而 long 类型的取值范畴是大于 int 的取值范畴的。
所以变量 b 和变量 s 外面的值会再次晋升为 long。
long + long + long。
所以最终后果是 long 类型的。
5. 强制转换
概念：
如果要把一个取值范畴大的数据或者变量赋值给另一个取值范畴小的变量。是不容许间接操作。
如果肯定要这么干，就须要退出强制转换。
书写格局：
指标数据类型 变量名 =（指标数据类型）被强转的数据；
简略了解：
要转成什么类型的，那么就在小括号中写什么类型就能够了。
案例：
public class OperatorDemo2 {public static void main(String[] args) {
double a = 12.3;
int b = (int) a;
System.out.println(b);//12
}
}留神点：
强制转换有可能会导致数据产生谬误。（数据的精度失落）
6. 字符串的 + 操作
外围技巧：
- 当 + 操作中呈现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
- 当间断进行 + 操作时，从左到右一一执行的。
7. 字符串相加的练习：
案例 1：
1 + "abc" + 1后果：”1abc1″
解释：
第一步：1 + “abc”。在这个过程中，有字符串参加的，所以做的是拼接操作，产生一个新的字符串 ”1abc”
第二步：“1abc” + 1。这个过程中，有字符串参加的，所以做的也是拼接操作，产生一个新的字符串 ”1abc1″
案例 2：
1 + 2 + "abc" + 2 + 1后果：“3abc21”
解释：
第一步：1 + 2。在这个过程中，没有字符串参加的，所以做的是加法运算，后果为 3。
第二步：3 + “abc”。在这个过程中，有字符串参加的，所以做的是拼接操作，产生一个新的字符串 ”3abc”。
第三步：”3abc” + 2。在这个过程中，有字符串参加的，所以做的是拼接操作，产生一个新的字符串 ”3abc2″。
第四步：”3abc2″ + 1。在这个过程中，有字符串参加的，所以做的是拼接操作，产生一个新的字符串“3abc21”
案例 3：
String name = "黑默丁格";
System.out.println("我的名字是" + name);后果：我的名字是黑默丁格
解释：当字符串跟变量相加的时候，实际上是跟变量外面的值进行拼接。
8. 字符的 + 操作
规定：
当 + 操作中呈现了字符，会拿着字符到计算机内置的 ASCII 码表中去查对应的数字，而后再进行计算。
案例：
char c = 'a';
int result = c + 0;
System.out.println(result);//97ASCII 码表中：
‘a’ —– 97
‘A’ —– 65
9. 算术运算符的总结
分类：
+ - * / % 这些操作跟小学数学简直是截然不同的。留神点：
- / 和 % 的区别：他们两个都是做除法运算，/ 取后果的商。% 取后果的余数。
- 整数操作只能失去整数，如果想要失去小数，必须有浮点数参加运算。
算术运算符的高级用法：
是以 + 为例进行的解说，其余减法，乘法，除法的运算规定也是一样的。
特例：字符串只有 + 操作，没有其余操作。
10. 自增自减运算符
分类：
++ 自增运算符
-- 自减运算符 ++：就是把变量外面的值 +1
–：就是把变量外面的值 -1
应用形式：
- 放在变量的后面，咱们叫做先 ++。比方：++a
- 放在变量的前面，咱们叫做后 ++。比方：a++
留神点：
不论是先 ++，还是后 ++。独自写在一行的时候，运算后果是截然不同的。
案例：
//++
int a = 10;
a++;// 就是让变量 a 外面的值 + 1
System.out.println(a);//11
++a;// 就是让变量 a 外面的值 + 1
System.out.println(a);//12自增自减运算符的利用场景：
某些状况下，变量须要进行加 1 或者减 1 的时候应用。
比方：过生日多一岁，就用到了自增运算符。
比方：购物商场中，抉择商品数量，也用到了自增或者自减运算符。
比方：统计很多数据中，有多少个数据满足要求，也用到了自增运算符。
11. 赋值运算符
最为罕用的：=
运算过程：就是把等号左边的后果赋值给右边的变量
案例：
public class OperatorDemo6 {public static void main(String[] args) {
//1. 最为简略的赋值运算符用法
int a = 10;// 就是把 10 赋值给变量 a
System.out.println(a);
//2. 如果等号左边须要进行计算。int b = 20;
int c = a + b;// 先计算等号左边的，把计算的后果赋值给右边的变量
System.out.println(c);
//3. 非凡的用法
a = a + 10;// 先计算等号左边的，把计算的后果赋值给右边的变量
System.out.println(a);//20
}
}12. 扩大赋值运算符
分类：
+=、-=、*=、/=、%=
运算规定：
就是把右边跟左边进行运算，把最终的后果赋值给右边，对左边没有任何影响。
案例：
public class OperatorDemo7 {public static void main(String[] args) {
// 扩大赋值运算符
int a = 10;
int b = 20;
a += b;// 把右边和左边相加，再把最终的后果赋值给右边，对左边没有任何影响
// 相当于 a = a + b;
System.out.println(a);//30
System.out.println(b);//20
}
}留神点：
扩大的赋值运算符中隐层还蕴含了一个强制转换。
以 += 为例。
a += b ; 实际上相当于 a = (byte)(a + b);
public class OperatorDemo8 {public static void main(String[] args) {
byte a = 10;
byte b = 20;
//a += b;
a = (byte)(a + b);
System.out.println(a);//30
}
}13. 关系运算符
又叫比拟运算符，其实就是拿着右边跟左边进行了判断而已。
分类：
| 符号 | 解释 |
|---|---|
| == | 就是判断右边跟左边是否相等，如果成立就是 true，如果不成立就是 false |
| != | 就是判断右边跟左边是否不相等，如果成立就是 true，如果不成立就是 false |
| > | 就是判断右边是否大于左边，如果成立就是 true，如果不成立就是 false |
| >= | 就是判断右边是否大于等于左边，如果成立就是 true，如果不成立就是 false |
| < | 就是判断右边是否小于左边，如果成立就是 true，如果不成立就是 false |
| <= | 就是判断右边是否小于等于左边，如果成立就是 true，如果不成立就是 false |
留神点：
- 关系运算符最终的后果肯定是布尔类型的。要么是 true，要么是 false
- 在写 == 的时候，千万不要写成 =
14. 逻辑运算符
& 和 | 的应用：
&：逻辑与（而且）
两边都为真，后果才是真，只有有一个为假，那么后果就是假。
|：逻辑或（或者）
两边都为假，后果才是假，只有有一个为真，那么后果就是真。
代码示例：
// & // 两边都是真，后果才是真。System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println("===================================");
// | 或 // 两边都是假，后果才是假，如果有一个为真，那么后果就是真。System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true应用场景：
依据固定的场景，来抉择应用 & 还是应用 |
-
用户登录。
用户名输出正确 & 明码输出正确
因为只有用户名和明码同时都正确了，那么能力胜利登录，只有有一个失败了都不行。
应用技巧：
当咱们须要同时满足右边和左边两种状况时，能够应用且
-
丈母娘选女婿
丈母娘：女婿啊，你要么买个房子，要么买辆车。就能够把我的小棉袄穿走了。
买个房子 | 买辆车
两个条件中，只有满足其中一个，就能够穿走小棉袄了。
应用技巧：
当两种条件只有满足其中一个的时候，能够应用或
^（异或）的应用：
在当前用的不多，理解一下即可。
计算规定：如果两边雷同，后果为 false，如果两边不同，后果为 true
代码示例：
//^ // 左右不雷同，后果才是 true，左右雷同后果就是 false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true!（取反）的应用：
是取反，也叫做非。
计算规定：false 取反就是 true，true 取反就是 false
舒适提醒： 取反最多只用一个。
代码示例：
System.out.println(!false);//true
System.out.println(!true);//false
System.out.println(!!false);// 留神点：取反最多只用一个。15. 短路逻辑运算符
分类：&& ||
&&：
运算后果跟 & 是截然不同的，只不过具备短路成果。
||：
运算后果跟 | 是截然不同的。只不过具备短路成果。
逻辑外围：
当右边不能确定整个表达式的后果，左边才会执行。
当右边能确定整个表达式的后果，那么左边就不会执行了。从而进步了代码的运行效率。
举例：
-
用户登录案例
用户名正确 & 明码正确
如果应用一个 &，不论用户名是否正确都会去验证明码。
思考：
如果用户名输出正确了，那么咱们再判断明码是否正确，是合乎业务逻辑的。
然而如果用户名输出谬误了，那么当初还有必要去比拟明码吗？没有不要了。
如果应用一个 &，那么右边和左边不论什么状况下，都会执行。
用户名正确 && 明码正确
如果用户名输出正确了，那么才会验证明码是否输出正确。
如果用户名输出谬误了，那么就不会再去验证明码是否正确，最终的后果间接为 false。从而进步了程序运行的效率。
-
丈母娘选女婿
有房 | 有车
首先先看看有没有房，发现有，而后再去看看有没有车。
思考：
既然都有房子，干嘛还要去看车呢？多此一举。
有房 || 有车
首先先看看有没有房，如果有，那么左边就不执行了。最终的后果间接为 true。
如果没有房子，才会去看左边有没有车。
总结：
&& 和 &、|| 和 | 的运行后果都是截然不同的。
然而短路逻辑运算符能够进步程序的运行效率。
倡议：
最为罕用：&& ||！
16. 三元运算符
又叫做：三元表达式或者问号冒号表达式。
格局：
关系表达式？表达式 1：表达式 2；
计算规定：
- 计算关系表达式的值。
- 如果关系表达式的值为真，那么执行表达式 1。
- 如果关系表达式的值为假，那么执行表达式 2。
留神点：
三元运算符的最终后果肯定要被应用，要么赋值给一个变量，要么间接打印进去。
案例：
public class OperatorDemo12 {public static void main(String[] args) {
// 需要：求两个数的较大值
int a = 10;
int b = 20;
// 格局：关系表达式？表达式 1：表达式 2；// 留神点：// 三元运算符的最终后果肯定要被应用。// 要么赋值给一个变量，要么间接输入。int max = a > b ? a : b ;
System.out.println(max);
System.out.println(a > b ? a : b);
}
}17. 练习 1 - 两只老虎
需要：
动物园里有两只老虎，两只老虎的体重别离为通过键盘录入取得，
请用程序实现判断两只老虎的体重是否雷同。
代码示例：
//1. 获取两只老虎的体重
Scanner sc = new Scanner(System.in);
System.out.println("请输出第一只老虎的体重");
int weight1 = sc.nextInt();
System.out.println("请输出第二只老虎的体重");
int weight2 = sc.nextInt();
//2. 利用三元运算符求出最终后果
String result = weight1 == weight2 ? "雷同" : "不雷同";
System.out.println(result);18. 练习 2 - 求三个数的最大值
需要：
一座寺庙里住着三个和尚，已知他们的身高别离为 150cm、210cm、165cm。
请用程序实现获取这三个和尚的最高身高。
代码示例：
//1. 定义三个变量记录和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;
//2. 利用三元运算符求出两个数中的较大值。int temp = height1 > height2 ? height1 : height2;
//3. 求出最终的后果
int max = temp > height3 ? temp : height3;
System.out.println(max);19. 运算符的优先级
在 Java 中波及了很多的运算符，每一种运算符都有各自的优先级。然而这些优先级不须要记忆。
咱们只有晓得其中一点：
小括号优先于所有。