一、注释
在 Java 里，注释扮演着解释代码、增强代码可读性的重要角色，并且编译器会直接忽略它们。Java 提供了三种不同类型的注释，下面会为你逐一详细讲解。
1.1 单行注释
语法格式：以双斜杠 // 起始，从 // 开始到本行结束的所有内容都会被视为注释。
示例代码：
public class Main {
public static void main(String[] args) {
// 这行代码用于输出问候语
System.out.println("您好!");
}
}
使用场景：常用于对某一行代码或者代码片段进行简单说明。
1.2 多行注释
语法格式：以 /* 开头，以 */ 结尾，其间的所有内容均为注释，可以跨越多行。
示例代码：
public class Main{
public static void main(String[] args) {
/*
* 以下代码块用于计算两个整数的和
* 首先定义两个整数变量
* 然后将它们相加并输出结果
*/
int a = 5;
int b = 3;
int sum = a + b;
System.out.println("两数之和: " + sum);
}
}
使用场景：当需要对一段代码进行较为详细的解释，且内容较多时，使用多行注释能使代码结构更清晰。
1.3 文档注释
语法格式：以 /** 开头，以 */ 结尾，通常用于为类、方法、字段等添加文档说明。可以使用特定的标签（如 @param、@return、@author 等）来提供更详细的信息，这些注释可通过 Java 的 javadoc 工具生成 API 文档。
示例代码：
/**
* 这是一个表示书籍的类，包含书籍的基本信息和相关操作。
*
* @author 野生派蒙
* @version 1.0
*/
public class Book {
private String title;
private String author;
/**
* 构造一个书籍对象。
*
* @param title 书籍的标题
* @param author 书籍的作者
*/
public Book(String title, String author) {
this.title = title;
this.author = author;
}
/**
* 获取书籍的标题。
*
* @return 书籍的标题
*/
public String getTitle() {
return title;
}
/**
* 获取书籍的作者。
*
* @return 书籍的作者
*/
public String getAuthor() {
return author;
}
}
使用场景：主要用于生成项目的 API 文档，方便其他开发者了解类、方法的功能、使用方法、参数含义和返回值等信息。使用 javadoc 工具可以将这些文档注释提取出来生成 HTML 格式的文档，命令示例如下：
javadoc -d doc Book.java
上述命令会 Book 类的所在目录创建一个 doc 目录，在 doc 目录下生成 Book 类的 API 文档。
1.4 注意事项
需要着重强调的是，注释的质量至关重要。千万不要为了写注释而写注释，这种做法不仅毫无益处，反而会加重阅读者的理解负担。若决定添加注释，务必保证注释条理清晰、逻辑合理。
实际编程过程中，若要求为每处代码都添加注释，很容易造成过度注释的情况。当注释无法提供额外的有用信息时，它们只会让代码变得冗余，而无法真正提升代码的可读性。
一般而言，代码自身具备良好的表达力且仅带有少量必要注释，远比充斥大量注释但结构零碎、逻辑复杂的代码更胜一筹。与其花费时间去编写注释来解释糟糕的代码，倒不如把时间用在优化和清理那堆糟糕的代码上。
二、标识符、关键字
标识符是用来给变量、类、方法以及包等命名的符号，简单来说，就是你在代码里自己起的名字。
命名规则：
-
由合法字符组成：可以由字母、数字、下划线（_）和美元符号（$）组成。
-
不能以数字开头：数字只能出现在标识符的中间或末尾。
-
区分大小写：Java 是大小写敏感的，myVariable 和 MyVariable 是两个不同的标识符。
-
不能是关键字：不能使用 Java 的关键字作为标识符。
命名规范：
-
类名：通常采用大驼峰命名法，即每个单词的首字母大写，如 UserMapper。
-
方法名和变量名：通常采用小驼峰命名法，即第一个单词的首字母小写，后续单词的首字母大写，如 myName、mySchool。
-
常量名：全部使用大写字母，单词之间用下划线分隔，如 MAX_SPEED。
关键字是 Java 语言中被赋予特定含义的保留字，这些关键字不能作为标识符使用。
常见关键字：
- 数据类型相关：int、double、char、boolean 等，用于声明不同类型的变量。
- 流程控制相关：if、else、for、while、switch 等，用于控制程序的执行流程。
- 类、方法、修饰符相关：class、public、private、protected、static、final 等，用于定义类、方法和变量的访问权限和特性。
- 异常处理相关：try、catch、finally、throw、throws 等，用于处理程序中可能出现的异常。
三、字面量
在 Java 中，字面量是直接出现在代码中的固定值，它代表了一个具体的数据，不同类型的字面量有其特定的表示方式，开发者可以根据需求选择合适的字面量类型进行赋值操作。以下是不同数据类型对应的字面量介绍。
3.1 整数类型
整数类型字面量用于表示整数数值，Java 支持四种整数类型：byte、short、int 和 long。
默认情况下，整数字面量是 int 类型，所以如果想表达 long 类型的整数，要在整数的后面加上 L 或者 l，建议使用 L，避免和数字 1 混淆。
public class Main {
public static void main(String[] args) {
// 整数类型
System.out.println("十进制：" + 10);
System.out.println("二进制：" + 0b1010);
System.out.println("八进制：" + 012);
System.out.println("十六进制：" + 0xA);
System.out.println("long 类型：" + 10L);
}
}
运行结果：
十进制：10
二进制：10
八进制：10
十六进制：10
long 类型：10
3.2 浮点数类型
浮点类型字面量用于表示带小数部分的数值，Java 支持两种浮点类型：float 和 double。
默认情况下，小数字面量是 double 类型，如果要表示 float 类型的小数，要在小数后面加上 F 或 f。
public class Main {
public static void main(String[] args) {
// 浮点数类型
System.out.println("double 类型：" + 3.14);
System.out.println("float 类型：" + 3.14f);
}
}
运行结果：
double 类型：3.14
float 类型：3.14
3.3 字符类型
字符类型字面量用于表示单个字符，使用单引号括起来，还可以使用转义序列来表示一些特殊字符。
public class Main {
public static void main(String[] args) {
// 字符类型
System.out.println("字符：" + 'A');
System.out.println("换行符：" + '\n' + 'B');
System.out.println("制表符：" + '\t' + 'C');
}
}
运行结果：
字符：A
换行符：
B
制表符： C
3.4 字符串类型
字符串类型字面量用于表示一串字符，使用双引号括起来。
public class Main {
public static void main(String[] args) {
// 字符串类型
System.out.println("字符串类型：" + "Hello,World!");
}
}
运行结果：
字符串类型：Hello,World!
3.5 布尔类型
布尔类型字面量只有两个值：true 和 false，用于表示逻辑真和逻辑假。
public class Main {
public static void main(String[] args) {
// 布尔类型
System.out.println("逻辑真：" + true);
System.out.println("逻辑假：" + false);
}
}
运行结果：
逻辑真：true
逻辑假：false
3.6 null 类型
null 字面量只有一个值 null，用于表示一个引用类型的变量不引用任何对象。
public class Main {
public static void main(String[] args) {
// null 类型
System.out.println("null：" + null);
}
}
运行结果：
null：null
四、数据类型
在 Java 中，数据类型用于定义变量或表达式可以存储的数据的种类和范围。Java 是一种强类型语言，这意味着每个变量都必须先声明其数据类型，才能进行使用。Java 的数据类型主要分为两大类：基本数据类型和引用数据类型。
4.1 基本数据类型
Java 有 8 种基本数据类型，它们可以进一步划分为 4 种整数类型、2 种浮点类型、1 种字符类型和 1 种布尔类型，不同的数据类型具有不同的取值范围、默认值和占用的存储空间。
| 基本数据类型 | 字节 | 默认值 | 取值范围 |
|---|---|---|---|
| byte | 1 | 0 | -128 ~ 127 |
| short | 2 | 0 | -32768 ~ 32767 |
| int | 4 | 0 | -2147483648 ~ 2147483647 |
| long | 8 | 0L | -9223372036854775808 ~ 9223372036854775807 |
| float | 4 | 0.0f | 1.4E-45 ~ 3.4028235E38 |
| double | 8 | 0.0d | 4.9E-324 ~ 1.7976931348623157E308 |
| char | 2 | ‘\u0000’ | 0 ~ 65535 |
| boolean | false | true 或 false |
注意事项
（1）对于 boolean 类型，官方文档未明确定义其存储空间，它主要依赖于 JVM 厂商的具体实现。boolean 单独使用，占 4 个字节；boolean 以数组的形式使用，占 1 个字节，这一结论在遵循《Java 虚拟机规范》的 JVM 中是成立的，但对于不遵循规范的 JVM 则不一定适用。因为《Java 虚拟机规范》只是一种指导性的标准，不同的 JVM 实现者可以根据自身的需求和设计进行调整。有些 JVM 可能会遵循规范严格实现，而有些 JVM 可能会采用不同的优化策略来存储 boolean 类型。所以，如果某个 JVM 没有遵循规范，那么 boolean 类型实际占用的字节数就无法依据规范来确定，可能需要通过具体的测试或者查阅该 JVM 的文档来了解。
（2）Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为 int 整型解析。
（3）Java 里使用 float 类型的数据一定要在数值后面加上 f 或 F，否则将作为 double 浮点型解析。
4.2 引用数据类型
引用数据类型是对对象的引用，而不是对象本身。引用数据类型包括类、接口、数组等。
类
类是 Java 中最常见的引用数据类型，通过定义类可以创建对象。例如，String 类是 Java 中原本就有的引用类，用于表示字符串。
public class Main {
public static void main(String[] args) {
// 创建一个 String 对象
String str = "Hello, World!";
}
}
接口
接口是一种抽象类型，它定义了一组方法的签名，但没有实现这些方法。类可以实现接口，从而实现接口中定义的方法。
// 定义一个接口
interface MyInterface {
void doSomething();
}
// 实现接口的类
class MyClass implements MyInterface {
@Override
public void doSomething() {
System.out.println("Doing something...");
}
public static void main(String[] args) {
// 使用接口类型的引用
MyInterface obj = new MyClass();
obj.doSomething();
}
}
运行结果：
Doing something...
数组
数组是一种用于存储多个相同类型元素的容器。数组也是引用数据类型，通过数组名引用数组对象。
public class Main {
public static void main(String[] args) {
// 创建一个整数数组
int[] numbers = {
1, 2, 3, 4, 5};
}
}
4.3 两种类型的区别
存储方式：基本数据类型直接存储数据的值，而引用数据类型存储的是对象的引用（内存地址）。
默认值：基本数据类型有默认值，而引用数据类型的默认值为 null。
传递方式：基本数据类型在方法调用时传递的是值的副本，而引用数据类型传递的是引用的副本，它们都指向同一个对象。
综上所述，Java 的数据类型系统为开发者提供了丰富的选择，能够满足不同场景下的数据处理需求。
4.4 自动数据类型转换
自动类型转换（也称为隐式类型转换）是指在某些情况下，Java 编译器会自动将一种数据类型转换为另一种数据类型，而无需程序员显式地进行类型转换操作。
要发生自动类型转换，必须满足以下两个条件：
-
目标类型的范围要大于源类型：即目标数据类型能够容纳源数据类型的所有可能值。例如，int 类型的数据可以自动转换为 long 类型，因为 long 类型的取值范围比 int 类型大。
-
数据类型要兼容：通常是基本数据类型之间或者存在继承关系的引用数据类型之间才可能发生自动类型转换。基本数据类型中，整数类型、浮点类型之间有一定的转换规则；引用数据类型中，子类对象可以自动转换为父类对象。
基本数据类型的自动类型转换顺序大致如下（从低到高）：byte -> short -> char -> int -> long -> float -> double
示例代码：
public class Main {
public static void main(String[] args) {
// byte 类型自动转换为 int 类型
byte byteNum = 10;
int intNum = byteNum;
System.out.println("byte 转换为 int: " + intNum);
// int 类型自动转换为 long 类型
int anotherInt = 20;
long longNum = anotherInt;
System.out.println("int 转换为 long: " + longNum);
// int 类型自动转换为 float 类型
int intValue = 30;
float floatNum = intValue;
System.out.println("int 转换为 float: " + floatNum);
// long 类型自动转换为 double 类型
long longValue = 40L;
double doubleNum = longValue;
System.out.println("long 转换为 double: " + doubleNum);
}
}
代码解释：
byte 类型的变量 byteNum 可以自动转换为 int 类型，因为 int 类型的取值范围包含了 byte 类型的取值范围。同理，int 可以自动转换为 long、float，long 可以自动转换为 double。
注意事项：
自动类型转换是由 Java 编译器自动完成的，不会丢失数据（在满足转换条件的情况下），在进行混合运算时，如果操作数的数据类型不同，会自动将较低类型转换为较高类型进行计算。例如，int 和 double 进行运算，int 会自动转换为 double 类型。
4.5 强制数据类型转换
在 Java 中，当需要将一种数据类型转换为另一种数据类型，且不满足自动类型转换的条件时，就可以使用强制类型转换。强制类型转换是一种显式的类型转换方式，需要程序员手动指定要转换的目标类型。
语法格式： (目标数据类型) 表达式。这里的表达式可以是一个变量、常量或者其他合法的表达式。通过这种方式，将表达式的结果强制转换为指定的目标数据类型。
注意事项： 基本数据类型的强制转换通常是将取值范围大的数据类型转换为取值范围小的数据类型，这种转换可能会导致数据丢失。
代码示例：
public class Main {
public static void main(String[] args) {
// double 类型强制转换为 int 类型
double doubleNum = 10.7;
int intNum = (int) doubleNum;
System.out.println("double 强制转换为 int: " + intNum);
// int 类型强制转换为 byte 类型
int largeInt = 257;
byte byteNum = (byte) largeInt;
System.out.println("int 强制转换为 byte: " + byteNum);
// char 类型和 int 类型的强制转换
char charValue = 'A';
System.out.println("char 强制转换为 int (ASCII 值): " + (int) charValue);
int anotherAscii = 66;
char anotherChar = (char) anotherAscii;
System.out.println("int (ASCII 值) 强制转换为 char: " + anotherChar);
}
}
代码解释：
-
double 转 int：将 double 类型的 10.7 强制转换为 int 类型时，小数部分会被直接截断，结果为 10。
-
int 转 byte：byte 类型的取值范围是 -128 到 127，而 257 超出了这个范围，强制转换后会发生数据溢出，结果可能不符合预期。257 的二进制表示在强制转换为 byte 时，只保留低 8 位，最终结果为 1。
-
char 与 int 互转：char 类型可以和 int 类型相互转换，char 类型存储的是字符的 Unicode 码值，将 char 强制转换为 int 可以得到其对应的码值；将 int 强制转换为 char 可以根据码值得到对应的字符。
4.5 数据类型自动提升
在 Java 中，当在一个表达式中使用不同数据类型的操作数进行运算时，Java 编译器会自动将这些操作数的数据类型提升为一种统一的数据类型，然后再进行计算，这种自动转换是为了避免数据丢失，保证计算结果的精度。。
转换公式：
- 如果表达式中有 double 类型的操作数，其他操作数都会被提升为 double 类型，计算结果也是 double 类型。
- 如果表达式中没有 double 类型，但有 float 类型的操作数，其他操作数都会被提升为 float 类型，计算结果也是 float 类型。
- 如果表达式中没有 double 和 float 类型，但有 long 类型的操作数，其他操作数都会被提升为 long 类型，计算结果也是 long 类型。
- 如果以上情况都不满足，所有操作数都会被提升为 int 类型，计算结果也是 int 类型。
代码示例：
public class Main {
public static void main(String[] args) {
// 1. 包含 double 类型的运算
int intNum = 5;
double doubleNum = 3.14;
// intNum 会被提升为 double 类型
double result1 = intNum + doubleNum;
System.out.println("包含 double 类型的运算结果: " + result1);
// 2. 包含 float 类型的运算
short shortNum = 10;
float floatNum = 2.5f;
// shortNum 会被提升为 float 类型
float result2 = shortNum + floatNum;
System.out.println("包含 float 类型的运算结果: " + result2);
// 3. 包含 long 类型的运算
byte byteNum = 3;
long longNum = 100L;
// byteNum 会被提升为 long 类型
long result3 = byteNum + longNum;
System.out.println("包含 long 类型的运算结果: " + result3);
// 4. 不包含 double、float、long 类型的运算
char charValue = 'A';
int anotherInt = 20;
// charValue 会被提升为 int 类型
int result4 = charValue + anotherInt;
System.out.println("不包含 double、float、long 类型的运算结果: " + result4);
}
}
代码解释：
- 包含 double 类型的运算：int 类型的 intNum 与 double 类型的 doubleNum 相加时，intNum 会被自动提升为 double 类型，最终结果也是 double 类型。
- 包含 float 类型的运算：short 类型的 shortNum 与 float 类型的 floatNum 相加时，shortNum 会被提升为 float 类型，结果为 float 类型。
- 包含 long 类型的运算：byte 类型的 byteNum 与 long 类型的 longNum 相加时，byteNum 会被提升为 long 类型，结果为 long 类型。
- 不包含 double、float、long 类型的运算：char 类型的 charValue 与 int 类型的 anotherInt 相加时，charValue 会被提升为 int 类型，结果为 int 类型。
注意事项:
- 数据类型提升是 Java 编译器自动完成的，无需程序员手动干预。
- 数据类型提升可以避免数据丢失，但在某些情况下可能会导致内存使用增加，因为转换为更大的数据类型需要更多的存储空间。
- 在赋值时，如果将提升后的数据类型结果赋值给较小的数据类型变量，可能需要进行强制类型转换，否则会导致编译错误。
五、变量
在 Java 中，变量是存储数据的容器。当程序需要处理数据时，会将数据存储在变量中，方便后续使用和操作。
5.1 变量的声明
在 Java 里，要使用一个变量，首先需要对其进行声明，也就是告诉编译器变量的类型和名称。声明变量的基本语法格式如下：
数据类型 变量名;
以下是不同数据类型变量声明的示例：
public class Main {
public static void main(String[] args) {
// 整型
int number;
// 浮点型
double price;
// 字符型
char grade;
// 布尔型
boolean isStudent;
// 字符串类型
String name;
}
}
5.2 变量的初始化
变量声明之后，此时没有实际的值，需要对其进行初始化，也就是给变量赋一个具体的值，。初始化可以在声明变量时同时进行，也可以在声明之后再赋值。
public class Main {
public static void main(String[] args) {
// 声明时初始化
int number = 10;
double price = 9.4;
char grade = 'A';
boolean isStudent = true;
String name = "野生派蒙";
// 声明后初始化
String city;
city = "江西南昌";
}
}
5.3 变量的作用域
变量的作用域指的是变量在程序中可以被访问的范围。在 Java 中，变量主要有以下几种作用域：
局部变量
局部变量在方法、构造方法或者代码块中声明，它的作用域仅限于声明它的块内部，在代码块的外部无法访问该变量。
public class Main {
public static void main(String[] args) {
// 局部变量
int localVar = 10;
System.out.println(localVar);
}
// 这里无法访问 localVar
}
成员变量（实例变量）
成员变量定义在类中，但在方法、构造方法或语句块之外。每个对象都有自己独立的成员变量副本。如果不进行显式初始化，会有默认值。
public class Main {
// 成员变量
int instanceVar;
public static void main(String[] args) {
Main obj = new Main ();
System.out.println(obj.instanceVar); // 输出默认值 0
}
}
静态变量（类变量）
静态变量使用 static 关键字修饰，属于类本身，而不是类的某个实例。一个类的所有实例共享同一个静态变量。同样，如果不初始化，也有默认值。
public class Main {
// 静态变量
static int classVar = 20;
public static void main(String[] args) {
System.out.println(Main .classVar);
}
}
5.4 变量的命名规则
在 Java 中，变量命名需要遵循一定的规则和规范：
-
规则：
- 变量名只能包含字母、数字、下划线 _ 和美元符号 $。
- 变量名不能以数字开头。
- 变量名不能是 Java 中的关键字。
-
规范：
- 采用驼峰命名法，即如果变量名由多个单词组成，第一个单词首字母小写，后续单词首字母大写，如 studentName。
- 变量名要具有描述性，能够清晰表达变量的用途，避免使用无意义的名称。
六、运算符
在 Java 中，运算符是用于执行各种操作的特殊符号，根据其功能和操作数的数量，可将运算符分为多种类型，以下是运算符的详细介绍。
6.1 算术运算符
算术运算符用于执行基本的数学运算，主要包括：
| 运算符 | 描述 |
|---|---|
| + | 加法运算，也可以用作字符串连接 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算，整数相除结果为整数，直接将小数抹去，而不是四舍五入 |
| % | 取模运算，求两数相除之后的余数 |
| ++ | 自增运算符，分为前缀自增和后缀自增 |
| - - | 自减运算符，分为前缀自减和后缀自减 |
代码示例：
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 3;
System.out.println("加法: " + (a + b));
System.out.println("减法: " + (a - b));
System.out.println("乘法: " + (a * b));
System.out.println("除法: " + (a / b));
System.out.println("取模: " + (a % b));
int num = 5;
System.out.println("后缀自增: " + num++);
System.out.println("后缀自减：" + num--);
System.out.println("前缀自减: " + --num);
System.out.println("前缀自增：" + ++num);
}
}
运行结果：
加法: 13
减法: 7
乘法: 30
除法: 3
取模: 1
后缀自增: 5
后缀自减：6
前缀自减: 4
前缀自增：5
6.2 关系运算符
关系运算符用于比较两个值之间的关系，结果为布尔类型（true 或 false），常见的关系运算符有：
| 运算符 | 描述 |
|---|---|
| == | 判断两个值是否相等 |
| != | 判断两个值是否不相等 |
| > | 判断左边的值是否大于右边的值 |
| < | 判断左边的值是否小于右边的值 |
| >= | 判断左边的值是否大于等于右边的值 |
| <= | 判断左边的值是否小于等于右边的值 |
代码示例：
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("相等: " + (a == b));
System.out.println("不相等: " + (a != b));
System.out.println("大于: " + (a > b));
System.out.println("小于: " + (a < b));
System.out.println("大于等于: " + (a >= b));
System.out.println("小于等于: " + (a <= b));
}
}
运行结果：
相等: false
不相等: true
大于: false
小于: true
大于等于: false
小于等于: true
6.3 逻辑运算符
逻辑运算符用于对布尔值进行逻辑运算，主要包括：
| 运算符 | 描述 |
|---|---|
| && | 逻辑与，只有当两个操作数都为 true 时，结果才为 true |
| || | 逻辑或，只要有一个操作数为 true，结果就为 true |
| ! | 逻辑非，对操作数取反，true 变 false，false 变 true |
代码示例：
public class Main {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("逻辑与: " + (a && b));
System.out.println("逻辑或: " + (a || b));
System.out.println("逻辑非: " + (!a));
}
}
运行结果：
逻辑与: false
逻辑或: true
逻辑非: false
6.4 位运算符
位运算符用于对整数类型（byte、short、int、long）的二进制位进行操作，常见的位运算符有：
| 运算符 | 描述 |
|---|---|
| & | 按位与，对应位都为 1 时结果为 1 |
| | | 按位或，对应位只要有一个为 1 结果为 1 |
| ^ | 按位异或，对应位不同时结果为 1 |
| ~ | 按位取反，将每一位取反 |
| << | 左移运算符，将二进制位向左移动指定的位数 |
| >> | 右移运算符，将二进制位向右移动指定的位数，符号位不变 |
| >>> | 无符号右移运算符，将二进制位向右移动指定的位数，高位补 0 |
代码示例：
public class Main {
public static void main(String[] args) {
int a = 5; // 二进制: 0101
int b = 3; // 二进制: 0011
System.out.println("按位与: " + (a & b));
System.out.println("按位或: " + (a | b));
System.out.println("按位异或: " + (a ^ b));
System.out.println("按位取反: " + (~a));
System.out.println("左移: " + (a << 2));
System.out.println("右移: " + (a >> 2));
System.out.println("无符号右移: " + (a >>> 2));
}
}
运行结果：
按位与: 1
按位或: 7
按位异或: 6
按位取反: -6
左移: 20
右移: 1
无符号右移: 1
提示：一般平时开发不会怎么用，但是如果你参加一些算法比赛或者阅读源码的时候可能会碰到，因为计算机底层都是二进制，使用位运算可以直接操作二进制位，避免了数据在不同进制或类型之间转换的开销，从而提高程序的执行效率。
记住：左移一位相当于乘2，右移一位相当于除2（整数的除法会将小数抹去）。
6.5 赋值运算符
用于将一个值经过算术运算后再赋给变量，常见的赋值运算符有：
| 运算符 | 描述 |
|---|---|
| = | 简单赋值运算符，将右边的值赋给左边的变量 |
| += | 加等于，先进行加法运算，再将结果赋给左边的变量 |
| -= | 减等于，先进行减法运算，再将结果赋给左边的变量 |
| *= | 乘等于，先进行乘法运算，再将结果赋给左边的变量 |
| /= | 除等于，先进行除法运算，再将结果赋给左边的变量 |
| %= | 模等于，先进行取模运算，再将结果赋给左边的变量 |
代码示例
public class Main {
public static void main(String[] args) {
int num = 5;
num += 3;
System.out.println("加等于: " + num);
num -= 2;
System.out.println("减等于: " + num);
num *= 4;
System.out.println("乘等于: " + num);
num /= 2;
System.out.println("除等于: " + num);
num %= 3;
System.out.println("模等于: " + num);
}
}
运行结果：
加等于: 8
减等于: 6
乘等于: 24
除等于: 12
模等于: 0
6.6 三元运算符
三元运算符是 Java 中唯一的一个三目运算符，用于根据一个布尔表达式的结果来选择两个值中的一个，如果布尔表达式为 true，则返回表达式 1 的值；否则返回表达式 2 的值。
语法格式： 布尔表达式 ? 表达式 1 : 表达式 2。
示例代码：
public class TernaryOperatorExample {
public static void main(String[] args) {
int a = 10;
int b = 20;
int max = (a > b) ? a: b;
System.out.println("最大值: " + max);
}
}
运行结果：
最大值: 20
6.7 运算符的优先级
在 Java 中，运算符的优先级决定了表达式中运算符执行的先后顺序。优先级高的运算符会先进行计算，当运算符优先级相同时，按照从左到右或从右到左来确定计算顺序。以下是 Java 中常见运算符的优先级列表，从高到低排列：
| 优先级 | 运算符 |
|---|---|
| 1 | ( ) [ ] . |
| 2 | ! ~ - - ++ + - |
| 3 | * / % |
| 4 | + - |
| 5 | << >> >>> |
| 6 | < <= > >= instanceof |
| 7 | == != |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ? : |
| 14 | = += -= *= /= %= &= |
| 15 | ， |
这么多运算符不需要全部记住，只需要记住，当你想改变表达式的执行顺序时，用小括号括起来就好。
七、结语
本篇文章只讲了 Java 基础语法的一半，为了避免文章过长，我打算在下一篇文章讲解另外一部分，内容大概是：流程控制语句、方法和数组。
这篇文章大概 14500 字，在数据类型转换和运算符那一块需要细心一点，其他部分只要记住，然后多敲多练就好。如果有什么问题，欢迎在评论区中留言评论。
至此，本文结束，如果这篇文章对您有所帮助，希望可以点赞、收藏加关注，感谢。