Java 核心语法与高级实践

public class HelloWorld {
    // 程序的主入口点，所有的Java独立应用程序都从这里开始执行
    public static void main(String[] args) {
        // 向标准输出终端打印一行文本字符串，并自动换行
        System.out.println("Hello, XiaoYu Tech World!");
    }
}

public class BubbleSort {
    public static void sort(int[] arr) {
        int n = arr.length;
        // 外层循环控制排序的轮数，总共执行 n-1 轮
        for (int i = 0; i < n - 1; i++) {
            // 内层循环负责进行相邻元素的比较与位置交换
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 发现逆序，执行经典的无损三变量值交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

public class CacheManager {
    // 使用 volatile 关键字禁止指令重排，确保多线程可见性
    private static volatile CacheManager instance;

    private CacheManager() {} // 私有化构造函数，防止外部非法 new 实例化

    public static CacheManager getInstance() {
        if (instance == null) { // 第一重检查：避免不必要的同步锁开销
            synchronized (CacheManager.class) {
                if (instance == null) { // 第二重检查：确保只有一个实例被创建
                    instance = new CacheManager();
                }
            }
        }
        return instance;
    }
}

public class BinarySearch {
    public static int search(int[] arr, int low, int high, int target) {
        if (low > high) return -1; // 递归终结条件：未找到目标元素
        
        // 采用防溢出的折中计算法，替代传统的 (low + high) / 2
        int mid = low + (high - low) / 2;
        
        if (arr[mid] == target) return mid; // 命中目标，返回对应索引
        if (arr[mid] > target) {
            return search(arr, low, mid - 1, target); // 目标在左侧区间，递归左半部
        }
        return search(arr, mid + 1, high, target); // 目标在右侧区间，递归右半部
    }
}

public class TaskWorker implements Runnable {
    private String taskName;
    
    public TaskWorker(String name) {
        this.taskName = name;
    }

    @Override
    public void run() {
        // 获取当前正在执行此段代码的线程上下文名称
        System.out.println(Thread.currentThread().getName() + " 开始处理任务: " + taskName);
        try {
            Thread.sleep(1500); // 模拟耗时的密集型业务逻辑计算
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 保持线程中断状态
        }
        System.out.println(taskName + " 任务执行完毕。");
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> inputs = Arrays.asList("apple", "", "banana", "cherry", "apricot");
        
        // 利用Stream流水线：过滤空字符串 -> 筛选a开头的元素 -> 转换大写 -> 收集成列表
        List<String> result = inputs.stream()
            .filter(str -> !str.isEmpty())
            .filter(str -> str.startsWith("a"))
            .map(String::toUpperCase)
            .collect(Collectors.toList());
            
        System.out.println(result); // 输出: [APPLE, APRICOT]
    }
}

import java.sql.*;

public class JdbcQuery {
    public void fetchUser(String dbUrl, String user, String pass, int userId) {
        String sql = "SELECT id, username FROM users WHERE id = ?";
        // 使用 try-with-resources 确保数据库物理资源能够被无条件自动闭合回收
        try (Connection conn = DriverManager.getConnection(dbUrl, user, pass);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            
            pstmt.setInt(1, userId); // 强类型参数化绑定，从源头上斩断 SQL 注入攻击
            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    System.out.println("用户: " + rs.getString("username"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NioReader {
    public static void readFile(String filePath) throws IOException {
        // 借助传统文件流获取高性能的 NIO 通道文件传输器
        try (FileInputStream fis = new FileInputStream(filePath);
             FileChannel channel = fis.getChannel()) {
            
            ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配1KB的高速缓冲区
            while (channel.read(buffer) != -1) {
                buffer.flip(); // 反转缓冲区：由写入模式无缝切换为读取读取模式
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get()); // 循环抽离并消费字节流
                }
                buffer.clear(); // 清空复位缓冲区，准备承接下一轮的管道数据写入
            }
        }
    }
}

public class BusinessException extends Exception {
    private int errorCode;

    // 继承父类带有异常说明文字的构造，保证调用栈的可回溯性
    public BusinessException(int errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }

    public int getErrorCode() {
        return this.errorCode;
    }
}

interface Button { void render(); }
class DarkButton implements Button { public void render() { System.out.println("暗黑风按钮"); } }

interface GUIFactory { Button createButton(); }
// 具体的工厂实现，专门负责生成特定的暗黑风格组件族群
class DarkThemeFactory implements GUIFactory {
    public Button createButton() {
        return new DarkButton(); // 工厂多态：返回具体的类，上层只感知标准接口
    }
}