〈java程序基础〉——构建坚实技术根基的起点
在当今软件开发领域,Java程序基础不仅是程序员入门的必经之路,更是构建企业级应用系统的核心支柱。从移动终端到云端服务器,从嵌入式设备到大型分布式系统,Java语言凭借其“一次编写,到处运行”的跨平台特性、强大的生态系统和活跃的社区支持,持续占据编程语言排行榜前列。对于初学者而言,掌握扎实的java程序基础意味着拥有打开现代软件工程世界的大门钥匙;对于资深开发者,重温基础细节往往能发现性能优化与架构设计的关键突破口。
java程序基础涵盖的内容远不止简单的语法罗列。它是一套完整的知识体系,从变量定义、运算符、流程控制等最基础的编程元素开始,逐步深入到类与对象、继承与多态、接口与抽象类等面向对象核心概念;从数组、字符串等基础数据结构,到集合框架、泛型、注解等高级特性;从异常处理机制到输入输出流操作;从单线程执行到并发编程模型;从字节码结构到内存模型;从传统IO到NIO异步非阻塞模型;从运行时动态加载到反射机制;从简单工厂模式到复杂架构设计模式……所有这些内容共同构成了一个系统化、层次清晰的知识网络。
学习java程序基础不是为了死记硬背语法细节,而是要理解其背后的设计哲学与工程思想。例如,Java中所有的类都隐式继承自Object类这一设计,体现了面向对象语言对“万物皆对象”理念的贯彻;异常处理机制中受检异常与非受检异常的区分,反映了对错误处理责任的明确划分;集合框架中不同集合类型的性能特征与适用场景,体现了对数据结构与算法在实际应用中的权衡考量。这些深层次的设计思想,才是支撑Java语言长期生命力的关键所在。
值得注意的是,java程序基础的学习应当与工程实践紧密结合。脱离实际应用场景的语法学习容易陷入“纸上谈兵”的困境。建议学习者在掌握每个知识点后,立即通过小型项目进行实践验证。例如,在学习集合框架时,可以构建一个简单的图书管理系统,用ArrayList存储图书信息,用HashMap实现按ISBN快速检索;在学习多线程时,可以实现一个简单的下载器,主线程负责界面交互,工作线程负责文件下载。这种“学习—实践—反思”的闭环过程,能够显著提升学习效果,将抽象的知识转化为实际的开发能力。
此外,随着Java生态的持续演进,新版本不断引入现代化特性(如Pattern Matching、Records、Virtual Threads等),但这些新特性都是建立在java程序基础之上的增强与补充。没有扎实的基础,就难以理解新特性的设计动机与使用场景。因此,本页面将聚焦于java程序基础的核心内容,为后续学习高级特性打下坚实根基。
⚡ Java语言核心语法体系
语法是编程语言的“骨架”,决定了程序员如何与计算机进行沟通。Java语言的语法体系严格遵循面向对象原则,同时兼顾可读性与安全性。理解其核心语法结构是编写高质量Java代码的前提。
1. 数据类型与变量
Java提供两种数据类型:基本类型(primitive types)与引用类型(reference types)。基本类型包括8种:byte、short、int、long、float、double、char、boolean。引用类型包括类(class)、接口(interface)、数组(array)等。这种区分不仅影响内存布局(基本类型存储在栈上,引用类型对象存储在堆上),也影响操作语义(基本类型是值传递,引用类型传递的是引用值)。
例如:
int count = 100; // 栈上分配,值直接存储
String name = "Java"; // 堆上分配对象,栈上存储引用地址
int[] arr = new int[5]; // 数组是引用类型,arr存储数组对象的引用
2. 控制流程
Java支持三种基本控制结构:顺序结构、选择结构(if-else、switch)、循环结构(for、while、do-while)。其中switch语句在Java 7中开始支持String类型,Java 12引入了switch表达式(使用yield返回值),极大提升了代码简洁性与表达力。
注意:使用switch处理枚举或字符串时,编译器会生成哈希表优化查找效率,但需确保case值唯一且不为null,否则会抛出NullPointerException。
3. 方法定义与重载
方法是Java程序的基本单元,遵循“方法签名唯一”原则(方法名+参数类型序列)。重载(overloading)允许同一方法名处理不同参数类型或数量的调用,但不能仅通过返回类型区分重载方法。编译器在编译期根据调用时的参数类型与数量绑定具体方法实现,属于静态多态。
示例:
public int add(int a, int b) { return a + b; }
public double add(double a, double b) { return a + b; }
public int add(int a, int b, int c) { return a + b + c; }
4. 数组与字符串
数组是固定长度的同构数据结构,支持一维与多维(本质是数组的数组)。字符串是不可变的引用类型(String类),每次修改都会创建新对象。为提高字符串拼接效率,应使用StringBuilder(单线程)或StringBuffer(多线程)。
重要提示:字符串常量池(String Pool)是JVM为优化内存使用的机制,相同字面量的字符串在池中仅存储一份。例如:
String s1 = "Java";
String s2 = "Java";
String s3 = new String("Java");
System.out.println(s1 == s2); // true(引用同一池对象)
System.out.println(s1 == s3); // false(s3是新对象)
⚙️ 面向对象编程核心思想
面向对象编程(OOP)是Java语言的灵魂。其三大特性:封装、继承、多态,共同构成了现代软件工程的基石。
1. 封装(Encapsulation)
封装通过访问修饰符(public、protected、default、private)控制类成员的可见性,隐藏实现细节,仅暴露必要接口。私有字段配合公有getter/setter方法是标准做法。结合final关键字可创建不可变类(如String、Integer),提升线程安全性与代码健壮性。
最佳实践:字段设为private,通过方法提供受控访问;在setter中加入参数校验逻辑;使用Builder模式构造复杂对象。
2. 继承(Inheritance)
Java仅支持单继承(一个类只能直接继承一个父类),但通过接口实现多继承效果。继承体现“is-a”关系,子类继承父类的非私有成员。注意:构造方法不能被继承,但子类构造器会隐式调用父类无参构造器(super()),若父类无无参构造器则需显式调用。
示例:
class Animal {
protected String name;
public Animal(String name) { this.name = name; }
public void eat() { System.out.println(name + "吃东西"); }
}
class Dog extends Animal {
public Dog(String name) { super(name); }
@Override public void eat() { System.out.println(name + "啃骨头"); }
}
3. 多态(Polymorphism)
多态允许父类引用指向子类对象,运行时动态绑定具体方法实现。实现条件:继承关系、方法重写、父类引用指向子类对象。多态是实现“开闭原则”(对扩展开放,对修改关闭)的关键机制。
典型应用:策略模式、工厂模式、依赖注入。例如Spring框架中,Bean的注入类型常为接口,实际运行时加载具体实现类,实现解耦与可配置性。
4. 抽象类与接口
抽象类(abstract class)用于定义通用模板,可包含抽象方法与具体实现;接口(interface)在Java 8后支持默认方法(default)与静态方法(static),Java 9支持私有方法(private),极大增强了接口的表达能力。
选择原则:强调“是什么”(is-a)用抽象类;强调“能做什么”(can-do)用接口。例如,List是接口(定义列表行为),AbstractList是抽象类(提供基础实现)。
〔集合框架〕——高效数据存储与操作的核心
Java集合框架(Collections Framework)提供了统一的接口与高效实现,是开发中使用最频繁的组件之一。理解其架构与性能特征至关重要。
1. 核心接口体系
Collection接口有两个主要子接口:List(有序可重复)、Set(无序不重复)、Queue(队列)。Map(键值对)独立于Collection体系,但常与集合操作配合使用。
常见实现类对比:
| 类型 | 实现类 | 线程安全 | 性能特点 | 适用场景 |
|---|---|---|---|---|
| List | ArrayList | 否 | 随机访问快O(1),插入删除慢O(n) | 频繁读取,较少修改 |
| LinkedList | 否 | 插入删除快O(1),随机访问慢O(n) | 频繁增删,顺序访问 | |
| Vector | 是 | 同步开销大,已过时 | 旧系统兼容 | |
| Set | HashSet | 否 | 基于HashMap,O(1)增删查 | 去重,无序 |
| TreeSet | 否 | 基于TreeMap,O(log n),有序 | 需要排序 | |
| Map | HashMap | 否 | O(1)操作,允许null键值 | 通用键值存储 |
| TreeMap | 否 | O(log n),有序键 | 需要排序键 | |
| ConcurrentHashMap | 是 | 分段锁/ CAS,高并发 | 高并发场景 |
2. 泛型(Generics)
泛型通过类型参数实现编译期类型安全检查,避免运行时ClassCastException。编译后会进行类型擦除(type erasure),泛型信息仅存在于源码阶段。
通配符使用规则:
- ? extends T:上界通配符,只能读(生产者),实际类型是T的子类
- ? super T:下界通配符,只能写(消费者),实际类型是T的父类
- ?:无界通配符,只读Object方法
示例:编写通用工具方法处理数字列表
public static double sum(List extends Number> numbers) {
return numbers.stream().mapToDouble(Number::doubleValue).sum();
}
3. 并发集合
java.util.concurrent包提供线程安全集合:CopyOnWriteArrayList(写时复制,适合读多写少)、ConcurrentHashMap(分段锁/ CAS)、ConcurrentSkipListMap(跳表,有序并发Map)等。它们通过CAS操作、锁分段、volatile语义等技术实现高性能并发控制。
4. 集合操作新特性
Java 8引入Stream API,支持函数式操作:filter、map、reduce、collect等。Java 9添加了Immutable Collections工厂方法(List.of()、Set.of()、Map.of()),创建不可变集合更简洁。
〔异常处理与资源管理〕——构建健壮系统的保障
异常处理机制是Java安全性的核心体现。合理使用异常,可提升系统容错性与可维护性。
1. 异常体系结构
Throwable是所有异常的父类,分为Error(严重错误,如OutOfMemoryError)与Exception(可处理异常)。Exception分为受检异常(Checked Exception,如IOException)与非受检异常(Unchecked Exception,如NullPointerException)。
设计原则:
- 优先使用非受检异常处理编程错误(如参数校验失败)
- 对可恢复的外部错误(如网络超时)使用受检异常
- 避免过度使用异常:异常用于异常路径,非正常流程控制
2. try-with-resources
Java 7引入的自动资源管理(ARM)语法,确保资源在使用后自动关闭,避免资源泄漏。实现AutoCloseable接口的类可在此语法中使用。
示例:安全读取文件
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("文件读取失败: " + e.getMessage());
}
3. 自定义异常
自定义异常应继承Exception或RuntimeException,并提供详细构造器。建议包含错误码与上下文信息,便于日志记录与问题定位。
示例:
public class BusinessException extends RuntimeException {
private final String errorCode;
public BusinessException(String errorCode, String message) {
super(message);
this.errorCode = errorCode;
}
public String getErrorCode() { return errorCode; }
}
〔多线程与并发编程〕——释放硬件性能的关键
并发编程是Java的强项,其强大的并发工具包(java.util.concurrent)为开发者提供了从基础线程控制到高级并发模式的完整支持。
1. 线程基础
创建线程的两种方式:继承Thread类、实现Runnable接口(推荐)。Java 8后支持Lambda表达式简化写法:
new Thread(() -> System.out.println("Hello from thread")).start();
线程状态:NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。理解状态转换对调试并发问题至关重要。
2. 同步机制
- synchronized:内置锁,可修饰方法或代码块,自动释放锁
- ReentrantLock:可显式控制锁,支持公平锁、可中断锁、超时锁
- volatile:保证可见性,禁止指令重排序,适用于状态标记
- Atomic类(如AtomicInteger):基于CAS操作,无锁高并发计数
3. 高级并发工具
- CountDownLatch:等待多个线程完成
- CyclicBarrier:线程间屏障,等待所有线程到达
- Semaphore:信号量,控制并发访问数量
- Exchanger:线程间交换数据
- Phaser:灵活的屏障,支持动态注册线程
4. 线程池
使用Executors创建线程池,但生产环境推荐直接使用ThreadPoolExecutor,可精细控制核心线程数、最大线程数、队列容量、拒绝策略等参数。
拒绝策略:
- AbortPolicy:抛出RejectedExecutionException
- CallerRunsPolicy:由调用线程执行任务
- DiscardPolicy:直接丢弃任务
- DiscardOldestPolicy:丢弃最老任务
5. Fork/Join框架
适用于分治任务(Divide-and-Conquer),如并行计算大数组求和。通过Work-Stealing算法,空闲线程可窃取其他线程任务,提高CPU利用率。
6. 虚拟线程(Java 21+)
Project Loom引入的轻量级线程,可创建百万级线程而无需担心栈内存消耗。通过虚拟线程与平台线程映射,实现高并发I/O密集型应用的简化开发。
〔JVM原理与内存模型〕——理解程序运行的底层逻辑
深入理解JVM是成为高级Java开发者的必经之路。它帮助我们诊断性能问题、内存泄漏与GC调优。
1. JVM内存区域
- 程序计数器(PC Register):线程私有,记录当前执行字节码指令地址
- Java虚拟机栈(JVM Stack):线程私有,存储栈帧(局部变量表、操作数栈等)
- 本地方法栈(Native Method Stack):为native方法服务
- 堆(Heap):线程共享,存储对象实例,是GC主要区域
- 方法区(Method Area):存储类信息、常量、静态变量、JIT编译代码(Java 8后为元空间Metaspace)
2. 对象创建过程
1. 类加载检查(检查类是否已加载)
2. 分配内存(指针碰撞或空闲列表)
3. 初始化零值(设置默认初始值)
4. 设置对象头(标记字段、类型指针等)
5. 执行init方法(执行构造函数)
3. 内存分配与回收
- 新生代:Eden区 + 两个Survivor区(S0/S1),Minor GC频繁
- 老年代:长期存活对象进入,Major GC/Full GC
- 对象晋升阈值:默认15(可通过-XX:MaxTenuringThreshold设置)
- 动态对象年龄判定:Survivor区中相同年龄对象总大小 > 一半时,大于等于该年龄的对象直接进入老年代
4. GC算法
- 标记-清除(Mark-Sweep):标记后清除,产生碎片
- 复制(Copying):用于新生代,无碎片,但浪费空间
- 标记-整理(Mark-Compact):用于老年代,避免碎片
- 分代收集:结合新生代与老年代策略
- G1收集器:Region化堆,可预测停顿时间,支持并发标记
5. 内存模型(JMM)
定义了线程与主内存的交互规则:原子性(atomic)、可见性(volatile)、有序性(happens-before原则)。synchronized与volatile是实现线程安全的关键。
典型问题:双重检查锁定单例需加volatile防止指令重排序:
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); // volatile防止重排序
}
}
}
return instance;
}
}
〔IO与NIO〕——高效数据传输的基石
文件与网络IO操作是程序与外部世界交互的核心。从传统阻塞IO到NIO的非阻塞模型,Java持续优化数据传输效率。
1. 传统IO(java.io)
基于流(Stream)模型:InputStream/OutputStream(字节流)、Reader/Writer(字符流)。阻塞式I/O,每个连接需独立线程,高并发场景下线程开销大。
2. NIO(java.nio)
基于通道(Channel)与缓冲区(Buffer)模型,支持非阻塞模式。核心组件:
- Channel:双向(可读可写),如FileChannel、SocketChannel
- Buffer:数据容器,如ByteBuffer、CharBuffer
- Selector:多路复用器,单线程管理多个Channel
示例:非阻塞服务器端Socket
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select(); // 阻塞等待事件
Set keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isAcceptable()) { }
if (key.isReadable()) { }
}
}
3. 新IO.2(Java 7+)
- Path/Paths/Files:更现代的文件操作API
- AsynchronousFileChannel:异步文件IO
- AIO(Asynchronous I/O):操作系统级异步支持
4. 内存映射文件(MappedByteBuffer)
将文件映射到内存,避免用户空间与内核空间的数据拷贝,适合大文件读写。例如处理1GB日志文件时,速度可提升数倍。
〔反射与注解〕——动态性与元编程的利器
反射(Reflection)与注解(Annotation)是Java实现框架级功能的核心机制。
1. 反射机制
通过Class、Field、Method、Constructor等类在运行时获取类信息并操作对象。常见用途:
- 动态加载类(Class.forName())
- 调用私有方法/字段(需setAccessible(true))
- 实现通用ORM映射(如Hibernate)
- 构建依赖注入容器(如Spring)
性能注意:反射操作比直接调用慢约100倍,应缓存反射结果(如Method对象)。
2. 注解(Annotation)
元注解定义注解行为:
- @Target:注解适用位置(ElementType.METHOD, ElementType.TYPE等)
- @Retention:注解生命周期(SOURCE、CLASS、RUNTIME)
- @Documented:生成Javadoc
- @Inherited:子类继承注解
运行时注解通过反射获取,例如Spring的@Transactional注解:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Transactional {
String value() default "";
}
注解处理器(如APT)可在编译期处理注解(如Lombok、Dagger),生成额外源码或配置文件。
〔设计模式与架构思想〕——工程化开发的智慧结晶
设计模式是解决常见问题的可复用方案。掌握常用模式可提升代码质量与协作效率。
1. 创建型模式
- 单例模式:确保唯一实例(DCL+volatile)
- 工厂模式:解耦对象创建与使用
- 建造者模式:复杂对象分步构建(如StringBuilder)
- 原型模式:克隆对象(Cloneable接口)
2. 结构型模式
- 适配器模式:接口转换(如InputStreamReader)
- 装饰器模式:动态扩展功能(如BufferedInputStream)
- 代理模式:控制访问(JDK动态代理、CGLIB)
3. 行为型模式
- 观察者模式:事件订阅(java.util.Observer)
- 策略模式:算法族封装(Comparator)
- 模板方法:固定流程,子类实现细节(Servlet)
4. 实战应用
- Spring框架:大量使用工厂、代理、模板方法
- MyBatis:动态代理实现Mapper接口
- Spring Boot自动配置:基于条件注解(@Conditional)
〔开发工具链〕——提升效率的现代化武器
现代Java开发离不开强大的工具生态。掌握工具链可显著提升开发效率。
1. IDE
- IntelliJ IDEA:功能最全,智能提示强大
- Eclipse:插件丰富,社区支持好
- VS Code + Java Extension Pack:轻量级选择
2. 构建工具
- Maven:依赖管理(pom.xml)、生命周期管理
- Gradle:基于Groovy/Kotlin DSL,构建脚本更灵活
3. 版本控制
- Git:分布式版本控制系统
- GitHub/GitLab:代码托管与协作平台
4. 测试框架
- JUnit 5:单元测试框架(@Test, @BeforeEach)
- Mockito:Mock框架(@Mock, @InjectMocks)
- TestNG:更高级测试组织(并行、依赖测试)
5. 性能分析工具
- JProfiler / VisualVM:CPU/内存分析
- JMH:微基准测试框架
- Arthas:线上诊断工具(热更新、监控)
〔安全机制〕——构建可信系统的基石
安全是Java企业级应用的生命线。理解Java安全架构至关重要。
1. 安全架构
- Security Manager:细粒度权限控制(Java 17后已弃用)
- Java Cryptography Architecture (JCA):加密服务框架
- SSL/TLS支持:通过javax.net.ssl包实现HTTPS
2. 常见安全实践
- 输入验证:防止SQL注入(PreparedStatement)、XSS(HTML转义)
- 加密存储:密码使用BCrypt/Argon2哈希
- 安全随机数:SecureRandom替代Random
- 权限控制:基于角色的访问控制(RBAC)
3. 模块系统(Java 9+)
模块(module)通过module-info.java定义依赖与导出包,增强封装性与安全性。例如:
module com.example.app {
requires java.base;
exports com.example.service;
}
〔社区与学习资源〕——持续成长的伙伴
Java拥有全球最活跃的开发者社区,丰富的学习资源助您快速成长。
1. 官方资源
- Oracle Java Docs:权威API文档
- OpenJDK源码:深入理解JVM实现
- JEP(JDK Enhancement Proposals):新特性提案
2. 社区平台
- Stack Overflow:问题解答
- GitHub:开源项目与代码阅读
- Reddit (r/java):社区讨论
- JavaRanch:经典Java论坛
3. 推荐学习路径
① 掌握语法基础 → ② 实践小项目(如图书管理系统)→ ③ 阅读经典书籍(《Effective Java》)→ ④ 深入JVM与并发 → ⑤ 参与开源项目 → ⑥ 研究框架源码(如Spring)
4. 常见误区
- ❌ 只学语法不写代码 → ✅ 每天编码,从模仿到创新
- ❌ 忽略设计模式 → ✅ 理解模式思想,而非死记结构
- ❌ 过度依赖IDE自动提示 → ✅ 适当手写代码加深理解
- ❌ 不关注性能与安全 → ✅ 从一开始就养成好习惯
java程序基础语法详解
〈变量与数据类型〉
在java程序基础中,变量是存储数据的基本单元。Java变量分为:
- 成员变量:类中定义,有默认值(int默认0,boolean默认false)
- 局部变量:方法中定义,必须显式初始化
- 常量:final修饰,不可修改(如public static final int MAX = 100)
数据类型分为基本类型(8种)与引用类型(类、接口、数组)。基本类型直接存储值,占用固定内存;引用类型存储对象地址,指向堆内存中的对象。
〈运算符与表达式〉
Java运算符包括:
- 算术运算符:+、-、*、/、%、++、--
- 关系运算符:==、!=、<、>、<=、>=
- 逻辑运算符:&&(短路与)、||(短路或)、!(非)
- 位运算符:&、|、^、~、<<、>>、>>>
- 赋值运算符:=、+=、-=等
- 三元运算符:条件 ? 表达式1 : 表达式2
注意:短路与(&&)在第一个条件为false时不再计算第二个条件;短路或(||)在第一个条件为true时不再计算第二个条件。合理利用短路特性可避免空指针异常。
〈流程控制语句〉
流程控制语句决定程序执行路径:
- if-else:条件分支
- switch:多分支选择,支持byte/short/char/int/enum/String(Java 7+)
- for:循环,支持增强for(for-each)
- while/do-while:条件循环
- break/continue:跳出/继续循环
增强for循环示例:
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
System.out.println(num);
}
〈数组操作要点〉
数组是相同类型元素的有序集合。Java数组具有以下特性:
- 长度固定,创建后不可变
- 索引从0开始
- 支持多维数组(本质是数组的数组)
- 所有数组继承自Object,实现Cloneable与Serializable接口
常见操作:
- 声明:int[] arr = new int[5]; 或 int[] arr = {1,2,3};
- 访问:arr[0] = 10;
- 遍历:for循环、增强for循环、Arrays.stream(arr)
- 排序:Arrays.sort(arr)
- 复制:Arrays.copyOf(arr, newLength)
多维数组示例:
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
〈字符串处理技巧〉
String是不可变类,所有修改操作都返回新对象。为提高效率:
- 拼接:使用StringBuilder(单线程)或StringBuffer(多线程)
- 比较:使用equals()而非==(比较内容而非引用)
- 分割:split(regex)返回字符串数组
- 查找:indexOf()、contains()、startsWith()、endsWith()
- 格式化:String.format()、printf()
字符串池机制示例:
String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s1.equals(s3)); // true
〈方法定义与重载〉
方法是Java程序的基本单元,定义格式:
访问修饰符 返回类型 方法名(参数列表) {
// 方法体
return 返回值;
}
重载(Overloading)条件:
- 方法名相同
- 参数列表不同(类型、数量或顺序)
- 与返回类型无关
示例:
public int add(int a, int b) { return a + b; }
public double add(double a, double b) { return a + b; }
public int add(int a, int b, int c) { return a + b + c; }
注意:重载在编译期决定,属于静态多态;方法重写在运行期决定,属于动态多态。
面向对象编程深度解析
〈封装与访问控制〉
封装通过隐藏实现细节提升系统安全性与可维护性。Java提供四种访问修饰符:
| 修饰符 | 本类 | 同包 | 子类 | 全局 |
|---|---|---|---|---|
| private | ✓ | ✗ | ✗ | ✗ |
| default | ✓ | ✓ | ✗ | ✗ |
| protected | ✓ | ✓ | ✓ | ✗ |
| public | ✓ | ✓ | ✓ | ✓ |
最佳实践:
- 字段设为private
- 提供公有getter/setter方法(遵循JavaBean规范)
- 在setter中加入参数校验
- 使用不可变类(final字段+私有构造器)提升线程安全性
〈继承与多态〉
继承实现代码复用,多态实现运行时绑定。关键点:
- Java单继承,但支持多接口实现
- 子类继承父类非私有成员(构造方法除外)
- 重写(Override)需保持方法签名一致
- 使用@Override注解避免误写
- 向上转型:父类引用指向子类对象
示例:多态应用
class Animal {
public void sound() { System.out.println("动物叫声"); }
}
class Dog extends Animal {
@Override public void sound() { System.out.println("汪汪"); }
}
class Cat extends Animal {
@Override public void sound() { System.out.println("喵喵"); }
}
public class Main {
public static void main(String[] args) {
Animal[] animals = {new Dog(), new Cat()};
for (Animal a : animals) a.sound(); // 动态绑定
}
}
〈抽象类与模板方法模式〉
抽象类用于定义通用模板,可包含抽象方法(无实现)与具体方法。典型应用是模板方法模式:
abstract class Beverage {
final void prepareRecipe() {
boilWater();
brew();
pourInCup();
addCondiments();
}
abstract void brew();
abstract void addCondiments();
void boilWater() { System.out.println("煮水"); }
void pourInCup() { System.out.println("倒入杯中"); }
}
class Coffee extends Beverage {
void brew() { System.out.println("用滤纸冲泡咖啡"); }
void addCondiments() { System.out.println("加糖和牛奶"); }
}
注意:抽象类不能实例化,但可包含构造方法供子类调用。
〈接口与默认方法〉
接口在Java 8后支持默认方法(default)与静态方法(static),Java 9支持私有方法(private)。这极大增强了接口的表达能力。
接口特点:
- 所有方法默认public abstract
- 字段默认public static final
- 支持多实现
- 可继承多个接口
示例:接口默认方法
interface Printable {
void print();
default void log() { System.out.println("打印日志"); }
static void help() { System.out.println("使用print方法打印内容"); }
}
class Document implements Printable {
public void print() { System.out.println("打印文档"); }
}
集合框架核心知识
〈List与Set详解〉
List接口实现类:
- ArrayList:基于动态数组,随机访问快O(1),插入删除慢O(n)
- LinkedList:基于双向链表,插入删除快O(1),随机访问慢O(n)
- Vector:线程安全但性能低,已过时
Set接口实现类:
- HashSet:基于HashMap,O(1)增删查,无序
- LinkedHashSet:维护插入顺序
- TreeSet:基于TreeMap,有序,O(log n)
选择建议:
- 频繁随机访问 → ArrayList
- 频繁增删 → LinkedList
- 去重且无序 → HashSet
- 去重且有序 → TreeSet
〈Map与泛型应用〉
Map接口实现类:
- HashMap:O(1)操作,允许null键值
- LinkedHashMap:维护插入顺序
- TreeMap:有序键,O(log n)
- ConcurrentHashMap:高并发安全
泛型使用示例:
Map> map = new HashMap<>();
map.put("A", Arrays.asList(1, 2, 3));
map.put("B", Arrays.asList(4, 5));
for (Map.Entry> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
泛型通配符规则:
- ? extends T:上界通配符,只能读(生产者)
- ? super T:下界通配符,只能写(消费者)
- ?:无界通配符
〈函数式操作与Stream〉
Java 8引入Stream API,支持链式操作:
- 中间操作:filter、map、sorted、distinct
- 终止操作:collect、forEach、reduce、count
示例:筛选大于10的偶数并求和
List numbers = Arrays.asList(1, 5, 8, 12, 3, 15);
int sum = numbers.stream()
.filter(n -> n > 10)
.filter(n -> n % 2 == 0)
.mapToInt(Integer::intValue)
.sum(); // 12
〈并行流性能优化〉
并行流(parallelStream)利用Fork/Join框架实现多线程处理,适合CPU密集型任务:
long count = LongStream.rangeClosed(1, 1000000)
.parallel()
.filter(n -> isPrime(n))
.count();
注意:并行流不保证顺序,且I/O密集型任务不宜使用(线程阻塞影响吞吐量)。
多线程与并发编程
〈线程创建与状态〉
创建线程的三种方式:
- 继承Thread类
- 实现Runnable接口(推荐)
- 使用ExecutorService线程池
线程状态转换:
- NEW:刚创建
- RUNNABLE:就绪/运行中
- BLOCKED:等待锁
- WAITING:无限期等待(Object.wait())
- TIMED_WAITING:超时等待(Thread.sleep())
- TERMINATED:运行结束
〈同步机制对比〉
| 机制 | 可中断 | 公平性 | 超时 | 适用场景 |
|---|---|---|---|---|
| synchronized | ✗ | ✗ | ✗ | 简单同步 |
| ReentrantLock | ✓ | ✓ | ✓ | 复杂同步 |
| volatile | ✗ | ✗ | ✗ | 状态标记 |
| Atomic类 | ✗ | ✗ | ✗ | 高并发计数 |
ReentrantLock使用示例:
Lock lock = new ReentrantLock();
try {
lock.lock();
// 临界区代码
} finally {
lock.unlock();
}
〈线程池配置与使用〉
线程池参数详解:
- corePoolSize:核心线程数
- maximumPoolSize:最大线程数
- keepAliveTime:空闲线程存活时间
- workQueue:任务队列(ArrayBlockingQueue、LinkedBlockingQueue等)
- threadFactory:线程工厂
- rejectedExecutionHandler:拒绝策略
推荐配置(CPU密集型):
int cores = Runtime.getRuntime().availableProcessors();
ExecutorService pool = new ThreadPoolExecutor(
cores, cores * 2, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000),
new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
〈并发集合应用〉
java.util.concurrent提供线程安全集合:
- CopyOnWriteArrayList:写时复制,适合读多写少
- ConcurrentHashMap:分段锁/ CAS,高并发Map
- ConcurrentSkipListMap:有序并发Map
- BlockingQueue:阻塞队列(ArrayBlockingQueue、LinkedBlockingQueue)
示例:生产者-消费者模型
BlockingQueue queue = new ArrayBlockingQueue<>(10);
// 生产者
new Thread(() -> {
try { queue.put("Data"); } catch (InterruptedException e) {}
}).start();
// 消费者
new Thread(() -> {
try { String data = queue.take(); } catch (InterruptedException e) {}
}).start();
JVM原理与调优
〈内存区域与对象生命周期〉
JVM内存模型:
- 程序计数器:线程私有
- 虚拟机栈:栈帧存储(局部变量表、操作数栈)
- 本地方法栈:native方法服务
- 堆:对象实例存储,GC主要区域
- 方法区(元空间):类信息、常量、静态变量
对象创建过程:
- 类加载检查
- 内存分配(指针碰撞/空闲列表)
- 初始化零值
- 设置对象头
- 执行init方法
〈GC机制与调优参数〉
GC分类:
- Minor GC:新生代回收,频繁
- Major GC:老年代回收
- Full GC:全堆回收
常用JVM参数:
- -Xms/-Xmx:堆初始/最大大小
- -Xmn:新生代大小
- -XX:MetaspaceSize:元空间初始大小
- -XX:+UseG1GC:启用G1垃圾收集器
- -XX:MaxGCPauseMillis:目标最大停顿时间
G1收集器特点:
- Region化堆
- 可预测停顿时间
- 并发标记
- 混合回收
〈GC日志解读〉
GC日志示例:
[GC (Allocation Failure) [PSYoungGen: 65536K->8192K(76288K)] 65536K->8192K(251392K), 0.0123456 secs]
关键信息:
- GC类型:GC/Full GC
- 原因:Allocation Failure等
- 堆区域:新生代/老年代使用量变化
- 停顿时间
优化方向:
- Minor GC频繁 → 增大新生代
- Full GC频繁 → 检查内存泄漏
- 停顿时间长 → 调整GC算法
〈JVM诊断工具〉
常用工具:
- jps:查看Java进程
- jstack:线程堆栈
- jmap:内存映像
- jstat:GC统计
- jcmd:综合诊断命令
- VisualVM:图形化监控
- Arthas:线上诊断
示例:线程死锁检测
jstack -l 12345 | grep -i deadlock
IO与NIO详解
〈传统IO模型〉
java.io基于流模型,特点:
- 阻塞式I/O
- 每个连接需独立线程
- 高并发下线程开销大
- API相对繁琐
示例:文件读取
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
〈NIO核心组件〉
NIO(New IO)基于通道与缓冲区模型:
- Channel:双向数据通道(FileChannel、SocketChannel)
- Buffer:数据容器(ByteBuffer、CharBuffer)
- Selector:多路复用器,单线程管理多个Channel
NIO优势:
- 非阻塞模式
- 高并发支持
- 零拷贝支持(内存映射)
- 更灵活的I/O操作
示例:非阻塞服务器
Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() > 0) {
for (SelectionKey key : selector.selectedKeys()) {
if (key.isAcceptable()) { }
if (key.isReadable()) { }
}
}
〈异步文件与网络IO〉
Java 7引入NIO.2,提供异步通道:
- AsynchronousFileChannel:异步文件读写
- AsynchronousSocketChannel:异步网络通信
示例:异步文件读取
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
Paths.get("data.txt"), StandardOpenOption.READ);
channel.read(ByteBuffer.allocate(1024), 0, null,
new CompletionHandler() {
public void completed(Integer result, Void attachment) {
System.out.println("读取字节数: " + result);
}
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
〈Files工具类〉
java.nio.file.Files提供便捷的文件操作:
- readAllBytes/lines:读取文件
- write:写入文件
- copy/move:复制/移动
- delete:删除
- exists/notExists:检查文件
- list/lines:遍历目录
示例:读取文件所有行
List lines = Files.readAllLines(Paths.get("file.txt"), StandardCharsets.UTF_8);
lines.forEach(System.out::println);
反射与注解
〈反射机制原理〉
反射通过Class、Field、Method、Constructor等类在运行时操作对象:
- 获取Class对象:Class.forName()、对象.getClass()、类型.class
- 创建对象:Class.newInstance()(已过时)或Constructor.newInstance()
- 访问字段:Field.get/set()
- 调用方法:Method.invoke()
性能注意:反射比直接调用慢约100倍,应缓存反射结果。
示例:动态调用方法
Class> clazz = Class.forName("com.example.Hello");
Object obj = clazz.getDeclaredConstructor().newInstance();
Method method = clazz.getMethod("sayHello", String.class);
method.invoke(obj, "World");
〈注解处理器与元编程〉
注解分三类生命周期:
- SOURCE:仅源码阶段(@Override)
- CLASS:编译到字节码(默认)
- RUNTIME:运行时可通过反射获取
元注解:
- @Target:注解位置
- @Retention:生命周期
- @Documented:生成Javadoc
- @Inherited:子类继承
运行时注解处理示例:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {
String value();
}
// 使用
class User {
@Column("user_name")
private String name;
}
// 读取
Field field = User.class.getDeclaredField("name");
Column column = field.getAnnotation(Column.class);
String columnName = column.value();
〈APT与Lombok原理〉
APT(Annotation Processing Tool)在编译期处理注解:
- 实现Processor接口
- 重写process方法
- 生成额外源码或配置
典型应用:
- Lombok:@Getter/@Setter/@Data生成getter/setter
- Dagger:依赖注入代码生成
- MapStruct:对象映射代码生成
Lombok等价代码示例:
// 源码
@Data
public class User {
private String name;
private int age;
}
// 编译后生成
public class User {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
// ... hashCode, equals, toString
}
〈JDK动态代理〉
JDK动态代理基于InvocationHandler:
interface Service {
void process();
}
class ServiceImpl implements Service {
public void process() { System.out.println("处理请求"); }
}
class ProxyHandler implements InvocationHandler {
private final Service target;
ProxyHandler(Service target) { this.target = target; }
public Object invoke(Object proxy, Method method, Object[] args) {
System.out.println("方法调用前");
Object result = method.invoke(target, args);
System.out.println("方法调用后");
return result;
}
}
// 创建代理
Service proxy = (Service) Proxy.newProxyInstance(
Service.class.getClassLoader(),
new Class[]{Service.class},
new ProxyHandler(new ServiceImpl())
);
proxy.process();
Spring AOP底层即基于JDK动态代理或CGLIB(继承实现)。
设计模式实战
〈创建型模式〉
单例模式(DCL+volatile):
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
工厂模式:
interface Shape { void draw(); }
class Circle implements Shape { public void draw() { System.out.println("圆"); } }
class Rectangle implements Shape { public void draw() { System.out.println("矩形"); } }
class ShapeFactory {
public Shape getShape(String type) {
if ("circle".equalsIgnoreCase(type)) return new Circle();
if ("rectangle".equalsIgnoreCase(type)) return new Rectangle();
return null;
}
}
〈结构型模式〉
装饰器模式(IO流):
BufferedReader reader = new BufferedReader(
new InputStreamReader(
new FileInputStream("file.txt"), StandardCharsets.UTF_8));
代理模式(Spring AOP):
- 静态代理:手动编写代理类
- 动态代理:JDK Proxy / CGLIB
〈行为型模式〉
观察者模式(Java Event):
class Button {
private List listeners = new ArrayList<>();
public void addListener(MouseListener l) { listeners.add(l); }
public void click() {
listeners.forEach(l -> l.mouseClicked(null));
}
}
策略模式(Comparator):
Comparator byLength = (s1, s2) -> Integer.compare(s1.length(), s2.length());
List list = Arrays.asList("apple", "banana", "cat");
list.sort(byLength);
〈Spring核心设计〉
Spring框架广泛使用设计模式:
- 工厂模式:BeanFactory
- 单例模式:默认Bean作用域
- 代理模式:AOP实现
- 模板方法:JdbcTemplate
- 观察者模式:ApplicationEvent
依赖注入(DI)示例:
@Service
public class UserService {
@Autowired private UserRepository repo;
}
开发工具链
〈IDE与编辑器〉
主流IDE对比:
| IDE | 优势 | 适用场景 |
|---|---|---|
| IntelliJ IDEA | 智能提示强、插件丰富 | 企业级开发 |
| Eclipse | 插件生态成熟 | 传统项目 |
| VS Code | 轻量、跨平台 | 快速开发/微服务 |
推荐插件:
- IntelliJ IDEA:Lombok、CheckStyle、SonarLint
- VS Code:Java Extension Pack、Prettier
〈构建与测试工具〉
Maven依赖管理:
org.springframework.boot
spring-boot-starter-web
3.1.0
Gradle构建脚本:
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web:3.1.0'
testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
}
测试框架:
- JUnit 5:单元测试(@Test, @BeforeEach)
- Mockito:Mock框架(@Mock, @InjectMocks)
- TestNG:高级测试组织
〈Git工作流〉
推荐工作流:
- master分支:稳定版本
- develop分支:开发集成
- feature分支:功能开发
- hotfix分支:紧急修复
常用命令:
- git clone:克隆仓库
- git checkout -b feature/login:创建分支
- git commit -m "feat: 添加登录功能"
- git push origin feature/login
- git merge:合并分支
〈性能分析工具〉
常用工具:
- VisualVM:CPU/内存分析
- JProfiler:商业性能分析
- JMH:微基准测试
- Arthas:线上诊断
JMH示例:
@Benchmark
public void testArrayList() {
List list = new ArrayList<>();
for (int i = 0; i < 1000; i++) list.add(i);
}
Java安全机制
〈安全架构〉
Java安全架构核心组件:
- Security Manager(Java 17后弃用)
- Java Cryptography Architecture (JCA)
- Java Secure Socket Extension (JSSE)
- Java Authentication and Authorization Service (JAAS)
现代安全实践:
- 输入验证:防止SQL注入(PreparedStatement)、XSS(HTML转义)
- 加密存储:密码使用BCrypt/Argon2
- 安全随机数:SecureRandom
- 权限控制:基于角色的访问控制(RBAC)
〈模块系统(Java 9+)〉
模块(module)通过module-info.java定义依赖与导出:
module com.example.app {
requires java.base;
requires spring.core;
exports com.example.service;
opens com.example.controller to spring.core;
}
模块优势:
- 强封装:默认不导出包
- 依赖清晰:显式声明依赖
- 减少攻击面
- 优化启动性能
〈加密API使用〉
对称加密(AES):
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256);
SecretKey key = keyGen.generateKey();
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypted = cipher.doFinal("Hello".getBytes());
非对称加密(RSA):
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
kpg.initialize(2048);
KeyPair pair = kpg.generateKeyPair();
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, pair.getPublic());
〈JWT安全认证〉
JWT(JSON Web Token)结构:
- Header:算法信息(HS256)
- Payload:用户信息(claims)
- Signature:签名验证
示例(使用jjwt库):
String jwt = Jwts.builder()
.setSubject("user123")
.setExpiration(new Date(System.currentTimeMillis() + 3600000))
.signWith(SignatureAlgorithm.HS256, "secretKey")
.compact();
安全要点:
- 使用强密钥
- 设置合理过期时间
- 验证签名与过期
- 敏感信息不存入Payload
社区与学习资源
〈学习路径建议〉
入门阶段(1-3个月)
- 掌握语法基础(变量、流程控制、OOP)
- 完成小项目(计算器、图书管理系统)
- 学习基础算法与数据结构
进阶阶段(3-6个月)
- 深入集合框架与泛型
- 掌握多线程与并发编程
- 理解JVM内存模型
- 学习常用设计模式
专家阶段(6个月+)
- 研究框架源码(Spring、MyBatis)
- 参与开源项目
- 性能调优与架构设计
- 技术分享与写作
〈推荐书籍〉
- 《Effective Java》:Java开发圣经,3rd edition(Joshua Bloch)
- 《Java并发编程实战》:并发编程权威指南(Brian Goetz)
- 《深入理解Java虚拟机》:JVM原理与调优(周志明)
- 《设计模式》:GOF设计模式(Erich Gamma等)
- 《Spring Boot编程思想》:Spring核心原理(小马哥)
〈实战项目建议〉
- 图书管理系统:基础CRUD、集合使用
- 在线聊天室:Socket编程、多线程
- 博客系统:Spring Boot、MyBatis、Redis
- 秒杀系统:高并发、Redis、分布式锁
- 个人博客:静态网站生成、Markdown解析