前言
“采菊东篱下，悠然见南山” ----- 陶渊明《饮酒·其五》
1. 运算符
1.1 运算符
运算符概述：用于执行各种操作的符号，如+，-，*，/等。
1.2 Java运算符分类
Java运算符分为：算数运算符、自增自减运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符。
| 运算符名称 | 运算符 |
|---|---|
| 算数运算符 | + - * / % |
| 自增自减运算符 | ++ – |
| 赋值运算符 | = += -= *= /= %= |
| 关系运算符 | == != > >= < <= |
| 逻辑运算符 | & | ！ ^ && || |
| 三元运算符 | ? : |
1.3 算数运算符
1.3.1 分类
| 运算符 | 运算 | 示例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | -4 | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 2*3 | 6 |
| / | 除 | 6/2 | 3 |
| % | 取模/取余 | 7%5 | 2 |
注意：整数相除，结果为整数，
有小数参与，结果为小数,小数相除，结果可能不精确
1.3.2 小数相除不精确解析
1. 原因
浮点数在计算机中通常使用 IEEE 754 标准表示。这种表示方式不能精确地表示所有十进制小数，特别是那些不能精确表示为二进制小数的十进制小数。
2. 代码示例
double a = 0.1;
double b = 0.2;
double sum = a + b;
System.out.println(sum); // 输出可能不是 0.3，而是 0.30000000000000004
3. 解决办法
使用BigDecimal类,该类提供了精确的浮点数运算。它是处理高精度数值运算的推荐方式
package com.syh;
import java.math.BigDecimal;
public class Esther {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal sum = a.add(b);
System.out.println(sum); // 输出 0.3
}
}
使用 BigDecimal 虽然可以解决精度问题，但它的运算速度比原生的浮点数运算慢，因此在性能敏感的应用中需要权衡精度和性能。
1.4 自增自减运算符
1.4.1 分类
自增和自减运算符可以写在变量前面或后面，写在前面表示先运算再赋值，写在后面表示先赋值再运算
| 运算符 | 运算 |
|---|---|
| ++ | ++x，x++ |
| – | –y，y– |
1.4.2 代码示例
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.先++
int a = 1;
int result1 = ++a;
System.out.println("a的值：" + a); // 2
System.out.println("result1的值：" + result1); // 2
System.out.println("----------");
// 2.后++
int b = 1;
int result2 = b++;
System.out.println("b的值：" + b); // 2
System.out.println("result2的值：" + result2); // 1
System.out.println("----------");
// 3.先--
int c = 1;
int result3 = --c;
System.out.println("c的值：" + c); // 0
System.out.println("result3的值：" + result3); // 0
System.out.println("----------");
// 4.后--
int d = 1;
int result4 = d--;
System.out.println("d的值：" + d); // 0
System.out.println("result4的值：" + result4); // 1
}
}
注意：单独使用的时候，++和–无论放在前边还是后边，结果是一样的
1.5 赋值运算符
| 运算符 | 运算 | 示例 | 等价于 |
|---|---|---|---|
| = | 赋值 | a = 4，b = 2 | a = 4，b = 2 |
| += | 加等于 | a = 4，b = 2，a += b | a = a + b |
| -= | 减等于 | a = 4，b = 2，a -= b | a = a - b |
| *= | 乘等于 | a = 4，b = 2，a *= b | a = a * b |
| /= | 除等于 | a = 4，b = 2，a /= b | a = a / b |
| %= | 模等于 | a = 4，b = 2，a %= b | a = a % b |
1.6 关系运算符
关系运算符用于两个数值的比较，结果是一个布尔值，即true或false
| 符号 | 解释 |
|---|---|
| == | 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false |
| != | 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false |
| > | 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false |
| >= | 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false |
| < | 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false |
| <= | 就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false |
1.7 逻辑运算符
1.7.1 分类
| 运算符 | 运算 | 解释 |
|---|---|---|
| & | 与 | 两边都为真，结果才是真，只要有一个为假，那么结果就是假 |
| | | 或 | 两边都为假，结果才是假，只要有一个为真，那么结果就是真。 |
| ! | 非 | 非真为假，非假为真 |
| ^ | 异或 | 两边不同为真，两边相同为假 |
| && | 短路与 | 和与相似，具有短路效果 |
| || | 短路或 | 和或相似，具有短路效果 |
1.7.2 运算规则
package com.syh;
public class Esther {
public static void main(String[] args) {
// &的运算规则(同真为真，其余为假)
System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & true); // false
System.out.println(false & false); // false
System.out.println("----------");
// |的运算规则(同假为假，其余为真)
System.out.println(true | true); // true
System.out.println(true | false); // true
System.out.println(false | true); // true
System.out.println(false | false); // false
System.out.println("----------");
// !的运算规则(非真为假，非假为真)
System.out.println(!true); // false
System.out.println(!false); // true
System.out.println("----------");
// ^的运算规则(不同为真，相同为假)
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
System.out.println(false ^ false); // false
}
}
1.7.3 &和&&，|和||区别
其一：具有短路效果，
即&无论左边为true还是false，右边表达式都会进行运算，而&&左边为false，右边表达式不再进行运算，结果直接为假。
即|无论左边为true还是false，右边表达式都会进行运算，而||左边为true，右边表达式不再进行运算，结果直接为真。
其二：&，|可以进行数字运算，而&&，||不可以，
其三：&& 、||、！最为常用
1.8 三元运算符
1.8.1 定义格式
关系表达式 ？ 表达式1 ：表达式2 ；
1.8.2 计算规则：
- 计算关系表达式的值。
- 如果关系表达式的值为真，那么执行表达式1。
- 如果关系表达式的值为假，那么执行表达式2。
1.9 运算符的优先级
| 优先级 | 运算符 |
|---|---|
| 1 | [] () |
| 2 | ++ – ~ ！ |
| 3 | * / % |
| 4 | + - |
| 5 | << >> >>> |
| 6 | < > <= >= |
| 7 | == != |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | = += -= *= /= %= |
数字越小，运算符优先级越高。
但是这些优先级不需要记忆,只需要知道其中一点：小括号优先于所有。
2. 表达式和语句
2.1 表达式
用运算符把常量或者变量连接起来，符合Java语法的式子就是表达式
例如：a + b这个整体就是表达式
其中 + 为算数运算符的一种，所以这个表达式也称为算数表达式
2.2 语句
语句：以分号结尾：例如 int a = 10;
3. 流程控制语句
3.1 流程控制语句分类
-
顺序结构
-
选择结构(if-else, switch)
-
循环结构(for, while, do…while)
3.2 顺序结构
3.2.1 顺序结构
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
3.2.2 流程图
3.2.3 代码示例
package com.syh;
public class Esther {
public static void main(String[] args) {
// 顺序结构
System.out.println("A"); // A
System.out.println("B"); // B
System.out.println("C"); // C
}
}
3.3 选择结构
3.3.1 if语句
1.格式一
if (关系表达式) {
语句体;
}
执行流程：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④继续执行后面的语句内容
流程图：
代码示例：
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.定义两个变量
int a = 10;
int b = 20;
// 2.判断a和b是否相等
if (a == b) {
System.out.println("a等于b");
}
}
}
注意：如果我们要对一个布尔类型的变量进行判断，不要写==，直接把变量写在小括号中即可。
2. 格式2
if (关系表达式) {
语句体1;
} else {
语句体2;
}
执行流程：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体1
③如果关系表达式的值为false就执行语句体2
④继续执行后面的语句内容
代码示例：
public class IfDemo02 {
public static void main(String[] args) {
// 1.定义两个变量
int a = 10;
int b = 20;
// 2.判断a和b是否相等
if(a > b) {
System.out.println("a的值大于b");
} else {
System.out.println("a的值小于于b");
}
}
}
3. 格式3
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程：
①首先计算关系表达式1的值
②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
④…
⑤如果没有任何关系表达式为true，就执行语句体n+1。
代码示例：
package com.syh;
public class Esther {
public static void main(String args[]) {
// 1.定义变量x
int x = 30;
// 2.对x进行判断
if (x == 10) {
System.out.print("x的值：10");
} else if (x == 20) {
System.out.print("x的值：20");
} else if (x == 30) {
System.out.print("x的值：30");
} else {
System.out.print("x的值：else 语句");
}
}
}
3.3.2 switch语句
1. 格式
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
2. 执行流程：
- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
3. 流程图
4.代码示例：
package com.syh;
import java.util.Scanner;
public class Esther {
public static void main(String[] args) {
// 1.键盘录入一个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int week = sc.nextInt();
// 2.switch语句
switch (week) {
case 1:
System.out.println("今天是星期一");
break;
case 2:
System.out.println("今天是星期二");
break;
case 3:
System.out.println("今天是星期三");
break;
case 4:
System.out.println("今天是星期四");
break;
case 5:
System.out.println("今天是星期五");
break;
case 6:
System.out.println("今天是星期六");
break;
case 7:
System.out.println("今天是星期日");
break;
default:
System.out.println("输入错误，没有这个星期");
break;
}
}
}
5. switch的扩展知识：
- case穿透：不写break会引发case穿透现象
- switch在JDK12的新特性
switch (week) {
case 1, 2, 3, 4, 5 -> System.out.println("工作日");
case 6, 7 -> System.out.println("休息日");
default -> System.out.println("没有这个星期");
}
3.4 循环结构
3.4.1 for循环
1. for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
2. 执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
3. 代码示例：求1~5的和
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.定义sum变量
int sum = 0;
// for循环
for (int i = 1; i <= 5; i++) {
sum += i;
}
System.out.println("1~5的和：" + sum); // 15
}
}
3.4.2 while循环
1. 格式：
初始化语句;
while(条件判断语句){
循环体;
条件控制语句;
}
2. 示例代码：输出1~5
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.定义变量i
int i = 1;
// 2.while循环
while(i <= 5){
System.out.println("i = " + i);
i++;
}
}
}
3.4.3 do…while循环
1. 格式：
初始化语句;
do{
循环体;
条件控制语句;
}while(条件判断语句);
特点：先执行，再判断。
2. 示例代码：输出1~5
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.定义变量x
int x = 1;
// 2.do-while循环
do {
System.out.println("x = " + x);
x++;
} while (x <= 5);
}
}
3.4.4 三种格式的区别：
-
当知道循环次数或者循环范围的时候，用for循环。
-
当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。
4. 条件控制语句
条件控制语句有两个，分别为break和continue
4.1 break语句
break 语句表示退出当前循环，继续执行循环外的代码，不能单独存在，可以用在switch和循环中
代码示例：
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.for循环打印1~5
for (int i = 1; i <= 5; i++) {
// 2.i = 3时，结束整个循环
if (i == 3) {
break;
}
// 3.输出变量i
System.out.println("i = " + i);
}
}
}
4.2 continue语句
continue语句表示跳过本次循环，继续执行下次循环，不能单独存在的。只能存在于循环当中。
代码示例：
package com.syh;
public class Esther {
public static void main(String[] args) {
// 1.for循环打印1~5
for (int i = 1; i <= 5; i++) {
// 2.i = 3时，结束本次循环
if (i == 3) {
continue;
}
// 3.输出变量i
System.out.println("i = " + i);
}
}
}
扫一扫
529
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
