java语言词汇

核心词汇

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为标准组合。