Java 基础

概述

Java 用途

Java 是用于开发应用程序的编程语言。程序就是计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合。主要用于以下几个核心领域：

Android 应用开发：Java 是 Android 平台开发的主要语言之一。许多我们日常使用的手机 App，如 Spotify、Signal 等，都是使用 Java 构建的。
企业级后端开发：这是 Java 最重要的应用场景。凭借其稳定性、安全性和高并发处理能力，Java 成为企业级服务端开发的首选。大量的银行、金融交易系统、大型电商网站（如 Twitter、LinkedIn）的后台都> 是由 Java 驱动的。
大数据处理：Java 是许多大数据技术生态的核心语言，例如 Hadoop 和 Spark 等框架都是用 Java 编写的，广泛用于处理和分析海量数据。
桌面应用程序：Java 可以开发跨平台的桌面软件。著名的集成开发环境（IDE）如 IntelliJ IDEA 和 Eclipse 本身就是用 Java 开发的桌面应用。
游戏开发：Java 也被用于游戏开发，最著名的例子就是风靡全球的沙盒游戏《我的世界》（Minecraft）。
嵌入式系统与物联网 (IoT)得益于其跨平台和稳定性，Java 还被应用于智能电视、车载系统、工业控制设备等嵌入式和物联网领域。

Java 历史

🌱 起源：从“Oak”到“Java” (1991-1994)

Java 的故事始于 1991 年，当时 Sun Microsystems 公司启动了一个名为“绿色计划”（Green Project）的秘密项目。

最初目标：由詹姆斯·高斯林（James Gosling）等人领导的团队，旨在为下一代智能消费电子产品（如机顶盒、交互式电视）开发一种新的编程语言。

命名“Oak”： Gosling 将这门新语言命名为“Oak”（橡树），灵感来自他办公室窗外的一棵树。然而，由于硬件厂商接受度低，该项目在消费电子市场遭遇失败。

关键转折： 1994 年，互联网（Web）开始兴起。团队敏锐地意识到，Oak 语言所具备的安全性、网络移动性和跨平台特性，完美契合了互联网“网络即计算机”的愿景。

正式更名：由于“Oak”已被注册为商标，团队选择了“Java”作为新名字，灵感来自印度尼西亚的爪哇咖啡。

🚀 爆发：互联网时代的宠儿 (1995-1999)

1995 年是 Java 历史上最重要的一年。

正式发布： 1995 年 5 月 23 日，Sun Microsystems 在 SunWorld 大会上正式发布 Java 1.0，并提出了著名的口号 “Write Once, Run Anywhere” (WORA)，即“一次编写，到处运行”。

引爆互联网： Java 的跨平台特性解决了当时软件开发的最大痛点。Netscape Navigator 浏览器迅速集成 Java 技术，使得 Java Applet（小程序）成为当时网页上实现动态交互的最热门技术。

随后的几年是 Java 标准化和壮大的关键期。

1996年： JDK 1.0 正式发布，标志着 Java 进入主流开发视野。

1997年： JDK 1.1 引入了 JDBC（数据库连接）、RMI（远程方法调用）和内部类等特性，完善了语言基础设施。

1998年： JDK 1.2 是一个里程碑版本，它被重命名为 “Java 2”，并首次将 Java 平台划分为三个版本，这一战略奠定了 Java 随后二十年的发展格局：

J2SE (Java 2 Standard Edition)：面向桌面和工作站的通用开发。

J2EE (Java 2 Enterprise Edition)：面向服务器端企业级应用，包含 EJB、Servlet、JSP 等规范。

J2ME (Java 2 Micro Edition)：面向移动设备（如功能手机）和嵌入式系统。

🏛️ 统治：企业级开发的霸主 (2000-2009)

进入 21 世纪，随着企业信息化的深入，Java 迅速确立了在企业后端开发的统治地位。

企业首选：尽管早期的 EJB 因配置繁琐而备受诟病，但 Java 凭借其稳定性、安全性和庞大的类库，成为了银行、电信和电商等核心系统的首选语言。

语法革命 (Java 5)： 2004 年发布的 JDK 5.0 是一次巨大的升级，引入了泛型、注解、枚举、自动装箱等特性，极大地提升了代码的简洁性和类型安全。

开源化 (Java 6)： 2006 年，Sun 公司宣布将 Java 技术作为免费软件对外发布，此举极大地推动了 Java 社区的繁荣。

巨头更迭 (2009)：甲骨文公司（Oracle）宣布收购 Sun 公司，Java 的归属权随之转入 Oracle 麾下。

🏎️ 进化：云原生时代的重生 (2010-至今)

在 Oracle 的推动下，Java 进入了一个快速、有序的现代化演进阶段。

里程碑式的 Java 8： 2014 年发布的 Java 8 至今仍是影响最深远的版本之一。它引入的 Lambda 表达式和 Stream API 让 Java 拥有了函数式编程能力，彻底改变了开发者的编码方式15。

模块化与新节奏 (Java 9)： 2017 年发布的 Java 9 引入了模块化系统（Project Jigsaw），并开启了“每6个月发布一个新版本，每2年发布一个长期支持版本（LTS）”的新节奏25。

拥抱云原生 (Java 21)： 2023 年发布的 JDK 21 标志着 Java 迈入了协程时代。核心特性虚拟线程（Virtual Threads）让开发者能够轻松创建百万级线程，极大地提升了高并发场景下的性能，为云原生应用开发注入了强大动力5。

Java 特点

⭐⭐ 核心优势

跨平台性 (Write Once, Run Anywhere)
这是 Java 最显著的特征。Java 代码在编译后不会生成特定操作系统的机器码，而是生成一种中间代码——字节码。这些字节码可以在任何安装了 Java 虚拟机 的硬件设备上运行。JVM 负责将字节码解释或编译成对应平台的机器码，从而实现了“一次编写，到处运行”的愿景，极大地提升了软件的可移植性。

面向对象 (OOP)
Java 是一门纯粹的面向对象编程语言。它完全基于“类”和“对象”的概念来组织代码，并支持封装、继承、多态等核心特性。这种编程范式使得代码更易于理解、复用和维护，特别适合开发大型复杂系统。

简单易学
Java 的语法设计去除了 C++ 中复杂且容易出错的特性，例如指针、多重继承和 goto 语句。同时，它采用了自动垃圾回收机制来管理内存，减轻了程序员的负担。这使得 Java 语言相对简洁，对于初学者来说非常友好。

⭐⭐ 稳健与安全

健壮性： Java 通过多种机制来保证程序的稳定运行：

强类型检查： 在编译和运行时都会进行严格的类型检查，提前暴露错误。

异常处理： 提供了完善的 try-catch-finally 机制来捕获和处理运行时错误，防止程序意外崩溃。

自动内存管理： 通过垃圾回收器自动回收不再使用的对象，有效避免了内存泄漏和悬空指针等问题。

安全性： Java 被设计用于网络和分布式环境，其安全性是内置的：

沙箱机制： JVM 为代码提供了一个受限的运行环境，限制其对本地系统资源（如文件、网络）的访问权限，防止恶意代码破坏系统。

字节码验证： 在加载类文件时，会进行严格的校验，确保代码不会执行非法操作。

⭐⭐ 高性能与并发

高性能
虽然早期 Java 因解释执行而性能受限，但现代 JVM 引入了 即时编译 技术。JIT 会将频繁执行的“热点代码”编译成本地机器码，使其运行性能接近 C/C++ 等编译型语言。

多线程支持
Java 在语言层面原生支持多线程编程。开发者可以方便地创建和管理多个线程，以实现并发执行任务。这对于开发高并发的服务器端应用和响应迅速的图形界面程序至关重要。

⭐⭐ 生态与扩展

分布式
Java 从诞生之初就具备网络基因，内置了丰富的网络库（如 java.net 和 java.rmi），使得开发分布式应用（如 Web 服务、远程调用）变得非常简单。

动态性
Java 能够在运行时动态地加载类、获取类信息并调用方法，这一特性主要通过反射机制实现。它是许多框架（如 Spring）实现依赖注入、面向切面编程等功能的基础，极大地增强了程序的灵活性。

Java 运行机制

Java 的运行机制是其能够实现“一次编写，到处运行”（WORA）的核心。它并非直接由操作系统执行，而是依赖于一个名为 Java 虚拟机 的中间层。

简单来说，Java 的运行机制可以分为三个核心阶段：编译、加载和执行。

⭐⭐ 核心组件：JDK、JRE 与 JVM

JDK (Java Development Kit)： 是 Java 的开发工具包，包含了编译器 (javac)、调试器等开发工具。开发者使用 JDK 将源代码编译成字节码。
JRE (Java Runtime Environment)： 是 Java 的运行时环境，包含了 JVM 和核心类库。普通用户只需安装 JRE 即可运行 Java 程序。
JVM (Java Virtual Machine)： 是 Java 虚拟机，是整个运行机制的核心。它是一个虚拟的计算机，负责加载字节码，并将其转换为特定平台的机器码来执行。

⭐⭐ 阶段一：编译（从源码到字节码）

这是 Java 程序运行的第一步，发生在开发阶段。

输入： 开发者编写的 .java 源代码文件。

工具： 使用 JDK 中的 javac 编译器。

过程： javac 编译器对源代码进行语法分析、语义分析和字节码生成。

输出： 生成与平台无关的 .class 字节码文件。此时的字节码并不是任何特定硬件的机器码，而是一种 JVM 能够理解的中间指令集。

⭐⭐ 阶段二：加载（类加载器的职责）

当你在命令行执行 java HelloWorld 时，JVM 启动并进入类加载阶段。

加载： 类加载器负责从文件系统或网络中找到 HelloWorld.class 文件，并将其二进制字节流读入内存。

链接：

验证： 确保字节码是合法且安全的，符合 JVM 规范，防止恶意代码破坏系统。

准备： 为类的静态变量分配内存，并设置其初始默认值（如 0、null）。

解析： 将常量池内的符号引用（如类名、方法名）替换为直接引用（内存地址）。

初始化： 执行类构造器 <clinit>() 方法，为类的静态变量赋予代码中指定的初始值，并执行静态代码块。

⭐⭐ 阶段三：执行（执行引擎的魔法）

类加载完成后，JVM 的执行引擎开始接管，执行 main 方法中的字节码。现代 JVM 采用了一种混合模式来平衡启动速度和运行效率。

混合执行模式

解释执行 (Interpreter)

方式： 像同声传译一样，逐条读取字节码，将其翻译成当前平台的机器码并执行。

优点： 启动速度快，无需等待编译。

缺点： 运行效率较低，因为同一段代码每次执行都需要翻译。

即时编译 (JIT - Just-In-Time Compiler)

方式： JVM 会监控程序运行，当发现某个方法或代码块被频繁调用（称为“热点代码”）时，JIT 编译器会将其整个编译成本地机器码，并缓存起来。

优点： 后续调用该热点代码时，直接执行高效的机器码，运行速度极快，接近 C/C++。

缺点： 编译过程会消耗 CPU 和内存资源，且首次执行时有延迟。

总结： Java 程序启动时，解释器优先执行，保证快速响应；在运行过程中，JIT 编译器不断优化热点代码，提升系统吞吐量。这种“解释器与编译器并存”的策略，是 Java 性能卓越的关键。

⭐⭐ 内存管理：自动垃圾回收

在整个执行过程中，JVM 的运行时数据区负责管理内存。其中最核心的机制之一是垃圾回收。JVM 会自动追踪对象的引用情况，当发现某些对象不再被任何引用指向时，垃圾回收器会自动回收其占用的内存，极大地减轻了开发者手动管理内存的负担和出错风险。

安装运行

安装配置

JAVA 8 安装详解：https://blog.csdn.net/suzengxin/article/details/115401549

运行程序

⭐⭐ 第一步：开发程序

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

⭐⭐ 第二步：编译程序

1	javac Hello.java

⭐⭐ 第三步：运行程序

1	java Hello

转义字符

转义字符	描述
`\t`	制表符
`\n`	换行符
`\r`	回车
`\"`	双引号
`\'`	单引号
`\\`	反斜杠

代码注释

单行注释

// 单行注释

多行注释

1
2
3

/*
    多行注释
*/

文档注释

/**
 * @author szxck
 * @version 1.0
 */

⭐⭐ 生成 Java 文档

1	javadoc -d D:\\javadoc -author -version Hello.java

⭐⭐ 标准标签

标签名	用途说明	适用对象
`@author`	指明类或接口的作者	包、类、接口
`@version`	指定类或接口的版本信息	包、类、接口
`@param`	描述方法或构造函数的参数名称和含义	方法、构造函数
`@return`	描述方法的返回值	方法
`@throws`	描述方法可能抛出的异常	方法、构造函数
`@exception`	与 `@throws` 功能相同，用于描述异常。	方法、构造函数
`@see`	提供指向其他类、方法或外部资源的“参见”链接	全局(类、方法、包等)
`@since`	指明该特性从哪个版本（或日期）开始引入	全局
`@deprecated`	标记该 API 已过时，不建议使用	全局
`@serial`	用于序列化字段的文档说明	字段 (Field)
`@serialData`	描述通过 `writeObject` 或 `writeExternal` 写入的数据	方法 (通常为 writeObject)
`@serialField`	描述 `ObjectStreamField` 组件	字段

⭐⭐ 内联标签

这些标签用 {} 包裹，可以嵌入到注释的任意文本中，用于内联显示特殊内容或链接。

标签名	用途说明
`{@link}`	内联插入一个指向其他类或成员的链接（类似于 `@see` 但可嵌入文本）
`{@linkplain}`	与 `{@link}` 类似，但链接文本以纯文本（非代码样式）显示
`{@value}`	显示静态字段（常量）的值
`{@code}`	将文本显示为代码样式（通常用于表示关键字或代码片段），并避免被解析为 HTML
`{@literal}`	显示文本而不进行任何转义（显示原样文本），不解析为 HTML 或其他标签
`{@inheritDoc}`	从直接父类或实现的接口中继承文档注释
`{@docRoot}`	指明生成的文档根目录的路径（用于构建相对路径链接）

⭐⭐ 不常用标签

标签名	用途说明
`@category`	(非标准，某些 Doclet 可能支持) 用于分类
`@index`	(Java 8+) 强制将标识符添加到索引中
`@apiNote`	(Java 8+) 提供关于 API 使用的额外说明（非规范性）
`@implSpec`	(Java 8+) 提供实现者需要遵守的规范说明
`@implNote`	(Java 8+) 提供关于实现的非规范性说明

数据类型

在 Java 中，数据类型、变量、常量是编程的三大基石，它们共同决定了程序如何存储和处理数据。简单来说，数据类型是“容器的规格”，变量是“可变的容器”，而常量是“不可变的容器”。

数据类型：用于定义变量或常量可以存储的数据种类以及占用内存的大小。Java 是强类型语言，每一个变量都必须先声明类型才能使用。
变量：变量是程序运行过程中值可以发生改变的数据存储单元。你可以把它想象成一个贴了标签的盒子，盒子的大小由数据类型决定，里面的内容（值）可以根据需要更换。
常量：常量是程序运行过程中值不能发生改变的数据。使用 final 关键字修饰的变量。一旦赋值，就不能再修改。

类型描述

类型	关键字	字节/位数	取值范围	默认值	描述
整数型	`byte`	1字节 / 8位	-128 到 127	0	最小的整数类型，常用于节省内存的场景（如处理二进制数据）
	`short`	2字节 / 16位	-32768 到 32767	0	较少使用，通常用于特定的内存优化场景
	`int`	4字节 / 32位	-2³¹ 到 2³¹-1	0	最常用的整数类型，也是整数字面量的默认类型
	`long`	8字节 / 64位	-2⁶³ 到 2⁶³-1	0L	用于存储非常大的数值（如时间戳、文件大小），定义时需在数值后加 L
浮点型	`float`	4字节 / 32位	约 ±3.4028235E+38	0.0F	单精度浮点数，定义时需在数值后加 F
浮点型	`double`	8字节 / 64位	约 ±1.7976931348623157E+308	0.0D	双精度浮点数，精度更高，是浮点数字面量的默认类型
字符型	`char`	2字节 (16位)	0 到 65535 (\u0000 到 \uffff)	\u0000	使用单引号 '' 表示，例如：'中'、'国'、'A'
布尔型	`boolean`	1 位 \| 1 字节	true (真) 或 false (假)	false	常用于条件判断和循环控制

类型转换

⭐⭐ 自动类型转换（隐式转换）

这是 Java 编译器自动完成的转换，也叫拓宽转换（Widening Conversion）。当你把一个“小杯子”里的水倒进一个“大杯子”时，不会溢出，因此是安全的。

转换规则： 容量小的数据类型可以直接赋值给容量大的数据类型。

byte → short → int → long → float → double

char → int → long → float → double

// 1. 赋值时的自动转换
int a = 100;
long b = a;        // int -> long，自动转换
double c = a;      // int -> double，自动转换

// 2. char的特殊性
char ch = 'A';     // 'A'的Unicode值是65
int ascii = ch;    // char -> int，自动转换，结果为65

// 3. 运算时的自动提升
byte x = 10;
short y = 20;
// byte + short -> 计算前先全部转为 int，所以结果必须用 int 或更大的类型接收
int result = x + y; 

float f = 1.5f;
double d = 2.5;
// float + double -> 提升为 double
double sum = f + d;

⭐⭐ 强制类型转换（显式转换）

这是程序员明确指示编译器进行的转换，也叫窄化转换（Narrowing Conversion）。当你把一个“大杯子”里的水倒进一个“小杯子”时，可能会溢出或洒掉（数据丢失），因此需要你“手动”负责。

精度丢失： 浮点数转整数时，直接截断小数部分（不是四舍五入）。

数据溢出： 数值超过了目标类型的取值范围，会发生“截断”或“溢出”。


double pi = 3.1415926;
int intPi = (int) pi;   // 强制转换，结果为 3（直接舍弃小数）

long bigNum = 3000000000L;
int num = (int) bigNum; // 强制转换，由于long范围大于int，可能导致溢出（结果可能为负数）

二进制

计算机中的数据存储： 学习笔记

各个进制之间相互转换： 学习笔记

原码、反码和补码： 学习笔记

运算符

Java运算符是用于对变量和值进行操作的符号。

算术运算符

算术运算符用于执行基本的数学运算。

运算符	名称	示例	描述
`+`	加法	`a + b`	相加两个操作数
`-`	减法	`a - b`	从第一个操作数中减去第二个操作数
`*`	乘法	`a * b`	相乘两个操作数
`/`	除法	`a / b`	分子除以分母
`%`	取模	`++a` 或 `a++`	返回除法的余数
`++`	自增	`++a` 或 `a++`	操作数的值增加1
`--`	自减	`--a` 或 `a--`	操作数的值减少1

⭐⭐ 示例代码

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println("a + b = " + (a + b)); // 13
        System.out.println("a - b = " + (a - b)); // 7
        System.out.println("a * b = " + (a * b)); // 30
        System.out.println("a / b = " + (a / b)); // 3 (整数除法)
        System.out.println("a % b = " + (a % b)); // 1
        
        int c = 5;
        System.out.println("c++ = " + (c++)); // 5 (先使用后自增)
        System.out.println("++c = " + (++c)); // 7 (先自增后使用)
    }
}

关系运算符

关系运算符用于比较两个值，返回布尔值（true或false）。

运算符	名称	示例	描述
`==`	等于	`a == b`	检查两个操作数的值是否相等
`!=`	不等于	`a != b`	检查两个操作数的值是否不相等
`>`	大于	`a > b`	检查左操作数的值是否大于右操作数的值
`<`	小于	`a < b`	检查左操作数的值是否小于右操作数的值
`>=`	大于等于	`a >= b`	检查左操作数的值是否大于或等于右操作数的值
`<=`	小于等于	`a <= b`	检查左操作数的值是否小于或等于右操作数的值

⭐⭐ 示例代码

public class RelationalOperators {
    public static void main(String[] args) {
        int a = 10, b = 20;
        System.out.println("a == b: " + (a == b)); // false
        System.out.println("a != b: " + (a != b)); // true
        System.out.println("a > b: " + (a > b));   // false
        System.out.println("a < b: " + (a < b));   // true
        System.out.println("a >= b: " + (a >= b)); // false
        System.out.println("a <= b: " + (a <= b)); // true
    }
}

逻辑运算符

逻辑运算符用于组合多个布尔表达式。

运算符	名称	示例	描述
`&&`	短路与	`a && b`	如果两个操作数都为真，则返回结果为真
`\|\|`	短路或	`a \|\| b`	如果两个操作数有一个为真，则返回结果为真
`&`	逻辑与	`a & b`	如果两个操作数都为真，则返回结果为真
`\|`	逻辑或	`a \| b`	如果两个操作数有一个为真，则返回结果为真
`^`	逻辑异或	`a ^ b`	两个操作数一个为真一个为假，则返回结果为真
`!`	非（取反）	`!a`	如果操作数为真，则返回结果为假（反转逻辑状态）

⭐⭐ 示例代码

// &&：如果第一个条件为false，不会检查第二个条件
// &： 如果第一个条件为false，还会继续检查第二个条件
// ||：如果第一个条件为true，不会检查第二个条件
// |： 如果第一个条件为true，还会继续检查第二个条件
public class LogicalOperators {
    public static void main(String[] args) {
        boolean x = true, y = false;
        
        System.out.println("x && y: " + (x && y)); // false
        System.out.println("x || y: " + (x || y)); // true
        System.out.println("!x: " + (!x));         // false
        
        // 短路示例
        int a = 5, b = 10;
        if (a > 10 && b++ > 5) {
            System.out.println("条件成立");
        }
        System.out.println("b = " + b); // b仍然是10，因为短路
    }
}

位运算符

位运算符对整数类型的位进行操作。

运算符	名称	示例	描述
`&`	按位与	`a & b`	只有当两个对应的二进制位都为 1 时，结果的该位才为 1，否则为 0
`\|`	按位或	`a \| b`	只要有一个对应的二进制位为 1，结果位就为 1，否则为 0
`^`	按位异或	`a ^ b`	当两个对应的二进制位不相同时，结果位为 1；否则（相同时）为 0
`~`	按位取反	`~a`	当原二进制位为 0 时，结果位为 1；当原位为 1 时，结果位为 0
`<<`	左移	`a << 1`	将a的二进制位向左移动1位，右边空出的位补入 0 左移几位，相当于乘以 2 的几次方
`>>`	右移	`a >> 1`	将a的二进制位向右移动1位，左边空出的位补入符号位右移几位，相当于除以 2 的几次方
`>>>`	无符号右移	`a >>> 1`	将a的二进制位向右移动1位，左边空出的位补入 0 处理的是二进制位的移动，而不是数学计算

⭐⭐ 示例代码

// 在 Java 中，所有整数在计算机底层都以 二进制补码 的形式存储。
// 对于正数来说，其原码、反码和补码是相同的。
// 对于负数来说，原码、反码和补码计算遵循一套固定的规则
//     反码 = 原码的符号位不变，其他位按位取反
//     补码 = 反码 + 1
public class BitwiseOperators {
    public static void main(String[] args) {
        int a = 6;  // 二进制: 0000 0000 0000 0000 0000 0000 0000 0110
        int b = 3;  // 二进制: 0000 0000 0000 0000 0000 0000 0000 0011 
        System.out.println("a & b = " + (a & b));   // 2 (0010)
        System.out.println("a | b = " + (a | b));   // 7 (0111)
        System.out.println("a ^ b = " + (a ^ b));   // 5 (0101)
        // a = 6 因为是正数，所以 6 补码跟原码一致
        // 补码   0000 0000 0000 0000 0000 0000 0000 0110
        // 取反   1111 1111 1111 1111 1111 1111 1111 1001 (按位取反，符号位是1，所以是负数)
        // 转反码 1111 1111 1111 1111 1111 1111 1111 1000 (负数反码 = 补码 - 1)
        // 转原码 1000 0000 0000 0000 0000 0000 0000 0111 (符号位不变，数值位取反)
        System.out.println("~a = " + (~a));         // -7 (转十进制)
        System.out.println("a << 1 = " + (a << 1)); // 12 (1100) > 6 * 2的1次方
        System.out.println("a >> 1 = " + (a >> 1)); // 3  (0011) > 6 / 2的1次方
    }
}

赋值运算符

赋值运算符用于给变量赋值。

运算符	示例	等价于
`=`	`a = 5`	简单赋值
`+=`	`a += 5`	`a = a + 5`
`-=`	`a -= 5`	`a = a - 5`
`*=`	`a *= 5`	`a = a * 5`
`/=`	`a /= 5`	`a = a / 5`
`%=`	`a %= 5`	`a = a % 5`
`&=`	`a &= 5`	`a = a & 5`
`\|=`	`a \|= 5`	`a = a \| 5`
`^=`	`a ^= 5`	`a = a ^ 5`
`<<=`	`a <<= 5`	`a = a << 5`
`>>=`	`a >>= 5`	`a = a >> 5`
`>>>=`	`a >>>= 5`	`a = a >>> 5`

⭐⭐ 示例代码

public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        
        a += 5;  // a = a + 5
        System.out.println("a += 5: " + a); // 15
        
        a -= 3;  // a = a - 3
        System.out.println("a -= 3: " + a); // 12
        
        a *= 2;  // a = a * 2
        System.out.println("a *= 2: " + a); // 24
    }
}

三元运算符

条件运算符是Java中唯一的三元运算符。

语法： 条件表达式 ? 表达式1 : 表达式2，条件表达式为真，返回表达式1，为假返回表达式2。

⭐⭐ 示例代码

public class TernaryOperator {
    public static void main(String[] args) {
        int a = 10, b = 20;
        
        // 使用三元运算符找出最大值
        int max = (a > b) ? a : b;
        System.out.println("最大值: " + max); // 20
        
        // 判断奇偶数
        String result = (a % 2 == 0) ? "偶数" : "奇数";
        System.out.println(a + "是" + result); // 10是偶数
    }
}

特殊运算符

// 字符串连接运算符 (+)
// 当 `+` 运算符用于字符串时，它会将其他类型的操作数转换为字符串并连接。
String str = "Hello" + " " + "World"; // "Hello World"
String result = "The answer is " + 42; // "The answer is 42"


// instanceof 运算符
// 用于检查对象是否是指定类型的实例。
String str = "Hello";
System.out.println("str instanceof String: " + (str instanceof String)); // true
System.out.println("str instanceof Integer: " + (str instanceof Integer)); // false


// 方法引用运算符 (::)
// Java 8 引入的方法引用，用于直接引用已有方法或构造器。
System.out::println; // 调用该方法 System.out.println();

运算符优先级

当表达式包含多个运算符时，Java按照优先级顺序执行。

优先级	运算符	运行顺序
1	`()` `[]` `.`	从左到右
2	`++` `--` `!` `~` `+` `-` `(type)` `new`	从右到左
3	`*` `/` `%`	从左到右
4	`+` `-`	从左到右
5	`<<` `>>` `>>>`	从左到右
6	`<` `<=` `>` `>=` `instanceof`	从左到右
7	`==` `!=`	从左到右
8	`&`	从左到右
9	`^`	从左到右
10	`\|`	从左到右
11	`&&`	从左到右
12	`\|\|`	从左到右
13	`? :`	从右到左
14	赋值运算符	从右到左

⭐⭐ 示例代码

1 2	int result = 10 + 5 * 2; // 先乘法后加法，结果为20 int result2 = (10 + 5) * 2; // 先加法后乘法，结果为30

控制结构

Java 的控制结构决定了代码的执行顺序和逻辑走向。简单来说，它让程序不再是“一条路走到黑”的顺序执行，而是具备了判断（分支）和重复（循环）的能力。

顺序结构

这是最简单的结构，程序默认从上到下逐行执行，中间没有任何判断和跳转。

// 特点：代码按照书写顺序依次运行。
// 注意：在定义变量时，必须遵循前向引用原则，即变量需要先声明再使用
public static void main(String[] args) {
    int a = 10;
    int b = a + 2;// a 变量需要先声明再使用
}

分支控制

⭐⭐ 单分支结构

    // 基本语法
    if (条件表达式) {
        // 代码块（当条件表达式为 true 时执行）
    }

    1.程序首先计算 条件表达式 的值。
    2.如果结果为 true，则执行大括号 {} 内的代码块。
    3.如果结果为 false，则跳过整个 if 结构，执行紧跟在 if 后面的下一行代码。
    4.如果代码块中只有一行语句，大括号 {} 可以省略（但强烈不建议省略，为了代码可读性和避免错误）。

public static void main(String[] args) {
    double balance = 500.0; // 账户余额
    double withdraw = 800.0; // 取款金额
    // 判断余额是否充足，余额不足：打印信息
    if (withdraw > balance) {
        System.out.println("余额不足，取款失败！");
        System.out.println("当前余额: " + balance);
    }
    // 如果余额充足，什么也不做，直接执行后续业务
}

⭐⭐ 双分支结构

    // 基本语法
    if (条件表达式) {
        // 代码块1（当条件为 true 时执行）
    } else {
        // 代码块2（当条件为 false 时执行）
    }

    1.程序首先计算 条件表达式 的值。
    2.如果结果为 true，执行 代码块1。
    3.如果结果为 false，执行 代码块2。
    4.执行完毕后，执行紧跟在 if 后面的下一行代码。

public static void main(String[] args) {
    int number = 7;
    if (number % 2 == 0) {
        System.out.println(number + " 是偶数");
    } else {
        System.out.println(number + " 是奇数");
    }
}

⭐⭐ 多分支结构

    // 基本语法
    if (条件表达式1) {
        // 代码块1
    } else if (条件表达式2) {
        // 代码块2
    } else {
        // 默认代码块（以上条件都不满足时执行）
    }

    1.自上而下依次判断条件表达式。
    2.一旦遇到某个 条件表达式 为 true，就执行对应的代码块，执行完毕后立即跳出整个结构，不再判断后续的 else if。
    3.如果所有的 if 和 else if 条件都不成立，且存在 else 分支，则执行 else 中的代码块。
    4.else 分支如果没有要处理的代码块，可以省略。

public static void main(String[] args) {
    int score = 85;
    String grade;
    if (score >= 90) {
        grade = "A (优秀)";
    } else if (score >= 80) {
        grade = "B (良好)";
    } else if (score >= 70) {
        grade = "C (中等)";
    } else if (score >= 60) {
        grade = "D (及格)";
    } else {
        grade = "E (不及格)";
    }
    System.out.println("分数: " + score + ", 等级: " + grade);
}

⭐⭐ 嵌套分支结构

    // 基本语法
    if (外层条件表达式) {
        // 外层代码块
        if (内层条件表达式) {
            // 内层代码块 A
        } else {
            // 内层代码块 B
        }
    } else {
        // 外层代码块
    }

    1.程序首先判断外层条件。只有在外层条件成立的情况下，才会去执行内部的内层条件判断。
    2.内层的 if-else 完全属于外层 if 或 else 的代码块范围。
    3.逻辑关系：通常用于表达“并且”的关系。例如：“如果是男性 并且 年龄大于 18” -> 外层判断性别，内层判断年龄。
    4.嵌套分支结构其实就是将上述的单分支、双分支或多分支结构互相“包裹”起来，形成里外两层或多层的判断逻辑。
    5.理论上 Java 支持无限层嵌套，但在实际开发中，为了代码的可读性和维护性，建议嵌套层次不要超过 3 层。

public static void main(String[] args) {
    String inputPassword = "888888";
    String realPassword = "888888";
    double balance = 1000.0;
    double withdraw = 1500.0;

    if (inputPassword.equals(realPassword)) {
        System.out.println("密码正确，正在验证金额...");
        
        // 嵌套开始：只有密码正确才需要验证金额
        if (withdraw <= balance) {
            System.out.println("取款成功，请取走现金！");
        } else {
            System.out.println("余额不足，取款失败！");
        }
        // 嵌套结束
        
    } else {
        System.out.println("密码错误，卡已锁定，请联系银行！");
    }
}

⭐⭐ 多值匹配结构

    // 基本语法
    switch (表达式) {
        case 值1:
            // 执行代码块1
            break;
        case 值2:
            // 执行代码块2
            break;
        case 值3:
        case 值4: // 多个case共用代码
            // 执行代码块3或4
            break;
        default:
            // 当所有case都不匹配时执行
    }

    1.表达式求值：switch 后面括号中的表达式只会被计算一次。
    2.顺序匹配：从上到下依次将表达式的值与 case 后面的值进行比较。一旦找到匹配的 case，程序会从该处开始执行代码。
    3.case 的值必须是字面量或 final 常量，不能是变量或表达式。
    4.break 语句用于终止 switch 结构，跳出整个代码块。
    5.穿透现象：如果省略 break，程序不会停止，而是会继续执行下一个 case 或 default 的代码，直到遇到 break 或 switch 结束。
    6.除非刻意利用穿透，否则每个 case 后都应该写 break，否则会导致逻辑错误。
    7.default 分支：当所有 case 都不匹配时执行。它是可选的，位置可以放在 switch 块的任何地方，但为了代码可读性，强烈建议放在末尾。

public static void main(String[] args) {
    int day = 3;
    switch (day) {
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        default:
            System.out.println("周末或输入错误");
    }
}

循环控制

⭐⭐ `for` 循环

    // 基本语法
    for (初始化语句; 循环条件; 迭代语句) {
        // 循环体（重复执行的代码）
    }

    1.初始化语句：最先执行，且只执行一次。通常用于定义循环变量（如 int i = 0）。
    2.循环条件：必须是一个布尔表达式。在每次循环开始前进行判断。
    3.如果结果为 true，则执行循环体。
    4.如果结果为 false，则终止循环，跳出 for 结构。
    5.循环体：条件为 true 时执行的具体代码。
    6.迭代语句：在循环体执行完毕后执行，通常用于更新循环变量（如 i++）。
    7.流程顺序：初始化 -> 判断条件 -> 执行循环体 -> 执行迭代语句 -> 再次判断条件……直到条件为 false。

public static void main(String[] args) {
    int sum = 0;
    // i 从 1 开始，只要 i <= 100 就继续循环，每次循环后 i 自增 1
    for (int i = 1; i <= 100; i++) {
        sum += i; // 累加
    }
    System.out.println("1 到 100 的和是: " + sum);
}

⭐⭐ `while` 循环

    // 基本语法
    while (循环条件) {
        // 循环体
        // 迭代语句（通常放在循环体末尾）
    }

    1.如果条件为 true，则执行循环体中的代码。
    2.如果条件为 false，则直接跳过整个 while 循环，执行循环后面的代码。
    3.注意：由于是先判断，如果一开始条件就是 false，循环体一次都不会执行。

public static void main(String[] args) {
    int sum = 0;
    int i = 1;
    // 只要 i <= 100 就继续循环
    while (i <= 100) {
        sum += i; // 累加
        i++; //i 自增 1
    }
    System.out.println("1 到 100 的和是: " + sum);
}

⭐⭐ `do-while` 循环

    // 基本语法
    do {
        // 循环体
        // 迭代语句
    } while (循环条件); // 注意这里的分号不能丢

    1.先执行：无论条件是否成立，循环体至少会执行一次。
    2.后判断：执行完循环体后，再判断 循环条件。
    3.如果条件为 true，则继续执行循环体。
    4.如果条件为 false，则终止循环。

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int secret = 8;
    int guess;
    
    do {
        System.out.print("请猜一个数字 (1-10): ");
        guess = scanner.nextInt();
        if (guess > secret) {
            System.out.println("太大了，再试一次！");
        } else if (guess < secret) {
            System.out.println("太小了，再试一次！");
        }
        // 如果猜对了，guess == secret，循环条件为 false，循环结束
    } while (guess != secret);
    
    System.out.println("恭喜你，猜对了！");
    scanner.close();
}

⭐⭐ 循环嵌套

    // 基本语法
    for (初始化语句1; 循环条件1; 迭代语句1) {
        // 外层循环体
        for (初始化语句2; 循环条件2; 迭代语句2) {
            // 内层循环体（核心逻辑通常在这里）
        }
    }

    1.循环嵌套可以是任意循环（for、while、do-while）的互相组合。
    2.最常见的是 for 循环嵌套 for 循环。

public static void main(String[] args) {
    System.out.println("九九乘法表");
    // 外层循环控制行数 (1-9行)
    for (int i = 1; i <= 9; i++) {
        // 内层循环控制列数 (每行打印的列数等于当前行数)
        for (int j = 1; j <= i; j++) {
            System.out.print(j + "*" + i + "=" + (i*j) + "\t");
        }
        System.out.println(); // 每行结束后换行
    }
}

流程控制

⭐⭐ `break` 终止循环

// 一旦执行 break，程序会立刻跳出当前所在的循环
// 循环中 break 后面的代码不会执行，循环的迭代（如 i++）也会停止。
public static void main(String[] args) {
    // 场景：寻找 1 到 10 中的第一个偶数 4
    for (int i = 1; i <= 10; i++) {
        if (i == 4) {
            System.out.println("找到数字 4，停止寻找！");
            break; // 循环直接结束，i 不会再变成 5, 6...
        }
        System.out.println("正在检查数字: " + i);
    }
    System.out.println("循环结束后的后续代码");
}

⭐⭐ `continue` 跳过本次循环

// 一旦执行 continue，程序会立刻跳过当前这一次循环中剩余未执行的代码。
// 它不会终止整个循环，而是直接去执行循环的迭代部分（如 i++）和条件判断，准备开始下一次循环。
public static void main(String[] args) {
    // 场景：打印 1 到 5，但跳过数字 3
    for (int i = 1; i <= 5; i++) {
        if (i == 3) {
            System.out.println("跳过数字 3");
            continue; // 跳过本次剩余代码（即下面的打印），直接进入下一次 i=4 的循环
        }
        System.out.println("当前数字: " + i);
    }
}

⭐⭐ `return` 结束方法

// 无论 return 写在方法的哪个角落（哪怕在最深层的循环里），一旦执行，整个方法立刻停止。
// 方法中 return 后面的所有代码都不会再执行。
public class ReturnDemo {
    
    // 有返回值的方法
    public static int findNumber() {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                System.out.println("找到目标数字 5，直接结束方法并返回结果");
                return i; // 直接跳出整个方法，循环和方法后续代码都不执行了
            }
            System.out.println("检查数字: " + i);
        }
        // 如果循环正常结束都没找到，返回 -1
        return -1;
    }

    public static void main(String[] args) {
        int result = findNumber();
        System.out.println("方法返回的结果是: " + result);
    }
}

第一阶段: 建立编程思想

Java 概述

如何快速学习Java技术、Java历史、Java特点、Sublime、Java运行机制、JDK、转义字符、Java开发规范、Java API

变量

数据类型、变量基本使用、数据类型转换

运算符

运算符介绍、算术运算符、关系运算符、逻辑运算符、赋值运算符、三元运算符、优先级、二进制、位运算符

控制结构

顺序、分支(if else switch)、循环(for , while , do while)、break、continue、return

数组、排序和查找

数组、排序、查找

面向对象编程(基础)

类与对象、成员方法、成员方法传参机制、overload、可变参数、作用域、构造器、this

面向对象编程(中级)

包、访问修饰符、封装、继承、多态、Super、overwrite、Object类详解、断点调试

第二阶段: 提升编程能力

面向对象编程(高级)

类变量和类方法、理解main方法语法、代码块、单例设计模式、final 关键字、抽象类接口、内部类

枚举和注解

自定义类实现枚举、enum关键字实现枚举、JDK内置的基本注解类型、元注解:对注解进行注解

Exception

异常的概念、异常体系图、常见的异常、异常处理、自定义异常、throw和throws的对比

常用类

包装类、String、StringBuffer、StringBuilder、Math、Date、Calendar、LocalDate…System、Arrays、Biglnteger、BigDecimal

集合

集合框架体系
Collection
- List：ArrayList、LinkedList、Vector
- Set：HashSet、LinkedHashSet、TreeSet
Map：HashMap、Hashtable、LinkedHashMap、TreeMap、Properties
Collections

泛型

泛型语法
自定义泛型：泛型类、泛型接口、泛型方法
泛型继承和通配符

线程基础

线程介绍、线程使用、线程方法、线程生命周期、Synchronized、互斥锁、死锁

IO流

文件：概念、常用操作
IO流原理及流的分类
节点流和处理流
输入流
- InputStream：FilelnputStream、BufferedInputStream、ObjectlnputStream
- Reader：FileReader、BufferedReader、InputStreamReader
输出流
- OutputStream：FileOutputStream、BufferedOutputStream、ObjectOutputStream
- Writer：FileWriter、BufferedWriter、OutputStreamWriter
Properties类

Java8新特性

Lambda、函数式接口、接口静态方法、接口默认方法、方法引用、构造器引用、stream API、并行流、串行流、Optional、新时间日期 API

Java11 新特性

代码层面新特性：JShell、类型推断、集合增强API、Stkeam 加强、新增字符串处理方法、Optional 加强、InputStream增强API、标准Java异步HTTP客户端
其他新特性：简化的编译运行、支持Unicode 10、Epsilon垃圾收集器、ZGC、JFR、支持Linux容器、支持G1上的并行完全垃圾收集、增加加密算法,代替RC4、最新HTTPS安全协议TLS 1.3、移除和废弃的内容

第三阶段: 分析需求，代码实现

网络编程

网络基础、InetAddress、Socket、TCP编程、字节流、字符流、UDP编程

反射

反射机制、Class类、类的加载、Class、Field、Method、Constructor、访问属性、访问方法

Mysql基础

MySQL安装和配置
数据库：创建、查看、删除数据库、备份恢复数据库
表：创建、删除、修改、查询
Mysql数据类型
CRUD：Insert、Update、Delete、Select
函数：、统计函数、时间日期、字符串函数、数学函数、流程控制
内连接
外连接
约束：not null、primary key、unique、foreign key、check、自增长
索引：主键索引、唯一索引(UNIQUE)、普通索引(INDEX)、全文索引
事务

JDBC和连接池

JDBC概述
JDBC快速入门
JDBC API：PreparedStatement、DriverManager、Statement、ResultSet
JDBCUtils
事务
批处理
连接池：DataSource、DBCP、C3P0、Proxool、BoneCP、Druid
Apache-DBUtils
DAO增删改查-BasicDao

正则表达式

快速入门
正则表达式基本语法
三个常用类：Pattern、Matcher、PatternSyntaxException
分组、捕获、反向引用
元字符：限定符、选择匹配符、分组组合和反向引用符、特殊字符字符、匹配符、定位符

学习资源

视频
- 韩顺平：零基础 30 天学会 Java：https://www.bilibili.com/video/BV1fh411y7R8
- 宋红康：全网最全Java零基础入门教程：https://www.bilibili.com/video/BV1Kb411W75N
- JDK8新特性详解：https://www.bilibili.com/video/BV1k64y1R7sA
- Java 核心技术卷：https://www.bilibili.com/video/BV18u411q7jv
文档
- 菜鸟教程 Java：https://www.runoob.com/java/java-tutorial.html
- 菜鸟教程 Java 8：https://www.runoob.com/java/java8-new-features.html
- 廖雪峰 Java 教程：https://www.liaoxuefeng.com/wiki/1252599548343744
- Java API 中文文档：https://www.matools.com/api/java8
书籍
- 《Head First Java》
- 《Java 8 实战》
- 《Java 从入门到精通》
- 《Java 核心技术卷 I》：https://pan.baidu.com/s/1G36MF1XrLhKMaBpNcfM61g?pwd=ep11
工具
- 在线编写运行：https://c.runoob.com/compile/10/
游戏
- Codegym：https://codegym.cc/zh
练手项目
- 牛客题库：https://www.nowcoder.com/intelligentTest
- Java 实现简单计算器：https://www.lanqiao.cn/courses/185
- Eclipse 实现 Java 编辑器：https://www.lanqiao.cn/courses/287
- 一本糊涂账：https://how2j.cn/module/104.html
- Java 五子棋：https://blog.csdn.net/cnlht/article/details/8176130
- Java 中国象棋：https://blog.csdn.net/cnlht/article/details/8205733
- JAVA GUI 图书馆管理系统：https://github.com/uboger/LibraryManager
- JAVA 坦克大战小游戏：https://github.com/wangzhengyi/TankWar
- Swing 编写的俄罗斯方块：https://github.com/HelloClyde/Tetris-Swing
- 小小记账本：https://github.com/xenv/SmallAccount

Java

Java 基础

概述

Java 用途

Java 历史

🌱 起源：从“Oak”到“Java” (1991-1994)

🚀 爆发：互联网时代的宠儿 (1995-1999)

🏛️ 统治：企业级开发的霸主 (2000-2009)

🏎️ 进化：云原生时代的重生 (2010-至今)

Java 特点

⭐⭐ 核心优势

⭐⭐ 稳健与安全

⭐⭐ 高性能与并发

⭐⭐ 生态与扩展

Java 运行机制

⭐⭐ 核心组件：JDK、JRE 与 JVM

⭐⭐ 阶段一：编译（从源码到字节码）

⭐⭐ 阶段二：加载（类加载器的职责）

⭐⭐ 阶段三：执行（执行引擎的魔法）

⭐⭐ 内存管理：自动垃圾回收

安装运行

安装配置

运行程序

⭐⭐ 第一步：开发程序

⭐⭐ 第二步：编译程序

⭐⭐ 第三步：运行程序

转义字符

代码注释

单行注释

多行注释

文档注释

⭐⭐ 生成 Java 文档

⭐⭐ 标准标签

⭐⭐ 内联标签

⭐⭐ 不常用标签

数据类型

类型描述

类型转换

⭐⭐ 自动类型转换（隐式转换）

⭐⭐ 强制类型转换（显式转换）

二进制

运算符

算术运算符

⭐⭐ 示例代码

关系运算符

⭐⭐ 示例代码

逻辑运算符

⭐⭐ 示例代码

位运算符

⭐⭐ 示例代码

赋值运算符

⭐⭐ 示例代码

三元运算符

⭐⭐ 示例代码

特殊运算符

运算符优先级

⭐⭐ 示例代码

控制结构

顺序结构

分支控制

⭐⭐ 单分支结构

⭐⭐ 双分支结构

⭐⭐ 多分支结构

⭐⭐ 嵌套分支结构

⭐⭐ 多值匹配结构

循环控制

⭐⭐ for 循环

⭐⭐ while 循环

⭐⭐ do-while 循环

⭐⭐ 循环嵌套

流程控制

⭐⭐ break 终止循环

⭐⭐ continue 跳过本次循环

⭐⭐ return 结束方法

第一阶段: 建立编程思想

Java 概述

变量

运算符

控制结构

数组、排序和查找

⭐⭐ `for` 循环

⭐⭐ `while` 循环

⭐⭐ `do-while` 循环

⭐⭐ `break` 终止循环

⭐⭐ `continue` 跳过本次循环

⭐⭐ `return` 结束方法