核心词汇
Java语言词汇体系以JDK(Java Development Kit)为核心构建,其基础词汇涵盖语言语法、数据类型、控制结构及核心API等维度。作为一门强类型、面向对象的编程语言,Java通过严谨的词汇规范保障代码的可读性与可维护性。JDK包含JRE(Java Runtime Environment)与开发工具链,而JRE又由JVM(Java Virtual Machine)与核心类库组成。这种分层架构确保Java程序“一次编译,到处运行”的跨平台特性。
Java关键字共50个(含3个保留字),如class、interface、extends、implements、public、private、protected、static、final、abstract、synchronized、volatile、native、transient、strictfp、try、catch、finally、throw、throws、new、instanceof、return、break、continue、switch、case、default、if、else、for、while、do、goto(保留)、const(保留)、assert、enum、package、import、this、super、void、boolean、byte、char、short、int、long、float、double、if、else、try、catch、finally、throw、throws、new、class、interface、extends、implements、abstract、final、static、native、strictfp、volatile、transient、synchronized、goto、const、assert、enum、package、import、this、super、void、boolean、byte、char、short、int、long、float、double。其中assert(断言)、enum(枚举)、package(包)、import(导入)为JDK 1.0后新增的关键字,用于增强语言表达力。
基础数据类型共8种:整数型(byte、short、int、long)、浮点型(float、double)、字符型(char)与布尔型(boolean)。每种类型有明确的取值范围与默认值,例如int占4字节,范围为-2³¹至2³¹-1;double占8字节,遵循IEEE 754标准。Java还提供对应的包装类(如Integer、Double),支持自动装箱与拆箱(Autoboxing/Unboxing),这是JDK 5引入的重要特性。
核心词汇速查表
| 类别 | 词汇 | 说明 |
|---|---|---|
| 访问控制 | public、private、protected、default |
控制类、方法、字段的可见性范围 |
| 类与继承 | class、interface、extends、implements、abstract、final |
定义类、接口、抽象类及继承规则 |
| 变量修饰 | static、final、transient、volatile、strictfp |
指定变量行为:静态、常量、序列化、线程同步等 |
| 异常处理 | try、catch、finally、throw、throws |
构建结构化异常处理机制 |
| 流程控制 | if、else、switch、case、for、while、do、break、continue、return |
实现条件、循环与跳转逻辑 |
| 对象操作 | new、instanceof、this、super、void |
创建对象、类型判断、引用当前/父类实例 |
Java标识符命名规则严格:由字母、数字、下划线(_)、美元符号($)组成,首字符不能为数字;区分大小写;不能使用关键字;推荐使用驼峰命名法(如javaClassName)。类名首字母大写(PascalCase),方法与变量名首字母小写(camelCase),常量全大写(UPPER_SNAKE_CASE)。
Java语言特性包括:面向对象(OOP)、平台无关性(通过JVM实现)、强类型检查、自动内存管理(垃圾回收GC)、多线程支持、泛型、注解、Lambda表达式(JDK 8)、模块化(JDK 9)等。这些特性共同构成Java词汇体系的语义基础,确保其在企业级开发中的稳定性与可扩展性。
主流JDK版本演进与核心词汇变化
- JDK 1.0 (1996):确立
package、import、class、interface、extends、implements、public、private、protected、static、final、abstract、try、catch、finally、throw、throws、new、return、break、continue、if、else、for、while、do、switch、case、default、this、super、void、boolean、byte、char、short、int、long、float、double等基础词汇。 - JDK 5 (2004):引入
enum(枚举)、assert(断言)、varargs(可变参数,语法形式为type... name)、autoboxing/unboxing(自动装箱/拆箱)、generics(泛型,引入<T>、<?>、<? extends T>、<? super T>)、annotations(注解,引入@Override、@Deprecated、@SuppressWarnings)、static import(静态导入)。 - JDK 8 (2014):引入Lambda表达式(
() → expression或() → { statements })、方法引用(::)、Stream API(stream()、filter()、map()、collect())、Optional类(Optional<T>)、默认方法(default关键字用于接口方法)、重复注解(@Repeatable)、类型注解(@Target(ElementType.TYPE_USE))。 - JDK 9 (2017):引入模块化系统(
module、requires、exports、opens、uses、provides、with),增强var(局部变量类型推断,但非JDK 10才正式引入?注:JDK 10引入var,此处为提前说明);改进Process API、Stream API、Collectors、Optional、Collection接口(of()、copyOf())。 - JDK 17 (2021):长期支持(LTS)版本,强化
sealed classes(sealed、non-sealed)、pattern matching for instanceof(if (obj instanceof String s))、records(record Point(int x, int y) {})、text blocks(三引号字符串:"""line1\nline2""")、switch增强(yield关键字)。
这些词汇演进不仅反映语言能力提升,也体现Java对现代编程范式(函数式、响应式、声明式)的兼容与融合。开发者需持续更新词汇库以适应技术发展。
面向对象
面向对象编程(OOP)是Java语言的基石,其核心词汇围绕class(类)、object(对象)、inheritance(继承)、polymorphism(多态)、encapsulation(封装)、abstraction(抽象)四大特性构建。这些概念通过特定词汇表达,形成严谨的语法体系。
四大特性详解
1. 封装(Encapsulation)
封装通过private、protected、public访问修饰符隐藏对象内部状态,仅暴露必要接口(getXXX()、setXXX())。例如:
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) {
if (age >= 0) this.age = age;
}
}
此设计确保age字段只能通过合法逻辑修改,防止无效值(负数)污染对象状态。
2. 继承(Inheritance)
继承使用extends关键字实现类的复用,子类可重写父类方法(@Override)。单继承机制避免多重继承的复杂性,同时通过implements支持多接口实现。
public class Animal {
protected String name;
public void eat() { System.out.println(name + " eats."); }
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println(name + " eats bones.");
}
}
3. 多态(Polymorphism)
多态体现为“父类引用指向子类对象”,运行时动态绑定方法。例如:
Animal dog = new Dog();
dog.setName("Buddy");
dog.eat(); // 输出:Buddy eats bones.
实际调用的是Dog类重写的eat()方法,体现了“一个接口,多种实现”的设计哲学。
4. 抽象(Abstraction)
抽象通过abstract类与interface实现,将共性提取为契约。抽象类可含实现代码(abstract方法+具体方法),接口(JDK 8后)支持默认方法(default)与静态方法(static)。
public interface Drivable {
void drive();
default void stop() {
System.out.println("Stopped.");
}
}
public abstract class Vehicle {
protected String brand;
public abstract void start();
}
构造方法与this/super
构造方法(Constructor)名称与类名相同,无返回类型。使用this()调用本类其他构造器,super()调用父类构造器,必须位于首行。
public class Student extends Person {
private int grade;
public Student(String name, int grade) {
super(name); // 调用父类构造器
this.grade = grade;
}
public Student(String name) {
this(name, 0); // 调用本类其他构造器
}
}
内部类(Inner Class)
内部类分为成员内部类、静态内部类、局部内部类与匿名内部类,增强封装性与代码组织能力。
public class Outer {
private String outerField = "Outer";
class Inner {
void print() {
System.out.println(outerField); // 可直接访问外部类私有字段
}
}
static class StaticInner {
void print() {
// 不能直接访问外部类非静态成员
}
}
}
对象生命周期与垃圾回收
对象通过new创建,生命周期结束时由JVM垃圾回收器(GC)自动回收。可通过finalize()(已过时,不推荐)或try-with-resources(JDK 7)确保资源释放。
try (FileInputStream fis = new FileInputStream("test.txt")) {
// 使用资源
} catch (IOException e) {
e.printStackTrace();
} // 自动关闭资源
强引用、软引用(SoftReference)、弱引用(WeakReference)、虚引用(PhantomReference)共同构成Java引用体系,影响GC行为。
集合体系
Java集合框架(Collections Framework)是语言核心库之一,提供统一的接口与实现类,涵盖Collection(单值集合)与Map(键值对集合)两大体系。其词汇设计强调可扩展性与高性能。
Collection体系
List接口
ArrayList(基于动态数组,随机访问快)、LinkedList(基于双向链表,增删快)、Vector(线程安全,已过时)实现List接口,支持有序、可重复元素。
List<String> list = new ArrayList<>();
list.add("Java");
list.add(0, "Hello"); // 插入到指定位置
System.out.println(list.get(0)); // 输出:Hello
Set接口
HashSet(基于HashMap,无序不重复)、LinkedHashSet(保持插入顺序)、TreeSet(基于红黑树,自然排序或自定义比较器)实现Set接口,确保元素唯一性。
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("A"); // 重复元素被忽略
System.out.println(set.size()); // 输出:2
Queue/Deque接口
Queue(队列,FIFO)与Deque(双端队列)支持先进先出/双端操作。常用实现类:LinkedList、ArrayDeque(非线程安全)、PriorityQueue(优先队列)。
Deque<String> deque = new ArrayDeque<>();
deque.push("A"); // 入栈
deque.offerLast("B"); // 入队尾
deque.pollFirst(); // 出队头
Map体系
HashMap(非线程安全,允许null键值)、LinkedHashMap(保持访问顺序)、TreeMap(排序)、Hashtable(线程安全,不允许null)、ConcurrentHashMap(高并发)实现Map接口。
Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);
System.out.println(map.get("Java")); // 输出:1
集合工具类
Collections类提供静态方法操作集合:sort()(排序)、binarySearch()(二分查找)、reverse()(反转)、synchronizedList()(线程安全包装)。
List<Integer> list = Arrays.asList(3, 1, 2); Collections.sort(list); System.out.println(list); // 输出:[1, 2, 3]
Arrays类操作数组:asList()(数组转List)、sort()、equals()(比较)、fill()(填充)。
集合选择指南
集合选择决策表
| 需求 | 推荐集合 | 原因 |
|---|---|---|
| 频繁随机访问 | ArrayList |
数组结构支持O(1)随机访问 |
| 频繁插入/删除 | LinkedList |
链表结构增删时间复杂度O(1) |
| 去重且无序 | HashSet |
哈希结构保证唯一性,查询快 |
| 去重且有序 | LinkedHashSet |
哈希+链表结构维持插入顺序 |
| 排序键值对 | TreeMap |
红黑树实现自然/自定义排序 |
| 高并发Map | ConcurrentHashMap |
分段锁/ CAS + synchronized 提升并发性能 |
集合遍历方式
- for-each循环:简洁安全,适用于所有
Iterable集合 - Iterator:支持遍历中删除元素(
remove()) - forEach + Lambda(JDK 8):函数式风格
- Stream API:支持链式操作(
filter、map、collect)
List<String> list = Arrays.asList("A", "B", "C");
list.stream()
.filter(s -> s.startsWith("A"))
.forEach(System.out::println);
集合框架的设计遵循“接口-实现-算法”分离原则,词汇体系清晰反映其层次结构,开发者需根据场景选择合适实现类以平衡性能与功能。
并发编程
Java并发包(java.util.concurrent)提供丰富的词汇与工具,解决多线程开发中的同步、通信、性能问题。核心词汇围绕Thread(线程)、Runnable(任务)、synchronized(同步)、volatile(可见性)、Lock(显式锁)、Executor(线程池)构建。
线程创建方式
- 继承Thread类:重写
run()方法,调用start()启动 - 实现Runnable接口:将任务逻辑封装在
run()中,交由Thread执行 - 实现Callable接口(JDK 5):返回结果并可抛出异常,配合
FutureTask使用 - 线程池(推荐):通过
ExecutorService管理线程生命周期
ExecutorService pool = Executors.newFixedThreadPool(3);
pool.submit(() -> {
System.out.println("Task executed in thread: " + Thread.currentThread().getName());
});
pool.shutdown();
同步机制
1. synchronized关键字
提供互斥锁(Monitor),可修饰方法或代码块:
public synchronized void method() { }
public void method() {
synchronized(this) { }
}
锁对象为this(实例锁)或类对象(ClassName.class,静态锁)。
2. volatile关键字
保证变量可见性(线程修改后立即写入主存),禁止指令重排序,但不保证原子性。
private volatile boolean running = true;
public void stop() {
running = false; // 其他线程可立即感知
3. 显式锁(Lock)
ReentrantLock支持可重入、公平锁、可中断锁、超时锁:
Lock lock = new ReentrantLock();
lock.lock();
try {
// 临界区
} finally {
lock.unlock(); // 必须在finally中释放
原子类
java.util.concurrent.atomic包提供无锁原子操作:
AtomicInteger:原子整数AtomicReference:原子引用AtomicBoolean:原子布尔值LongAdder(JDK 8):高并发下性能优于AtomicLong
AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // 原子自增
并发工具类
并发工具类对比表
| 工具类 | 用途 | 关键方法 |
|---|---|---|
CountDownLatch |
等待N个线程完成 | countDown()、await() |
CyclicBarrier |
线程间屏障同步 | await()、reset() |
Semaphore |
控制并发线程数 | acquire()、release() |
ConcurrentHashMap |
线程安全Map | 所有Map方法 |
BlockingQueue |
线程安全队列 | put()、take() |
线程池参数详解
ThreadPoolExecutor构造函数参数:
new ThreadPoolExecutor(
corePoolSize, // 核心线程数
maximumPoolSize, // 最大线程数
keepAliveTime, // 空闲线程存活时间
unit, // 时间单位
workQueue, // 任务队列
threadFactory, // 线程工厂
handler // 拒绝策略
);
拒绝策略:AbortPolicy(抛异常)、CallerRunsPolicy(调用者线程执行)、DiscardPolicy(静默丢弃)、DiscardOldestPolicy(丢弃 oldest 任务)。
Fork/Join框架
分治任务框架,通过ForkJoinPool与RecursiveTask实现工作窃取算法:
class SumTask extends RecursiveTask<Long> {
private final long[] array;
private final int start, end;
SumTask(long[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
if (end - start <= 1000) {
long sum = 0;
for (int i = start; i < end; i++) sum += array[i];
return sum;
}
int mid = (start + end) / 2;
SumTask left = new SumTask(array, start, mid);
SumTask right = new SumTask(array, mid, end);
invokeAll(left, right);
return left.join() + right.join();
}
}
并发编程词汇体系强调“安全”与“性能”平衡,开发者需深入理解线程模型、内存模型(JMM)及工具特性,避免死锁、活锁、饥饿等风险。
输入输出
Java I/O系统基于“流”(Stream)概念,分为字节流(InputStream、OutputStream)与字符流(Reader、Writer),支持文件、网络、内存等多场景操作。JDK 7引入NIO.2(java.nio.file)提供异步文件操作,JDK 8增强Stream与I/O集成。
传统I/O(BIO)
字节流
FileInputStream、FileOutputStream读写二进制文件:
try (FileInputStream fis = new FileInputStream("input.bin");
FileOutputStream fos = new FileOutputStream("output.bin")) {
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
}
字符流
FileReader、FileWriter处理文本文件(自动处理字符编码):
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
}
对象流
ObjectInputStream、ObjectOutputStream实现对象序列化:
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.dat"))) {
User user = new User("Alice", 30);
oos.writeObject(user);
}
需实现Serializable接口,可自定义serialVersionUID。
NIO(New I/O)
NIO基于通道(Channel)与缓冲区(Buffer),支持非阻塞模式:
try (FileChannel channel = FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ)) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
}
NIO.2(异步I/O)
JDK 7引入AsynchronousFileChannel:
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
Paths.get("file.txt"), StandardOpenOption.READ);
channel.read(ByteBuffer.allocate(1024), 0, null, new CompletionHandler<Integer, Void>() {
@Override
public void completed(Integer result, Void attachment) {
System.out.println("Read " + result + " bytes");
}
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
Files工具类
java.nio.file.Files提供便捷静态方法:
Path path = Paths.get("file.txt");
String content = Files.readString(path); // JDK 11
List<String> lines = Files.readAllLines(path);
Files.write(path, "Hello".getBytes());
I/O词汇总结
I/O核心词汇表
| 类别 | 词汇 | 说明 |
|---|---|---|
| 字节流 | InputStream、OutputStream |
所有字节流基类 |
| 字符流 | Reader、Writer |
所有字符流基类 |
| 缓冲流 | BufferedInputStream、BufferedReader |
提升I/O性能 |
| 转换流 | InputStreamReader、OutputStreamWriter |
字节→字符转换,支持编码 |
| 对象流 | ObjectInputStream、ObjectOutputStream |
对象序列化/反序列化 |
| NIO核心 | Channel、Buffer、Selector |
非阻塞I/O基础组件 |
| NIO.2路径 | Path、Paths、Files |
统一文件操作API |
I/O操作需注意资源释放(使用try-with-resources)、字符编码一致性(推荐UTF-8)、大文件处理(分块读取)及异常处理。现代Java开发中,优先使用NIO.2与Stream API组合实现高效I/O。
反射机制
反射(Reflection)是Java的动态特性,允许运行时检查与操作类结构。核心词汇围绕Class、Method、Field、Constructor构建,通过java.lang.reflect包提供API。
获取Class对象
Class.forName("com.example.User"):动态加载类User.class:类字面量user.getClass():对象实例方法
反射操作
1. 创建对象
Class<User>> clazz = User.class; User user = clazz.getDeclaredConstructor().newInstance();
2. 访问字段
Field field = clazz.getDeclaredField("name");
field.setAccessible(true); // 绕过访问控制
field.set(user, "Bob");
System.out.println(field.get(user));
3. 调用方法
Method method = clazz.getDeclaredMethod("setName", String.class);
method.invoke(user, "Alice");
4. 访问构造器
Constructor<User> constructor = clazz.getDeclaredConstructor(String.class, int.class);
constructor.setAccessible(true);
User user2 = constructor.newInstance("Charlie", 25);
注解与反射
运行时注解(@Retention(RetentionPolicy.RUNTIME))可通过反射读取:
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String value();
}
public class User {
@Column("user_name")
private String name;
}
Field field = User.class.getDeclaredField("name");
Column column = field.getAnnotation(Column.class);
System.out.println(column.value()); // 输出:user_name
反射性能优化
- 使用
setAccessible(true)减少权限检查 - 缓存
Class、Method等对象 - 避免频繁创建
Method对象(使用MethodHandle替代)
反射应用场景
- 框架开发(Spring依赖注入、MyBatis SQL映射)
- 动态代理(
Proxy.newProxyInstance) - 序列化库(Jackson、Gson)
- 插件化架构
反射虽强大,但牺牲性能与类型安全,需谨慎使用。现代Java推荐优先考虑接口、策略模式等静态方式,仅在动态性需求明确时启用反射。
异常体系
Java异常体系基于Throwable基类,分为Error(系统级错误)与Exception(程序可处理异常)。Exception进一步分为Checked Exception(编译时异常)与Unchecked Exception(运行时异常)。
异常继承树
Throwable
├── Error(如OutOfMemoryError)
└── Exception
├── RuntimeException(如NullPointerException)
└── 其他Checked Exception(如IOException)
异常处理语法
try-catch-finally结构:
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.err.println("Division by zero: " + e.getMessage());
} finally {
System.out.println("Cleanup code");
}
自定义异常
继承Exception(Checked)或RuntimeException(Unchecked):
public class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}
异常链
通过initCause()或构造函数Exception(String, Throwable)保留原始异常信息:
try {
// 原始异常
} catch (IOException e) {
throw new RuntimeException("File processing failed", e);
}
JDK 7新特性:try-with-resources
自动关闭实现了AutoCloseable接口的资源:
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
String line = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
最佳实践
- 优先捕获具体异常(避免
Exception泛化) - 不要忽略异常(至少记录日志)
- 使用自定义异常封装业务逻辑
- 避免在
finally中抛出异常
异常词汇体系强调“明确性”与“可恢复性”,合理设计异常层次有助于构建健壮应用。
泛型设计
泛型(Generics)是JDK 5引入的类型安全机制,通过<T>、<?>等符号实现编译时类型检查,避免运行时ClassCastException。
泛型类与接口
public class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
public interface Comparator<T> {
int compare(T o1, T o2);
}
通配符
<? extends T>:上界通配符(T的子类)<? super T>:下界通配符(T的父类)<?>:无界通配符(任意类型)
public static void printList(List<? extends Number> list) {
for (Number n : list) System.out.println(n);
}
List<Integer> ints = Arrays.asList(1, 2, 3);
printList(ints); // 合法
类型擦除
泛型仅存在于编译期,运行时被擦除为原始类型(Raw Type),例如List<String>在运行时为List。因此无法通过反射获取泛型参数。
泛型方法
public static <T> T getFirst(List<T> list) {
return list.isEmpty() ? null : list.get(0);
}
PECS原则
Producer Extends, Consumer Super:
- 需要读取数据(生产者)→ 使用? extends T
- 需要写入数据(消费者)→ 使用? super T
- 既读又写 → 使用具体类型
泛型设计词汇强调类型安全与灵活性平衡,是现代Java集合与工具类的基石。
注解应用
注解(Annotations)是元数据机制,通过@符号标识,用于编译时检查、运行时处理或代码生成。核心词汇包括@Override、@Deprecated、@SuppressWarnings、@FunctionalInterface。
元注解
定义注解行为的注解:
@Target:指定注解使用位置(ElementType)@Retention:指定生命周期(SOURCE、CLASS、RUNTIME)@Documented:生成Javadoc文档@Inherited:子类继承父类注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value() default "default";
int count() default 1;
}
内置注解
常用内置注解
| 注解 | 用途 | 示例 |
|---|---|---|
@Override |
重写方法校验 | @Override public String toString() |
@Deprecated |
标记过时API | @Deprecated public void oldMethod() |
@SuppressWarnings |
抑制警告 | @SuppressWarnings("unchecked") |
@SafeVarargs |
抑制可变参数警告 | @SafeVarargs public static void varargsMethod(T... args) |
@FunctionalInterface |
函数式接口校验 | @FunctionalInterface public interface Runnable |
注解处理器
运行时注解通过反射读取(Method.getAnnotation()),编译时注解由注解处理器(APT)处理,如Lombok的@Data。
public class AnnotationProcessor {
public static void process(Object obj) {
for (Method method : obj.getClass().getMethods()) {
if (method.isAnnotationPresent(MyAnnotation.class)) {
MyAnnotation ann = method.getAnnotation(MyAnnotation.class);
System.out.println(ann.value());
}
}
}
}
注解是现代框架(Spring、Hibernate)的核心技术,实现配置与代码分离,提升开发效率。
JVM原理
JVM(Java Virtual Machine)是Java程序的执行环境,负责类加载、字节码解释/编译、内存管理与垃圾回收。其核心词汇围绕运行时数据区、类加载机制、垃圾回收器构建。
运行时数据区
线程私有: ├── 程序计数器(PC Register) ├── 虚拟机栈(VM Stack) └── 本地方法栈(Native Method Stack) 线程共享: ├── 堆(Heap) └── 方法区(Method Area)→ 元空间(Metaspace,JDK 8+)
类加载机制
双亲委派模型:Bootstrap ClassLoader(C++实现)→ Extension ClassLoader → Application ClassLoader。
加载流程:加载 → 验证 → 准备(分配内存,设置初始值)→ 解析(符号引用→直接引用)→ 初始化(执行<clinit>)。
垃圾回收
对象存活判断
- 引用计数法:循环引用问题(JVM未使用)
- 可达性分析:GC Roots(虚拟机栈引用、静态属性、常量等)
垃圾回收算法
- 标记-清除:产生碎片
- 复制:新生代(Eden/S0/S1)
- 标记-整理:老年代
垃圾回收器
主流GC对比
| GC名称 | 区域 | 特点 |
|---|---|---|
Serial |
新生代 | 单线程,Client模式默认 |
Parallel Scavenge |
新生代 | 高吞吐量,可控制暂停时间 |
Parallel Old |
老年代 | Parallel Scavenge的老年代版本 |
CMS |
老年代 | 低延迟,标记-清除,JDK 9废弃 |
G1 |
整堆 | 区域化、并发标记、预测暂停时间 |
ZGC |
整堆 | 亚毫秒级停顿,JDK 11+,实验性 |
JIT编译器
热点代码(执行频率高)编译为本地机器码,提升执行效率。关键参数:-XX:CompileThreshold。
JVM调优关键词
-Xms、-Xmx:堆初始/最大大小-Xmn:新生代大小-XX:MetaspaceSize:元空间初始大小-XX:+UseG1GC:启用G1垃圾回收器
JVM词汇体系是理解Java性能瓶颈的关键,开发者需结合业务场景选择合适配置。
开发工具
Java生态工具链覆盖编码、调试、构建、测试、部署全流程,核心词汇包括IDE、构建工具、测试框架、容器与云原生工具。
集成开发环境(IDE)
- IntelliJ IDEA:JetBrains开发,功能全面,社区版免费
- Eclipse:开源老牌IDE,插件丰富
- NetBeans:Oracle官方支持,轻量级
构建工具
- Maven:基于POM(Project Object Model)配置依赖,坐标:
groupId、artifactId、version - Gradle:Groovy/Kotlin DSL,增量构建,性能优于Maven
// Gradle build.gradle示例
dependencies {
implementation 'org.springframework.boot:spring-boot-starter:2.7.0'
testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
}
测试框架
- JUnit:单元测试标准框架(JDK 5+支持注解)
- TestNG:支持参数化、并行、依赖测试
- Mockito:Mock对象生成
@Test
void testAdd() {
Calculator calc = new Calculator();
assertEquals(5, calc.add(2, 3));
}
容器与云原生工具
- Docker:容器化部署,镜像基于
Dockerfile构建 - Kubernetes:容器编排,管理Pod、Service
- Spring Boot:简化微服务开发,内嵌Tomcat/Jetty
# Dockerfile示例 FROM openjdk:17-jdk-slim COPY target/app.jar app.jar EXPOSE 8080 ENTRYPOINT ["java", "-jar", "app.jar"]
性能分析工具
- JProfiler:商业工具,功能全面
- YourKit:轻量级分析器
- VisualVM:JDK自带,免费
工具选择需权衡学习成本与功能需求,现代Java开发以IDEA + Gradle + Spring Boot + Docker为标准组合。
行业趋势
Java生态持续演进,核心趋势包括:云原生适配、性能优化、语言现代化、企业级框架革新。
1. 云原生与Serverless
Spring Cloud、Quarkus、Micronaut等框架优化冷启动时间与内存占用,适配Kubernetes调度。GraalVM支持AOT(Ahead-of-Time)编译,生成原生镜像,启动速度提升10倍以上。
# GraalVM原生镜像构建 native-image -cp app.jar App
2. 性能优化方向
- ZGC:JDK 11+提供低延迟GC(停顿<10ms)
- Vector API(JDK 16+):SIMD指令支持
- 结构化并发(JDK 19+):
StructuredTaskScope
3. 语言现代化
- Records(JDK 16+):不可变数据载体类
- Pattern Matching:简化
instanceof检查 - Sealed Classes(JDK 17+):限制继承/实现
sealed interface Shape permits Circle, Rectangle {
double area();
}
record Circle(double radius) implements Shape {
public double area() { return Math.PI * radius * radius; }
}
4. 企业级框架革新
- Spring Boot 3:支持JDK 17+、Jakarta EE 9+(包名
javax.*→jakarta.*) - Quarkus:云原生Java框架,启动时间<100ms
5. 安全与合规
Java 17+强化加密算法支持(AES-256、SHA-3),默认启用TLS 1.3,符合GDPR等数据保护法规。
学习路径建议
Java开发者成长路径
- 基础阶段:掌握核心词汇、OOP、集合、异常、I/O
- 进阶阶段:深入并发、反射、JVM原理、设计模式
- 框架阶段:Spring生态(Core、MVC、Boot、Cloud)
- 工程化阶段:Maven/Gradle、Docker、K8s、CI/CD
- 专家阶段:性能调优、源码分析、架构设计
Java语言词汇的深度学习需结合实践项目,从“知道”到“理解”再到“精通”,持续跟踪JEP(JDK Enhancement Proposals)是保持技术前沿的关键。