1运算符介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。可以分为算数运算符、赋值运算符、关系运算符（比较运算符）、逻辑运算符、三元运算符。
2算数运算符
2.1算术运算符介绍
算术运算符用于执行基本的数学运算。Java中的算术运算符包括：
- 加法（
+） - 减法（
-） - 乘法（
*） - 除法（
/） - 取模（
%） - 自增（
++） - 自减（
--）
2.2算术运算符一览表
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
+ | 加法 | a + b | a + b 的值 |
- | 减法 | a - b | a - b 的值 |
* | 乘法 | a * b | a * b 的值 |
/ | 除法 | a / b | a / b 的值，结果为 double 类型，除非两个操作数都是整数 |
% | 取模（求余数） | a % b | a % b 的余数 |
++ | 自增（使变量值加1） | ++a 或 a++ | a 的值加1 |
-- | 自减（使变量值减1） | --a 或 a-- | a 的值减1 |
2.3算术运算符案例
public class ArithmeticOperators {
public static void main(String[] args) {
int a = 10;
int b = 5;
// 加法
int sum = a + b;
System.out.println("加法结果: " + sum); // 输出: 加法结果: 15
// 减法
int difference = a - b;
System.out.println("减法结果: " + difference); // 输出: 减法结果: 5
// 乘法
int product = a * b;
System.out.println("乘法结果: " + product); // 输出: 乘法结果: 50
// 除法
double quotient = (double) a / b;
System.out.println("除法结果: " + quotient); // 输出: 除法结果: 2.0
// 取模
int remainder = a % b;
System.out.println("取模结果: " + remainder); // 输出: 取模结果: 0
// 自增
int c = 0;
c++;
System.out.println("自增后: " + c); // 输出: 自增后: 1
// 自减
int d = 10;
d--;
System.out.println("自减后: " + d); // 输出: 自减后: 9
}
}
2.3细节说明
- 加法：将两个数值相加。
- 减法：从一个数值中减去另一个数值。
- 乘法：将两个数值相乘。
- 除法：将一个数值除以另一个数值。如果操作数是整数，结果将是整数除法，即结果向下取整。如果至少有一个操作数是
double，则结果将是double类型。 - 取模：返回除法操作的余数。两个操作数都必须是整数。
- 自增和自减：自增操作符
++将变量的值增加1，自减操作符--将变量的值减少1。它们可以作为前缀（++a或--a）或后缀（a++或a--）使用。前缀形式返回递增或递减后的值，而后缀形式返回递增或递减前的值。
这些算术运算符是Java编程中进行数值计算的基础，它们在实现各种算法和数据处理时非常关键。
3关系运算符（比较运算符）
Java中的关系运算符（也称为比较运算符）用于比较两个操作数之间的关系，并根据比较结果返回布尔值（true或false）。以下是Java中的关系运算符：
- 等于 (
==)：检查两个操作数的值是否相等。 - 不等于 (
!=)：检查两个操作数的值是否不相等。 - 大于 (
>)：检查左操作数是否大于右操作数。 - 小于 (
<)：检查左操作数是否小于右操作数。 - 大于等于 (
>=)：检查左操作数是否大于或等于右操作数。 - 小于等于 (
<=)：检查左操作数是否小于或等于右操作数。
3.1关系运算符一览表
| 运算符 | 描述 | 示例 | 结果（布尔值） |
|---|---|---|---|
== | 等于 | a == b | 如果 a 等于 b，则为 true，否则为 false |
!= | 不等于 | a != b | 如果 a 不等于 b，则为 true，否则为 false |
> | 大于 | a > b | 如果 a 大于 b，则为 true，否则为 false |
< | 小于 | a < b | 如果 a 小于 b，则为 true，否则为 false |
>= | 大于等于 | a >= b | 如果 a 大于或等于 b，则为 true，否则为 false |
<= | 小于等于 | a <= b | 如果 a 小于或等于 b，则为 true，否则为 false |
3.2关系运算符案例
public class RelationalOperators {
public static void main(String[] args) {
int x = 10;
int y = 20;
int z = 10;
// 等于
boolean isEqual = (x == z);
System.out.println("x 等于 z ? " + isEqual); // 输出: x 等于 z ? true
// 不等于
boolean isNotEqual = (x != y);
System.out.println("x 不等于 y ? " + isNotEqual); // 输出: x 不等于 y ? true
// 大于
boolean isGreater = (y > x);
System.out.println("y 大于 x ? " + isGreater); // 输出: y 大于 x ? true
// 小于
boolean isLess = (x < y);
System.out.println("x 小于 y ? " + isLess); // 输出: x 小于 y ? true
// 大于等于
boolean isGreaterEqual = (x >= z);
System.out.println("x 大于等于 z ? " + isGreaterEqual); // 输出: x 大于等于 z ? true
// 小于等于
boolean isLessEqual = (x <= y);
System.out.println("x 小于等于 y ? " + isLessEqual); // 输出: x 小于等于 y ? true
}
}
3.3细节说明
- 等于 (
==)：比较两个操作数的值是否相等。对于原始数据类型（如int、float等），它比较值；对于对象，它比较引用是否指向同一对象。 - 不等于 (
!=)：比较两个操作数的值是否不相等。 - 大于 (
>)、小于 (<)、大于等于 (>=) 和 小于等于 (<=)：这些运算符用于比较数值的大小，并根据比较结果返回布尔值。
关系运算符在条件语句（如if、for、while等）中非常常用，用于基于特定条件执行代码块。
4逻辑运算符
Java中的逻辑运算符用于对布尔值进行逻辑运算，它们返回的结果也是一个布尔值（true 或 false）。以下是Java中逻辑运算符的详细介绍：
- 逻辑与 (
&&)：如果两个操作数都为true，则结果为true；否则为false。 - 逻辑或 (
||)：如果至少有一个操作数为true，则结果为true；否则为false。 - 逻辑非 (
!)：反转操作数的布尔值，如果操作数为true，则结果为false；如果操作数为false，则结果为true。
4.1逻辑运算符一览表
| 运算符 | 描述 | 示例 | 结果（布尔值） |
|---|---|---|---|
&& | 逻辑与 | a && b | 如果 a 和 b 都为 true，则结果为 true，否则为 false |
| ` | ` | 逻辑或 | |
! | 逻辑非 | !a | 如果 a 为 true，则结果为 false；如果 a 为 false，则结果为 true |
4.2逻辑运算符案例
public class LogicalOperators {
public static void main(String[] args) {
boolean isRaining = false;
boolean isUmbrella = true;
// 逻辑与
boolean shouldStayHome = (isRaining && !isUmbrella);
System.out.println("Should stay home? " + shouldStayHome); // 输出: Should stay home? false
// 逻辑或
boolean hasJacket = false;
boolean shouldGoOut = (isRaining || hasJacket);
System.out.println("Should go out? " + shouldGoOut); // 输出: Should go out? false
// 逻辑非
boolean willRain = !shouldStayHome;
System.out.println("Will it rain? " + willRain); // 输出: Will it rain? true
}
}
4.3细节说明
-
逻辑与 (
&&)：这个运算符常用于需要两个条件都满足时才执行某操作的情况。它具有短路特性，即如果第一个操作数为false，则不会计算第二个操作数，因为整个表达式的结果已经确定为false。 -
逻辑或 (
||)：这个运算符常用于只要有一个条件满足就执行某操作的情况。它也具有短路特性，即如果第一个操作数为true，则不会计算第二个操作数，因为整个表达式的结果已经确定为true。 -
逻辑非 (
!)：这个运算符用于反转布尔值。它不具有短路特性，但通常用于反转逻辑条件，或者在条件语句中简化代码。
逻辑运算符在编写条件语句和控制程序流程时非常有用，它们帮助程序员构建复杂的逻辑表达式。
5赋值运算符
Java中的赋值运算符用于将一个值赋给一个变量。除了基本的赋值运算符 `=` 外，Java还提供了一些组合赋值运算符，它们结合了其他运算符和赋值操作。
5.1基本赋值运算符
=：将等号右侧的值赋给左侧的变量。
5.2组合赋值运算符
+=：将右侧的值加到左侧变量的当前值上，并将结果赋给左侧变量。-=：将右侧的值从左侧变量的当前值中减去，并将结果赋给左侧变量。*=：将右侧的值乘以左侧变量的当前值，并将结果赋给左侧变量。/=：将左侧变量的当前值除以右侧的值，并将结果赋给左侧变量。%=：将左侧变量的当前值除以右侧的值，并取余数赋给左侧变量。&=：将左侧变量和右侧表达式进行按位与操作，并将结果赋给左侧变量。|=：将左侧变量和右侧表达式进行按位或操作，并将结果赋给左侧变量。^=：将左侧变量和右侧表达式进行按位异或操作，并将结果赋给左侧变量。<<=：将左侧变量的二进制表示向左移动右侧指定的位数，并将结果赋给左侧变量。>>=：将左侧变量的二进制表示向右移动右侧指定的位数（算术右移），并将结果赋给左侧变量。>>>=：将左侧变量的二进制表示向右移动右侧指定的位数（逻辑右移），并将结果赋给左侧变量。
5.3赋值运算符一览表
| 运算符 | 描述 | 示例 | 等价表达式 |
|---|---|---|---|
= | 赋值 | a = b | - |
+= | 加后赋值 | a += b | a = a + b |
-= | 减后赋值 | a -= b | a = a - b |
*= | 乘后赋值 | a *= b | a = a * b |
/= | 除后赋值 | a /= b | a = a / b |
%= | 取模后赋值 | a %= b | a = a % b |
&= | 按位与后赋值 | a &= b | a = a & b |
| ` | =` | 按位或后赋值 | `a |
^= | 按位异或后赋值 | a ^= b | a = a ^ b |
<<= | 左移位后赋值 | a <<= b | a = a << b |
>>= | 右移位（带符号）后赋值 | a >>= b | a = a >> b |
>>>= | 右移位（无符号）后赋值 | a >>>= b | a = a >>> b |
5.4赋值运算符案例
public class AssignmentOperators {
public static void main(String[] args) {
int num = 10;
// 基本赋值
num = 20;
System.out.println("基本赋值: " + num); // 输出: 基本赋值: 20
// 加后赋值
num += 5;
System.out.println("加后赋值: " + num); // 输出: 加后赋值: 25
// 乘后赋值
num *= 2;
System.out.println("乘后赋值: " + num); // 输出: 乘后赋值: 50
// 按位或后赋值
num |= 1;
System.out.println("按位或后赋值: " + num); // 输出可能依赖于num的初始二进制表示
// 左移位后赋值
num <<= 2;
System.out.println("左移位后赋值: " + num); // 输出: 左移位后赋值: 200
}
}
5.5细节说明
- 赋值运算符
=是最基本的赋值操作。 - 组合赋值运算符不仅执行了相应的运算，还节省了代码量，并且通常比分开写的两个操作（运算和赋值）效率更高。
- 按位赋值运算符（
&=、|=、^=、<<=、>>=、>>>=）在执行赋值之前会对变量和表达式进行按位运算。 - 赋值运算符通常用于初始化变量和在循环或条件语句中更新变量的值。
赋值运算符是编程中非常基础且频繁使用的元素，它们在程序中用于变量的赋值和状态更新。
6三元运算符
### 三元运算符介绍
Java中的三元运算符是一种条件运算符，它提供了一种使用单个表达式进行条件判断的方法。它由三个部分组成，因此得名“三元”。三元运算符的语法简洁，可以替代简单的if-else语句。
6.1三元运算符一览
| 运算符 | 语法 | 功能描述 |
|---|---|---|
| 三元 | condition ? value_if_true : value_if_false | 如果 condition 为 true，则返回 value_if_true，否则返回 value_if_false |
6.2三元运算符案例
public class TernaryOperatorExample {
public static void main(String[] args) {
// 定义并初始化 score 变量
int score = 85;
// 使用三元运算符确定等级
String grade = score >= 90 ? "A" : (score >= 80 ? "B" : "C");
System.out.println("Grade is: " + grade); // 输出: Grade is: B
// 定义并初始化 a 和 b 变量
int a = 10, b = 20;
// 使用三元运算符确定最大值
int max = (a > b) ? a : b;
System.out.println("Max value is: " + max); // 输出: Max value is: 20
}
}
6.3细节说明
- 条件判断：三元运算符的第一个部分是条件表达式，它必须返回一个布尔值（
true或false）。 - 简洁性：三元运算符提供了一种简洁的方式来编写条件语句，特别是当需要基于条件分配值时。
- 嵌套使用：三元运算符可以嵌套使用，但过度嵌套可能会使代码难以理解和维护。
- 类型一致性：
value_if_true和value_if_false必须兼容，以便编译器可以确定整个表达式的返回类型。 - 短路计算：如果条件表达式的结果已经确定，那么不会计算不相关的分支，这是三元运算符的短路特性。
- 适用场景：三元运算符适用于简单的条件判断，如果条件逻辑复杂，建议使用完整的if-else语句，以提高代码的可读性。
三元运算符是Java编程中一个非常实用的功能，它允许开发者在一行代码中完成条件判断和相应的操作。然而，应该谨慎使用，避免过度复杂化，以保持代码的清晰和可维护性。
7运算符优先级
7.1运算符优先级介绍
在Java编程中，运算符优先级定义了表达式中不同运算符的计算顺序。掌握运算符优先级对于正确理解和编写复杂的表达式至关重要。
7.2运算符优先级一览表
以下是Java中运算符优先级从高到低的顺序，包括每个运算符的作用：
| 类别 | 运算符 | 解释或作用 |
|---|---|---|
| 后缀增量/减量 | postfixExpr++ | 后缀增量运算符，先返回表达式的值，然后表达式值加1。 |
postfixExpr-- | 后缀减量运算符，先返回表达式的值，然后表达式值减1。 | |
| 前缀增量/减量 | ++prefixExpr | 前缀增量运算符，先将表达式值加1，然后返回表达式的值。 |
--prefixExpr | 前缀减量运算符，先将表达式值减1，然后返回表达式的值。 | |
| 一元运算符 | + - | 一元加和一元减，返回操作数的正数值或负数值。 |
! | 逻辑非运算符，对布尔值取反。 | |
~ | 按位非运算符，对每个位取反。 | |
| 乘除模 | * / % | 乘法、除法和取模运算符，用于乘法、除法和求余数。 |
| 加减 | + - | 加法和减法运算符，用于数值的加和减。 |
| 位移 | << >> >>> | 位移运算符，用于将操作数的二进制位左移或右移。 |
| 关系 | < > <= >= instanceof | 关系运算符，用于比较两个操作数的大小或实例类型。 |
| 相等性 | == != | 相等性运算符，用于比较两个操作数是否相等或不相等。 |
| 按位AND | & | 按位AND运算符，用于按位进行逻辑与操作。 |
| 按位XOR | ^ | 按位XOR运算符，用于按位进行逻辑异或操作。 |
| 按位OR | ` | ` |
| 逻辑AND | && | 逻辑AND运算符，用于逻辑与操作，具有短路特性。 |
| 逻辑OR | ` | |
| 条件 | ? : | 条件（三元）运算符，根据条件表达式的结果选择两个值之一。 |
| 赋值 | = += -= *= /= %= &= ` | = ^=` `<<=` `>>=` `>>>=` |
7.3运算符优先级案例
public class OperatorPrecedenceExample {
public static void main(String[] args) {
int a = 10, b = 5, c = 3;
// 乘法优先于加法
int result1 = a + b * c; // 先计算 b * c，结果是 15，然后 10 + 15 = 25
System.out.println("Result1 (a + b * c): " + result1); // 输出: 25
// 一元运算符优先于乘法
int result2 = a * -b; // 先计算 -b，结果是 -5，然后 10 * -5 = -50
System.out.println("Result2 (a * -b): " + result2); // 输出: -50
// 括号中的运算优先于其他运算
int result3 = (a + b) * c; // 先计算括号内的 a + b，结果是 15，然后 15 * 3 = 45
System.out.println("Result3 ((a + b) * c): " + result3); // 输出: 45
// 逻辑运算符的短路特性
boolean condition = false;
boolean result4 = condition || (a == b * c); // 由于condition为false，不会计算 (a == b * c)
System.out.println("Result4 (condition || (a == b * c)): " + result4); // 输出: false
}
}
7.4细节说明
- 括号：括号内的表达式优先级最高，无论括号内的运算符优先级如何，都会优先计算。
- 后缀和前缀运算符：后缀递增/递减和前缀递增/递减运算符用于数值的增加或减少，后缀版本先返回原始值，前缀版本返回修改后的值。
- 一元运算符：包括正负号、逻辑非和按位非，它们对单个操作数进行操作。
- 乘除模、加减：乘法、除法、取模、加法和减法运算符用于数值计算，乘除模优先于加减。
- 位移：位移运算符用于改变数值的二进制表示，左移（
<<）、右移（>>）和无符号右移（>>>）。 - 关系和相等性：关系运算符用于比较两个值的大小，相等性运算符用于比较两个值是否相等或不等。
- 按位AND、XOR、OR：这些运算符用于对两个数值的二进制位进行位操作。
- 逻辑AND、OR：逻辑AND和OR运算符用于布尔逻辑运算，它们具有短路特性，即在结果已确定的情况下，不再计算表达式的其余部分。
- 条件运算符：三元条件运算符提供了一种基于条件表达式选择两个值之一的简洁方式。
- 赋值运算符：赋值运算符用于将一个值赋给变量，组合赋值运算符结合了其他运算符和赋值操作。
了解运算符优先级有助于编写正确的表达式，并避免因优先级错误导致的逻辑错误。在复杂的表达式中，使用括号可以明确指定计算顺序，提高代码的可读性和正确性。
8标识符的命名规则和规范
8.1标识符命名规则介绍
在Java中，标识符是用来命名变量、方法、类、接口、数组等的字符序列。正确地命名标识符对于编写可读性强、易于维护的代码至关重要。
8.2标识符命名规则
- 字母数字：标识符可以包含字母、数字和下划线（_）。
- 非数字开头：标识符不能以数字开头。
- 大小写敏感：Java是大小写敏感的语言，这意味着
identifier和Identifier是两个不同的标识符。 - 关键字不可用：不能使用Java的保留关键字作为标识符。
- Unicode字符：可以使用Unicode字符，包括汉字等其他语言的文字。
- 长度限制：理论上没有长度限制，但过长的标识符会影响代码的可读性。
8.3标识符命名规范
- 驼峰命名法：
- 小驼峰式(camelCase)：变量、方法和对象通常使用小驼峰式命名，即第一个单词的首字母小写，后续单词的首字母大写（例如：
userName，isUserLoggedIn）。 - 大驼峰式(PascalCase)：类、接口和枚举通常使用大驼峰式命名，即每个单词的首字母都大写（例如：
UserName，UserLoginStatus）。
- 小驼峰式(camelCase)：变量、方法和对象通常使用小驼峰式命名，即第一个单词的首字母小写，后续单词的首字母大写（例如：
- 缩写和缩写词：
- 尽量避免缩写，除非它们非常常见和明显（例如：
URL、HTML）。 - 缩写词的每个字母都大写（例如：
HTTP，ID）。
- 尽量避免缩写，除非它们非常常见和明显（例如：
- 描述性命名：标识符名称应该清晰地描述变量或方法的用途。
- 统一性：团队内部应统一命名规范，保持代码风格的一致性。
- 避免过度限定：避免在名称中包含不必要的类型信息或作用域信息。
8.4案例
public class UserAccount {
private String firstName; // 小驼峰式命名，用于存储用户的名字
private String lastName; // 小驼峰式命名，用于存储用户的姓氏
private int age; // 小驼峰式命名，存储用户的年龄
// 构造函数，用于初始化新用户账户
public UserAccount(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
// 设置用户的名字
public void setUserName(String userName) {
// 这里可以添加逻辑来验证 userName 的有效性
this.firstName = userName;
}
// 检查用户是否已登录
public boolean isUserLoggedIn() {
// 这里可以添加逻辑来确定用户是否已登录
// 例如，检查一个登录状态标志或会话ID
return true; // 假设用户总是登录状态，实际应用中应替换为动态检查
}
// 获取用户的全名
public String getFullName() {
return firstName + " " + lastName;
}
// 主方法，仅用于演示 UserAccount 类的使用
public static void main(String[] args) {
// 创建一个 UserAccount 对象
UserAccount user = new UserAccount("John", "Doe", 30);
// 输出用户的全名
System.out.println("User Full Name: " + user.getFullName());
// 检查用户是否已登录
System.out.println("Is User Logged In: " + user.isUserLoggedIn());
}
}
8.5细节说明
- 可读性：良好的命名规范可以提高代码的可读性，使代码更容易被他人理解。
- 维护性：一致且清晰的命名规范有助于代码的维护和后续开发。
- 团队协作：在团队开发中，统一的命名规范可以减少沟通成本，提高开发效率。
- 避免混淆：避免使用容易混淆的名称，如
l（小写的L）和1（数字一），O（大写的o）和0（数字零）。
遵循Java的标识符命名规则和规范，可以帮助开发者编写出更加规范、清晰和易于维护的代码。
9关键字
9.1 Java关键字介绍
Java关键字是Java语言中预先定义好的单词，它们具有特殊的含义和用途。关键字是构建Java程序语法的基础，用于表达程序的特定结构和行为。由于这些关键字已被Java语言本身使用，因此不能用作变量名、方法名、类名或其他标识符。
9.2 Java关键字一览表
以下是Java语言中一些主要的关键字列表：
| 关键字 | 用途 |
|---|---|
abstract | 声明抽象类或方法。 |
assert | 从Java 1.4开始，用于断言测试，需要启用断言功能。 |
boolean | 布尔数据类型，只有true和false两个值。 |
break | 跳出最近的循环或switch语句。 |
byte | 8位有符号整数类型。 |
case | 用于switch语句中，表示一个选项。 |
catch | 异常处理，捕获try块中抛出的异常。 |
char | 16位Unicode字符类型。 |
class | 声明一个类。 |
const | Java中没有const关键字，final关键字用于定义常量。 |
continue | 跳过当前循环的剩余部分，开始新的循环迭代。 |
default | switch语句中的默认选项。 |
do | do-while循环的开始。 |
double | 双精度浮点数类型。 |
else | if语句的否定分支。 |
enum | 枚举类型，从Java 1.5开始。 |
extends | 类或接口的继承。 |
final | 声明一个常量或不可覆盖的方法。 |
finally | 异常处理，try-catch-finally结构中的最后块，总会被执行。 |
float | 单精度浮点数类型。 |
for | for循环的开始。 |
goto | Java中没有goto关键字，因为它被认为是一种不良的程序结构。 |
if | 条件语句。 |
implements | 类实现接口。 |
import | 导入类或包。 |
instanceof | 检查对象是否是特定类的实例。 |
int | 32位整数类型。 |
interface | 声明一个接口。 |
long | 64位整数类型，后缀L或l。 |
native | 声明一个方法是用本地代码实现的。 |
new | 创建对象或数组的新实例。 |
package | 声明包。 |
private | 访问修饰符，限制访问权限为当前类。 |
protected | 访问修饰符，限制访问权限为当前类和子类。 |
public | 访问修饰符，不限制访问权限。 |
return | 方法返回值。 |
short | 16位整数类型。 |
static | 静态方法或属性，属于类而不是类的实例。 |
strictfp | 强制浮点数精度。 |
super | 引用当前对象的父类。 |
switch | switch语句的开始。 |
synchronized | 同步方法或代码块，确保线程安全。 |
this | 引用当前对象。 |
throw | 抛出一个异常。 |
throws | 方法可能抛出的异常列表。 |
transient | 阻止实例的某些字段被序列化。 |
try | 异常处理，尝试执行代码块。 |
void | 无返回类型，用于方法没有返回值时。 |
volatile | 确保变量的更新对所有线程立即可见。 |
while | while循环的开始。 |
9.3 Java关键字案例
public final class HelloWorld {
private static int count = 0;
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
synchronized (HelloWorld.class) {
count++;
}
}
if (count == 5) {
System.out.println("Hello, World!");
}
}
}
9.4 细节说明
- 保留关键字：上述列出的是Java语言中保留的关键字，不能用作标识符。
- 废弃的关键字：Java中还有一些废弃的关键字，如
goto和const，这些在未来的版本中可能会有新的用途。 - 访问控制：
private、protected、public等关键字用于控制类成员的访问权限。 - 类和接口：
class和interface关键字用于声明类和接口。 - 方法相关：
static、final、native等关键字用于方法的声明，表示方法的不同特性。 - 控制流：
if、else、for、while、do、switch、case、default等关键字用于控制程序的流程。 - 异常处理：
try、catch、finally、throw、throws等关键字用于异常的处理和声明。 - 类型和变量：
int、double、boolean等关键字表示基本数据类型；class、interface等关键字表示复合数据类型。
了解Java关键字及其用途对于编写Java程序至关重要，它们是构成Java语言语法规则的基础。
10保留字
10.1 保留字介绍
在Java编程语言中，保留字（也称为未来保留字或潜在保留字）是指当前版本中尚未被用作关键字，但在未来的Java版本中可能会被赋予特殊含义的词汇。保留字和Java的关键字类似，出于兼容性和未来拓展的考虑，建议程序员避免使用这些词汇作为标识符。
10.2 Java保留字一览表
以下是Java语言中一些常见的保留字：
| 保留字 | 说明 |
|---|---|
goto | Java中没有goto语句，goto是保留字，不能用作标识符。 |
const | Java中没有const关键字，可以使用final关键字定义常量。 |
assert | 在Java 1.4中引入作为关键字，用于断言。 |
10.3 Java保留字案例
由于保留字不能用作标识符，以下示例仅用于说明如何避免使用保留字：
// 错误：不能使用保留字作为类名
// class goto { ... }
// 正确：使用不同的名称定义类
class GoTo { ... }
// 错误：不能使用保留字作为变量名
// int const = 10;
// 正确：使用final关键字定义常量
final int CONSTANT = 10;
10.4 细节说明
- 兼容性：保留字的存在是为了保持Java语言的兼容性，便于在未来版本中引入新的语法和特性。
- 避免使用：尽管保留字当前可能不具有特殊含义，但为了避免未来可能的冲突，建议不要使用它们作为标识符。
- 关键字与保留字：关键字在当前和未来的Java版本中都有确定的含义，而保留字主要是为了未来的版本预留。
- Java规范：Java语言规范中会明确哪些是保留字，程序员应当参考最新的Java规范文档来了解保留字的最新列表。
保留字的概念体现了Java语言设计的未来兼容性和扩展性。遵循这一规范，可以帮助开发者编写出更加健壮和适应未来变化的代码。
11键盘输入语句
11.1 键盘输入语句介绍
在Java中，键盘输入可以通过标准输入流来实现，通常是通过System.in获取。最常用的方法是使用java.util.Scanner类，它提供了方便的方法来读取不同类型的输入。
11.2 Java键盘输入语句一览表
| 方法 | 描述 |
|---|---|
Scanner scanner = new Scanner(System.in); | 创建Scanner对象，用于从标准输入读取数据。 |
scanner.hasNextType(); | 检查下一个输入值是否是指定的类型。 |
scanner.hasNext(); | 检查输入中是否有下一个标记。 |
scanner.next(); | 读取下一个字符串或单词。 |
scanner.nextLine(); | 读取输入中的一行，包括空白。 |
scanner.nextInt(); | 读取下一个整数。 |
scanner.nextDouble(); | 读取下一个浮点数。 |
scanner.close(); | 关闭Scanner对象，释放与之相关联的资源。 |
11.3 Java键盘输入语句案例
import java.util.Scanner; // 导入Scanner类
public class KeyboardInputExample {
public static void main(String[] args) {
// 创建Scanner对象，从标准输入（键盘）读取数据
Scanner scanner = new Scanner(System.in);
System.out.print("请输入您的名字: "); // 提示用户输入
String name = scanner.nextLine(); // 读取一行字符串
System.out.print("请输入您的年龄: "); // 提示用户输入
int age = scanner.nextInt(); // 读取一个整数
// 可以继续读取其他类型的输入...
// 输入完毕后，关闭Scanner对象
scanner.close();
// 输出获取的输入数据
System.out.println("你好, " + name + "! 你今年" + age + "岁。");
}
}
11.4 细节说明
- Scanner对象：使用
new Scanner(System.in)创建一个Scanner对象，它被配置为从System.in读取输入。 - 读取输入：
Scanner类提供了一系列next方法来读取不同类型的输入，如nextString(),nextInt(),nextDouble()等。 - 关闭Scanner：在输入读取完成后，应该调用
scanner.close()来关闭Scanner对象，释放系统资源。 - 异常处理：在使用
Scanner读取输入时，应当注意可能会抛出的InputMismatchException异常，这通常发生在输入类型与期望类型不匹配的情况下。 - 缓冲区：
Scanner类使用缓冲区来提高输入效率，因此它不会立即从System.in读取字符，而是在需要时从缓冲区中读取。
Scanner类是Java中处理键盘输入的标准方式，它简单易用，能够满足大多数基本的输入需求。对于更复杂的输入处理，可能需要结合其他类和方法来实现。
12进制
12.1 Java中常用的进制介绍
在计算机科学中，进制（也称为基数或计数系统）是用于指定数字系统的一种方式。Java支持多种进制的数字表示，包括二进制、八进制、十进制和十六进制。了解不同进制的表示对于编程，特别是在底层系统和硬件交互时非常重要。
12.2 进制详细
二进制（Binary）
- 基数：2
- 数字：仅包含
0和1 - 位（bit）：二进制的最小单位，每一位可以表示
0或1 - 表示：
0b或0B前缀，例如0b1010表示二进制的10 - 转换：每三个二进制位可以表示一个八进制数，每四个二进制位可以表示一个十六进制数。
八进制（Octal）
- 基数：8
- 数字：包含
0到7 - 位：八进制的每一位可以表示三个二进制位
- 表示：无前缀或以
0开头，例如0123表示八进制的123 - 转换：八进制每增加一个数位，相当于二进制增加三位。
十进制（Decimal）
- 基数：10
- 数字：包含
0到9 - 位：十进制的每一位可以表示两个二进制位（在计算机科学中，通常不考虑十进制的位表示）
- 表示：通常没有前缀，直接使用数字，例如
123 - 转换：十进制转换到其他进制通常通过除基数取余数的方法。
十六进制（Hexadecimal）
- 基数：16
- 数字：包含
0到9和A到F（或a到f），其中A到F表示十进制的10到15 - 位：十六进制的每一位可以表示四个二进制位
- 表示：
0x或0X前缀，例如0xCAFE表示十六进制的CAFE - 转换：十六进制每增加一个数位，相当于二进制增加四位。
12.3进制转换示例
二进制转八进制
- 将二进制数分组为每三个位一组（从右到左）。
- 将每组转换为对应的八进制数字。
例如，二进制101101转换为八进制：
- 分组：
101 101 - 转换：
5 5 - 结果：
八进制 55
二进制转十六进制
- 将二进制数分组为每四个位一组（从右到左）。
- 将每组转换为对应的十六进制数字。
例如，二进制1101 0011转换为十六进制：
- 分组：
1101 0011 - 转换：
D 3 - 结果：
十六进制 D3
八进制转十进制
- 从最右边的八进制数字开始，每数字乘以8的相应权重（从0开始）。
- 求和得到十进制数。
例如，八进制123转换为十进制：
1*8^2 + 2*8^1 + 3*8^0 = 64 + 16 + 3 = 83
十六进制转十进制
- 从最右边的十六进制数字开始，每数字乘以16的相应权重（从0开始）。
- 求和得到十进制数。
例如，十六进制1A3转换为十进制：
1*16^2 + 10*16^1 + 3*16^0 = 256 + 160 + 3 = 419
十进制转二进制
- 不断除以2并记录余数。
- 将余数倒序排列。
例如，十进制25转换为二进制：
25 / 2 = 12...112 / 2 = 6...06 / 2 = 3...03 / 2 = 1...11 / 2 = 0...1- 结果：
二进制 11001
十进制转八进制
- 不断除以8并记录余数。
- 将余数倒序排列。
例如，十进制255转换为八进制：
255 / 8 = 31...731 / 8 = 3...73 / 8 = 0...3- 结果：
八进制 377
十进制转十六进制
- 不断除以16并记录余数。
- 将余数倒序排列，并转换为相应的十六进制字符。
例如，十进制255转换为十六进制：
255 / 16 = 15...1515转换为十六进制是F- 结果：
十六进制 FF
了解不同进制之间的转换对于编程和计算机科学非常重要，特别是在处理二进制数据和内存表示时。Java提供了内置的方法来处理这些转换，简化了编程任务。
12.4 Java中进制转换案例
public class NumberSystemConversion {
public static void main(String[] args) {
// 二进制到十进制
int binary = 0b1010; // 二进制字面量
int decimal = binary; // Java自动转换为十进制
System.out.println("二进制1010转换为十进制是: " + decimal);
// 八进制到十进制
int octal = 0123; // 八进制字面量
System.out.println("八进制123转换为十进制是: " + octal);
// 十六进制到十进制
int hex = 0xCAFE; // 十六进制字面量
System.out.println("十六进制CAFE转换为十进制是: " + hex);
// 十进制到二进制、八进制、十六进制
int decimalNumber = 20;
String binaryString = Integer.toBinaryString(decimalNumber); // 十进制转二进制
String octalString = Integer.toOctalString(decimalNumber); // 十进制转八进制
String hexString = Integer.toHexString(decimalNumber); // 十进制转十六进制
System.out.println("十进制20转换为二进制是: " + binaryString);
System.out.println("十进制20转换为八进制是: " + octalString);
System.out.println("十进制20转换为十六进制是: " + hexString);
}
}
12.5 细节说明
- 字面量表示：Java允许使用特定的前缀来表示二进制、八进制和十六进制的字面量。
- 自动转换：在Java中，二进制、八进制和十六进制的字面量可以自动转换为十进制数值。
- 转换方法：
Integer类提供了toBinaryString、toOctalString和toHexString方法，用于将十进制整数转换为不同的进制字符串表示。 - 数值范围：在转换时，需要注意数值范围，确保转换后的数值在目标进制中是有效的。
- 编程实践：在编程中，通常使用十进制进行逻辑处理，而使用二进制、八进制或十六进制进行底层操作或内存表示。
掌握不同进制之间的转换对于理解计算机的工作原理和进行有效的编程非常重要。Java提供了方便的机制和方法来处理这些进制的转换。
13位运算
13.1 位运算介绍
位运算（Bitwise operations）是直接对整数的二进制位进行的运算。在Java中，位运算符可以对基本数据类型的整数（byte, short, int, long）进行操作。位运算在某些情况下非常有用，比如在需要设置或清除特定位的标记、进行高效的乘除运算，或者在底层硬件操作中。
13.2 Java位运算符一览表
| 运算符 | 符号 | 描述 |
|---|---|---|
| 按位与 | & | 对应位都为1时，结果才为1。 |
| 按位或 | ` | ` |
| 按位异或 | ^ | 对应位相异时结果为1，相同则为0。 |
| 按位非 | ~ | 反转操作数的每一位，将1变为0，将0变为1。 |
| 左移 | << | 将一个数的二进制表示向左移动指定位数，右边用0填充。 |
| 右移 | >> | 将一个数的二进制表示向右移动指定位数，左边的符号位不变。 |
| 无符号右移 | >>> | 将一个数的二进制表示向右移动指定位数，左边用0填充。 |
13.3 Java位运算案例
public class BitwiseOperations {
public static void main(String[] args) {
int a = 60; // 0011 1100
int b = 13; // 0000 1101
int result;
// 按位与
result = a & b; // 0000 1100
System.out.println("按位与: " + Integer.toBinaryString(result));
// 按位或
result = a | b; // 0011 1101
System.out.println("按位或: " + Integer.toBinaryString(result));
// 按位异或
result = a ^ b; // 0011 0001
System.out.println("按位异或: " + Integer.toBinaryString(result));
// 按位非
result = ~a; // 1100 0011
System.out.println("按位非(a): " + Integer.toBinaryString(result));
// 左移
result = a << 2; // 1111 0000
System.out.println("左移两位: " + Integer.toBinaryString(result));
// 右移
result = a >> 2; // 0000 0011
System.out.println("右移两位(带符号): " + Integer.toBinaryString(result));
// 无符号右移
result = a >>> 2; // 0000 1111
System.out.println("右移两位(无符号): " + Integer.toBinaryString(result));
}
}
13.4 细节说明
- 按位与 (
&)：常用于检查特定位是否同时为1。 - 按位或 (
|)：常用于设置特定的位为1。 - 按位异或 (
^)：常用于切换特定的位，或者清除特定的位（当与1的掩码异或时）。 - 按位非 (
~)：用于反转所有的位，经常用于取反或求补码。 - 左移 (
<<)：相当于乘以2的n次幂，其中n是左移的位数。 - 右移 (
>>)：相当于除以2的n次幂并向下取整，保留符号位。 - 无符号右移 (
>>>)：相当于除以2的n次幂并向下取整，忽略符号位，用0填充左边。
位运算符在编程中通常用于底层系统编程、性能优化、加密算法、数据压缩、网络编程等场景。由于位运算直接操作内存中的位，因此它们通常比算术运算更快，但使用时需要小心，以避免潜在的错误。
9072
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
