基础阶段：掌握Java核心语法（二）-CSDN博客

本文链接：https://blog.csdn.net/m0_67574906/article/details/145991103

基础阶段：掌握 Java 核心语法（二）

1. 异常处理

1.1 核心概念

Java 异常处理通过 try-catch-finally 结构实现，用于捕获和处理运行时错误，防止程序崩溃。

try 块：包含可能抛出异常的代码。
catch 块：捕获并处理异常。
finally 块：无论是否捕获异常，都会执行，常用于资源清理。

1.2 源码解析

以下是一个简单的异常处理示例及其源码解析：

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 故意引发异常
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            System.out.println("执行finally块");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // 可能抛出异常
    }
}

输出：

捕获到异常: / by zero
执行finally块

1.3 高级应用

在实际开发中，可以通过自定义异常和全局异常处理器来统一处理异常。例如：

public class BizException extends RuntimeException {
    private final int code;

    public BizException(int code, String message) {
        super(message);
        this.code = code;
    }
}

2. 集合框架

2.1 核心概念

Java 集合框架提供了多种数据结构，如 List、Set 和 Map，用于存储和操作对象。

2.2 源码解析

以下是 ArrayList 和 HashMap 的源码解析：

ArrayList 源码：

public class ArrayList<E> implements List<E> {
    private Object[] elementData; // 内部数组
    private int size; // 元素数量

    public boolean add(E e) {
        ensureCapacityInternal(size + 1); // 确保容量足够
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity); // 扩容
        }
    }

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量为旧容量的1.5倍
        elementData = Arrays.copyOf(elementData, newCapacity); // 重新分配数组
    }
}

HashMap 源码：

public class HashMap<K,V> implements Map<K,V> {
    static final int DEFAULT_INITIAL_CAPACITY = 16; // 默认初始容量
    static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认负载因子
    private Entry<K,V>[] table; // 哈希表

    public V put(K key, V value) {
        int hash = key.hashCode(); // 计算哈希值
        int index = hash % table.length; // 确定索引
        Entry<K,V> entry = table[index];
        if (entry == null) {
            table[index] = new Entry<>(key, value, null); // 插入新节点
        } else {
            // 处理哈希冲突（链表或红黑树）
        }
        return value;
    }
}

2.3 使用示例

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);

3. 输入输出（I/O）

3.1 核心概念

Java I/O 提供了字节流和字符流两种方式，用于处理文件读写。

3.2 源码解析

以下是文件读写的示例：

import java.io.*;

public class FileIOExample {
    public static void main(String[] args) {
        // 写入文件
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, World!");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 读取文件
        try (BufferedReader br = new BufferedReader(new FileReader("output.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println("File content: " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 多线程

4.1 核心概念

多线程通过 Thread 类或 Runnable 接口实现。

4.2 源码解析

以下是线程池的源码解析：

public ThreadPoolExecutor(
    int corePoolSize, // 核心线程数
    int maximumPoolSize, // 最大线程数
    long keepAliveTime, // 空闲线程存活时间
    TimeUnit unit, // 时间单位
    BlockingQueue<Runnable> workQueue, // 任务队列
    ThreadFactory threadFactory, // 线程工厂
    RejectedExecutionHandler handler // 拒绝策略
) {
    // 初始化逻辑
}

4.3 使用示例

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> System.out.println("Task executed by: " + Thread.currentThread().getName()));
executor.shutdown();

5. 泛型、注解和 Lambda 表达式

5.1 泛型

泛型通过类型参数提供类型安全：

List<String> list = new ArrayList<>();
list.add("Java");

5.2 注解

注解用于提供元数据：

@FunctionalInterface
public interface Runnable {
    void run();
}

5.3 Lambda 表达式

Lambda 表达式通过 invokedynamic 指令实现：

Runnable runnable = () -> System.out.println("Lambda expression");
new Thread(runnable).start();

Lambda 表达式源码：

public static CallSite metafactory(MethodHandles.Lookup caller,
                                   String invokedName,
                                   MethodType invokedType,
                                   MethodType samMethodType,
                                   MethodHandle implMethod,
                                   MethodType instantiatedMethodType)
    throws LambdaConversionException {
    AbstractValidatingLambdaMetafactory mf;
    mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                         invokedName, samMethodType,
                                         implMethod, instantiatedMethodType,
                                         false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
    mf.validateMetafactoryArgs();
    return mf.buildCallSite();
}