十一、Java 入门必学：final、单例、枚举、抽象类、接口

最新推荐文章于 2026-09-19 19:34:39 发布
原创 最新推荐文章于 2026-09-19 19:34:39 发布 · 648 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Java学习日常

当前文章被收录于：

Java学习日常
30 篇文章 8 人学习
订阅专栏 查看详情

目录

一、final 关键字

1. 修饰变量：变成 “常量”

2. 修饰方法：禁止子类重写

3. 修饰类：禁止被继承

核心总结

二、单例设计模式

1. 饿汉式单例：“饿了就先吃”（立即加载）

2. 懒汉式单例：“需要时再吃”（延迟加载）

饿汉式 vs 懒汉式

三、枚举

1. 认识枚举类

2. 枚举的应用场景

四、抽象类

1. 抽象类的基本规则

2. 抽象类的好处

3. 模板方法设计模式

抽象类的应用场景

五、接口

1. 认识接口

2. 接口的好处

3. JDK8 新增的三个方法

4. 接口的注意事项

接口 vs 抽象类

总结

一、final 关键字

final在 Java 中意为 “最终的、不可改变的”，可以修饰变量、方法、类，核心作用是限制修改，也是定义 “常量” 的核心关键字。

1. 修饰变量：变成 “常量”

  • 被final修饰的变量，赋值后就不能修改。
  1. 局部变量：声明后可以先不赋值，但只能赋值一次；
  2. 成员变量：必须在声明时 / 构造方法中赋值，且赋值后不可变；
  3. 常量命名规范：全大写，多个单词用下划线分隔（如MAX_SCORE）。

代码示例：

public class FinalDemo {
    // 1. 成员常量：声明时直接赋值
    public static final int MAX_SCORE = 100; // 全局常量（常用static+final）
    private final String USER_NAME; // 成员常量，构造方法中赋值

    // 构造方法中给final成员变量赋值
    public FinalDemo(String userName) {
        this.USER_NAME = userName; // 只能赋值一次
    }

    public void testFinalVar() {
        // 2. 局部常量：声明后赋值，且只能赋值一次
        final int age;
        age = 18;
        // age = 20; // 报错：final变量赋值后不可修改

        System.out.println(MAX_SCORE); // 输出100
        System.out.println(USER_NAME); // 输出构造方法传入的值
    }

    public static void main(String[] args) {
        FinalDemo demo = new FinalDemo("张三");
        demo.testFinalVar();
        // FinalDemo.MAX_SCORE = 90; // 报错：常量不可修改
    }
}

2. 修饰方法：禁止子类重写

  • 被final修饰的方法，子类不能重写（防止核心逻辑被篡改）。

代码示例：

class Parent {
    public final void sayHello() {
        System.out.println("你好");
    }
}

class Child extends Parent {
    // @Override // 报错：无法重写final方法
    // public void sayHello() {}
}

3. 修饰类：禁止被继承

  • 被final修饰的类，不能有子类（比如 Java 自带的String类就是 final 的，保证字符串不可变）。

代码示例：

final class FinalClass {}
// class SubClass extends FinalClass {} // 报错：无法继承final类

核心总结

final的核心是 “不可变”：

  1. 变量→常量（赋值后不能改）；
  2. 方法→不能被重写；
  3. 类→不能被继承。

二、单例设计模式

单例模式是 Java 最常用的设计模式之一，核心目标：让一个类在程序运行期间，只能创建一个对象。

常见的单例模式有两种实现方式：饿汉式、懒汉式。

1. 饿汉式单例：“饿了就先吃”（立即加载）

  • 类加载时就创建好实例，不管后续是否使用（优点：线程安全；缺点：可能浪费内存）。

代码示例：

// 饿汉式单例
public class HungrySingleton {
    // 1. 私有构造方法：禁止外部new对象
    private HungrySingleton() {}

    // 2. 类加载时就创建唯一实例（静态变量）
    private static final HungrySingleton INSTANCE = new HungrySingleton();

    // 3. 提供公共方法获取实例
    public static HungrySingleton getInstance() {
        return INSTANCE;
    }

    // 测试方法
    public void sayHi() {
        System.out.println("饿汉式单例：我是唯一的实例");
    }

    public static void main(String[] args) {
        // 获取两个实例，判断是否是同一个
        HungrySingleton s1 = HungrySingleton.getInstance();
        HungrySingleton s2 = HungrySingleton.getInstance();
        System.out.println(s1 == s2); // 输出true：同一个对象
    }
}

2. 懒汉式单例：“需要时再吃”（延迟加载）

  • 类加载时不创建实例，只有第一次调用getInstance()时才创建（优点：节省内存；缺点：基础版非线程安全）。

代码示例：

// 懒汉式单例（基础版，非线程安全）
public class LazySingleton {
    // 1. 私有构造方法
    private LazySingleton() {}

    // 2. 声明实例变量，初始为null
    private static LazySingleton INSTANCE = null;

    // 3. 调用时才创建实例
    public static LazySingleton getInstance() {
        if (INSTANCE == null) { // 为空才创建
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }

    public void sayHi() {
        System.out.println("懒汉式单例：我是唯一的实例");
    }

    public static void main(String[] args) {
        LazySingleton s1 = LazySingleton.getInstance();
        LazySingleton s2 = LazySingleton.getInstance();
        System.out.println(s1 == s2); // 输出true
    }
}

饿汉式 vs 懒汉式

特性饿汉式懒汉式
加载时机类加载时创建第一次调用时创建
线程安全安全不安全
内存占用启动时占用，可能浪费按需加载，更节省

三、枚举

枚举（enum）是 Java 5 新增的特性，本质是 “特殊的类”，用于定义一组固定的、有限的常量，相比普通常量更安全、更易读。

1. 认识枚举类

  • 用enum关键字声明，里面的每个值都是枚举类的实例（默认public static final）。

代码示例：

// 定义枚举类：季节
public enum Season {
    // 枚举常量（每个都是Season的实例）
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "烈日炎炎"),
    AUTUMN("秋天", "秋高气爽"),
    WINTER("冬天", "寒风刺骨");

    // 枚举类的成员变量（自定义属性）
    private final String name;
    private final String desc;

    // 枚举的构造方法：必须私有（默认也是私有）
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    // 提供get方法（枚举常量不可修改，无需set）
    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    // 测试枚举
    public static void main(String[] args) {
        // 1. 直接使用枚举常量
        Season spring = Season.SPRING;
        System.out.println(spring.getName()); // 输出：春天
        System.out.println(spring.getDesc()); // 输出：春暖花开

        // 2. 遍历所有枚举常量
        for (Season season : Season.values()) {
            System.out.println(season + "：" + season.getDesc());
        }

        // 3. 枚举的switch用法（更简洁）
        switch (spring) {
            case SPRING:
                System.out.println("当前是春天");
                break;
            case SUMMER:
                System.out.println("当前是夏天");
                break;
            // 其他case...
        }
    }
}

2. 枚举的应用场景

  1. 固定状态：订单状态（待支付、已支付、已取消）、用户状态（正常、禁用、锁定）；
  2. 有限选项：星期（周一到周日）、季节、性别；
  3. 替代常量：相比public static final int SPRING = 1，枚举更安全，不会传错值；
  4. 实现单例：枚举是实现单例的最佳方式。

四、抽象类

抽象类用abstract关键字声明，是 “不完整的类”—— 里面可以包含抽象方法（只有声明，没有实现） 和普通方法，核心作用是 “定义模板，让子类实现细节”。

1. 抽象类的基本规则

  1. 抽象类不能被实例化（不能new），只能被继承；
  2. 包含抽象方法的类，必须是抽象类；
  3. 子类继承抽象类后，必须实现所有抽象方法（除非子类也是抽象类）。

代码示例：

// 抽象类：动物
public abstract class Animal {
    // 普通方法（有实现）
    public void breathe() {
        System.out.println("所有动物都要呼吸");
    }

    // 抽象方法（只有声明，没有实现）
    public abstract void makeSound();
}

// 子类：狗（实现抽象方法）
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("小狗汪汪叫");
    }
}

// 子类：猫（实现抽象方法）
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("小猫喵喵叫");
    }
}

// 测试
class TestAnimal {
    public static void main(String[] args) {
        // Animal animal = new Animal(); // 报错：抽象类不能实例化
        Animal dog = new Dog();
        dog.breathe(); // 输出：所有动物都要呼吸
        dog.makeSound(); // 输出：小狗汪汪叫

        Animal cat = new Cat();
        cat.makeSound(); // 输出：小猫喵喵叫
    }
}

2. 抽象类的好处

  1. 代码复用：抽象类中的普通方法可以被所有子类复用（比如上面的breathe()）；
  2. 约束子类：抽象方法强制子类实现核心逻辑（比如所有动物都要实现makeSound()，保证子类有统一的行为）；
  3. 定义骨架：结合 “模板方法模式”，固定核心流程，子类只改细节。

3. 模板方法设计模式

  • 抽象类定义一个 “模板方法”，流程中的可变步骤交给子类实现。

代码示例：

// 抽象类：饮品制作模板
public abstract class DrinkTemplate {
    // 模板方法：固定制作流程（final防止子类修改）
    public final void makeDrink() {
        boilWater(); // 步骤1：烧水（固定）
        brew(); // 步骤2：冲泡（可变，子类实现）
        pourInCup(); // 步骤3：倒入杯中（固定）
        addCondiments(); // 步骤4：加调料（可变，子类实现）
    }

    // 固定方法：烧水
    private void boilWater() {
        System.out.println("烧开水（100℃）");
    }

    // 固定方法：倒入杯中
    private void pourInCup() {
        System.out.println("将饮品倒入杯中");
    }

    // 抽象方法：冲泡（子类实现）
    public abstract void brew();

    // 抽象方法：加调料（子类实现）
    public abstract void addCondiments();
}

// 子类：制作咖啡
class Coffee extends DrinkTemplate {
    @Override
    public void brew() {
        System.out.println("冲泡咖啡粉");
    }

    @Override
    public void addCondiments() {
        System.out.println("加牛奶和糖");
    }
}

// 子类：制作茶
class Tea extends DrinkTemplate {
    @Override
    public void brew() {
        System.out.println("冲泡茶叶");
    }

    @Override
    public void addCondiments() {
        System.out.println("加柠檬");
    }
}

// 测试
class TestDrink {
    public static void main(String[] args) {
        DrinkTemplate coffee = new Coffee();
        System.out.println("制作咖啡：");
        coffee.makeDrink(); // 按模板流程制作咖啡

        System.out.println("========");

        DrinkTemplate tea = new Tea();
        System.out.println("制作茶：");
        tea.makeDrink(); // 按模板流程制作茶
    }
}

输出结果：

制作咖啡：
烧开水（100℃）
冲泡咖啡粉
将饮品倒入杯中
加牛奶和糖
========
制作茶：
烧开水（100℃）
冲泡茶叶
将饮品倒入杯中
加柠檬

抽象类的应用场景

  1. 多个类有共同的核心流程，但细节不同（比如上面的饮品制作）；
  2. 需要定义统一的父类，约束子类的行为，但又不想让父类被实例化；
  3. 代码复用 + 行为约束的场景。

五、接口

接口（interface）是 Java 中 “纯抽象” 的规范，核心作用是定义契约（规则），让实现类遵守规则，是实现 “多态” 和 “解耦” 的核心。

1. 认识接口

  1. 用interface关键字声明；
  2. JDK8 前：只能包含public static final常量 + public abstract方法；
  3. JDK8 后：新增默认方法、静态方法、私有方法；
  4. 类用implements实现接口，必须实现所有抽象方法（除非是抽象类）。

代码示例：

// 定义接口：跑
public interface Runable {
    // 接口中的常量（默认public static final）
    int MAX_SPEED = 100;

    // 抽象方法（默认public abstract）
    void run();
}

// 实现类：人
class Person implements Runable {
    @Override
    public void run() {
        System.out.println("人用双腿跑，最高速度：" + MAX_SPEED);
    }
}

// 实现类：汽车
class Car implements Runable {
    @Override
    public void run() {
        System.out.println("汽车用轮子跑，最高速度：" + MAX_SPEED);
    }
}

// 测试
class TestRunable {
    public static void main(String[] args) {
        Runable person = new Person();
        person.run(); // 输出：人用双腿跑，最高速度：100

        Runable car = new Car();
        car.run(); // 输出：汽车用轮子跑，最高速度：100
    }
}

2. 接口的好处

  1. 解耦：接口定义规则，实现类负责实现，修改实现类不影响调用方；
  2. 多实现：Java 类只能单继承，但可以实现多个接口（弥补单继承的不足）；
  3. 标准化：统一接口，不同实现类遵循同一规则；
  4. 多态：接口引用指向实现类对象，提高代码灵活性。

3. JDK8 新增的三个方法

  • JDK8 为接口新增了 3 种方法，让接口更灵活（不用强制所有实现类修改）：
方法类型关键字特点
默认方法default有方法体，实现类可重写，也可直接使用
静态方法static有方法体，只能通过接口名调用（不能被实现类重写）
私有方法private有方法体，只能在接口内部调用（供默认方法 / 静态方法复用）

代码示例：

public interface JDK8Interface {
    // 1. 抽象方法
    void abstractMethod();

    // 2. 默认方法
    default void defaultMethod() {
        System.out.println("接口默认方法");
        privateMethod(); // 调用私有方法
    }

    // 3. 静态方法
    static void staticMethod() {
        System.out.println("接口静态方法");
        privateStaticMethod(); // 调用私有静态方法
    }

    // 4. 私有方法（非静态）
    private void privateMethod() {
        System.out.println("接口私有方法：供默认方法复用");
    }

    // 5. 私有静态方法
    private static void privateStaticMethod() {
        System.out.println("接口私有静态方法：供静态方法复用");
    }
}

// 实现类
class JDK8Impl implements JDK8Interface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }

    // 可选：重写默认方法
    @Override
    public void defaultMethod() {
        System.out.println("重写接口的默认方法");
    }
}

// 测试
class TestJDK8Interface {
    public static void main(String[] args) {
        JDK8Interface impl = new JDK8Impl();
        impl.abstractMethod(); // 输出：实现抽象方法
        impl.defaultMethod(); // 输出：重写接口的默认方法

        // 静态方法只能通过接口名调用
        JDK8Interface.staticMethod(); // 输出：接口静态方法 + 接口私有静态方法
    }
}

4. 接口的注意事项

  1. 接口不能被实例化（不能new）；
  2. 接口的成员：
    • 变量：默认public static final（必须初始化）；
    • 方法（JDK8 前）：默认public abstract；
  3. 一个类可以实现多个接口（用逗号分隔）；
  4. 接口可以继承多个接口（用extends）；
  5. 默认方法冲突：如果实现类同时实现两个接口，且接口有同名默认方法，必须重写该方法。

接口 vs 抽象类

特性抽象类接口
关键字abstract classinterface
继承 / 实现类用 extends 单继承类用 implements 多实现
方法可包含抽象方法 + 普通方法JDK8 前：只有抽象方法；JDK8 后：可包含默认 / 静态 / 私有方法
成员变量可定义任意变量只能是 public static final 常量
构造方法有构造方法（不能实例化）无构造方法
核心作用代码复用 + 定义骨架定义契约 + 解耦
使用场景子类有共同的父类，共享代码不同类需要遵守同一规则，解耦

总结

  1. final：修饰变量→常量、修饰方法→不可重写、修饰类→不可继承；
  2. 单例模式：饿汉式（立即加载，线程安全）、懒汉式（延迟加载，基础版非线程安全），核心是保证类只有一个实例；
  3. 枚举：定义固定常量集，类型安全，适合状态 / 选项类场景；
  4. 抽象类：包含抽象方法，不能实例化，模板方法模式是经典应用，核心是 “骨架 + 可变细节”；
  5. 接口：定义契约，支持多实现，JDK8 新增默认 / 静态 / 私有方法，和抽象类的核心区别是 “契约 vs 复用”。
标签
#开发语言 #java #算法
【SpringBoot 3.x 第268节】夯爆了，测试、观测、Starter 封装与生产级最佳实践（超详解）！
**My Coding Family**
05-30 1万+
🏆本文收录于《滚雪球学SpringBoot 3.x》，专门攻坚指数提升，本年度国内最系统+最专业+最详细（永久更新）。
Qwen 三代进化全景对比：从 Qwen2.5 到 Qwen3 再到 Qwen3.5
m0_47999117的博客
03-03 1万+
本文对比了阿里巴巴通义千问三代大模型（Qwen2.5、Qwen3、Qwen3.5）的技术演进。18个月内，模型在架构、训练数据和能力上实现显著突破：从纯稠密结构（Qwen2.5）发展为混合注意力架构（Qwen3.5），支持语言从29种扩展至201种，并实现原生多模态融合。关键进展包括引入MoE架构、Gated DeltaNet混合注意力机制（计算效率提升10倍）、以及从独立模态到早期视觉语言联合训练的转变。模型阵容从7个通用尺寸发展为8+个混合架构，最大参数量达397B，上下文窗口扩展至256K（托管版1M
Java 入门必学：final、单例、枚举、抽象类、接口
likuolei的博客
03-18 332
/ 抽象方法System.out.println("睡觉");final→ 限制（不能改/不能继承）单例→ 控制对象数量枚举→ 固定常量集合（更安全）抽象类→ “是什么”（is-a）接口→ “能做什么”（can-do）接口定能力，抽象类做模板，枚举管常量，单例控实例，final保约束如果你想继续深入，我可以帮你👇✅ 出一套「面试高频考题（final/接口/单例）」✅ 或做「设计模式入门（含代码实战）」✅ 或带你写一个“小项目综合应用这些知识点”
图像的低频，中频，高频信息含义？
热门推荐
jinking01的专栏
09-02 3万+
看很多图像处理的博文，都会说图像的主要成分是低频信息，它形成了图像的基本灰度等级，对图像结构的决定作用较小；中频信息决定了图像的基本结构，形成了图像的主要边缘结构；高频信息形成了图像的边缘和细节，是在中频信息上对图像内容的进一步强化。我有点纳闷，图像不就是一堆像素点构成的三维矩阵吗？跟频率有啥关系！ 针对这个问题，又查了不少网文，解释的也都各不相同。例如， “初学的时候，你可以把高中低这个度量和图像上相邻点的灰度差大小对等起来”。 “感性上来讲，图像越杂乱的部分，频率越高...
Java：（学习笔记）三、面向对象-基础
qq_44125436的博客
02-10 1076
Java：（学习笔记）三、面向对象-基础、 面向对象和面向过程、 构造器、 代码块、 相关语法、 关键字、 权限修饰符
r2dbc-mysql 自定义 Codec 扩展：手写 JSON 编解码器的完整教程
gitblog_01010的博客
08-16 362
r2dbc-mysql 是一个基于 R2DBC 规范的 MySQL 响应式驱动，内置了丰富的数据类型编解码器，但当面对 JSON、枚举对象、自定义业务类型等场景时，你常常需要**自定义 Codec 扩展**。本教程将以手写一个 JSON 编解码器为例，带你完整掌握 r2dbc-mysql 扩展机制的原理与实战步骤，让普通用户也能轻松为驱动"插上"自己的类型转换能力。 ## 为什么需要自定义 Co
Java八股文全解析：从集合JVM到并发中间件，构建扎实技术地基
weixin_34241036的博客
08-28 365
在Java技术面试中，集合框架、JVM内存模型、并发编程与消息中间件是绕不开的高频考点。理解HashMap底层扩容机制、JVM垃圾回收算法与线程池核心参数，不仅是应对面试的关键，更是排查线上OOM、性能调优的实战基础。从面向对象三大特性到Kafka百万并发背后的顺序写、页缓存与零拷贝设计，系统梳理这些知识能帮助开发者建立结构化技术索引，避免死记硬背。同时，掌握冒泡排序、快速排序等手写算法以及JDK环境变量配置、Lombok编译报错等实操排错能力，才能真正做到基础与项目经验互相验证。本文围绕Java八股知识体
现代C++11/14/17
qq_51496998的博客
05-29 324
读完本专栏的好处：C++方面的面试不再是困难，找个好工作还是可以的。对于现代特性也可以熟练使用。项目代码无障碍阅读。以下内容会按照重要程度分级，按照星级大胆跳过就行，绝大部分你用不到。0~3星(注意，程序员的世界是从0开始计数的)0星：不知道也无所谓1星：对于刚入职场的新人这东西都不重要。如果你是新人不用看这些东西。2星：需要了解，至少能看懂。3星：需要掌握，工作百分百遇到。注意星级不是难度😀。零、正篇前杂谈。1.1、被弃用的特性。(2✳)只说实际工作中才会涉及到的内容。
【AI Agent】2026年9月 AI Agent 全栈开发最新技术面试宝典（含高频+必背+大厂真题）
小江的记录本
06-04 4280
本文整理了2026年AI Agent全栈开发最新技术面试题，涵盖基础概念、核心框架和系统设计等关键领域。重点解析了AI Agent与普通Chatbot的本质区别（自主闭环执行能力）、Agentic Loop的完整工作流程（规划-执行-观察-评估循环），以及ReAct范式的原理与适用场景。特别强调面试回答技巧：需结合工程实践中的典型问题、处理方案和量化指标，而非简单背诵定义。内容来自字节、阿里等大厂真实面经，适合3-5年经验开发者准备春招面试，突出考察候选人在复杂场景下的技术决策能力。
Colab Kaggle 防断开脚本
jianpeng的工程笔记
09-08 5181
Colab 防断开 鼠标右键，检查，在console先输入如下代码 function ConnectButton(){ console.log("Connect pushed"); document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click() } setInterval(ConnectButton,60000); 过几秒钟再输入如
解决 Activiti UEL 表达式解析异常 TreeBuilderException
小李同学的博客
09-15 458
在Activiti工作流中，排他/包容网关条件表达式因嵌套${}导致UEL解析失败，抛出TreeBuilderException。根源在于UEL语法禁止表达式内再次使用${}，且需避免XML特殊字符干扰。解决方案包括：移除内部定界符、使用CDATA包裹表达式、确保返回布尔值。建议通过正则扫描、IDE插件校验、编码规范（如单引号字符串、复杂逻辑外置）及测试验证，从源头预防此类问题。
JVM 垃圾回收机制详解：从标记过程、回收算法到垃圾收集器
最新发布
加油,量变引起质变
09-19 393
本文系统梳理 JVM 垃圾回收机制，讲解堆内存分区、GC Roots 可达性分析，详解标记‑清除、复制、标记‑整理三大基础回收算法，对比 Serial、Parallel、CMS、G1、ZGC 多款垃圾收集器，分析各自优缺点与适用场景，帮助开发者吃透 GC 底层原理，理解内存管理，提升 Java 性能调优能力。
Java EE 进阶：3.SpringBoot 快速上手（第一弹）：配置环境
要努力去发光，而不是被照亮~
09-19 218
Java EE 进阶：3.SpringBoot 快速上手（第一弹）：配置环境
基于Spring AI 的智能聊天机器人
Qq121363Aa的博客
09-19 159
该项目使用最新的Spring AI 2.0.x ，从零开始搭建智能体；文章提到有些代码可使用多种方式书写，这些不同的书写方式都是从Spring AI官方得来，自己也实践了。
[071][验证码模块]基于Spring拦截器的验证码认证设计思想
杨运交的博客
09-14 326
本文介绍基于Spring拦截器的验证码认证设计，通过@CaptchaAuth注解与CaptchaAuthHandlerInterceptor实现声明式验证码校验。结合工厂模式支持多类型验证码（图形、短信等），解耦业务逻辑，提升复用性与可扩展性。方案遵循单一职责与开闭原则，无侵入式集成Spring生态，配合全局异常处理器统一响应错误，适用于登录、支付等高安全场景。
jquick-pdf 核心原理解析：基于 HTML 模板动态渲染 PDF 的实现逻辑
PaoHaiJiao的博客
09-16 518
六层链路是排错地图：读入、解析、变量绑定、布局与分页、渲染输出、结果返回，异常先分层再定位。二分删减是最实用的定位手段：先保留标题与一段文字，再逐项恢复表格、绑定值与分页节点。显式分页与自然分页必须分开回归；只是分页提示，不是绝对约束。适用边界与常见误区：jquick-pdf 位于“模板抽象”与“纯 Java 部署”之间，适合规则明确的业务文档，不适合依赖脚本与完整浏览器布局的页面；它与 iText、PdfBox 不是替代关系，后两者在底层控制上更强。
GitLab+Jenkins CI-CD自动化部署实战
2301_78547133的博客
09-16 294
本文记录了团队基于GitLab与Jenkins搭建CI/CD流水线的实战过程。通过制定Git Flow分支规范（如master/develop保护分支、MR审核机制），实现代码质量管控；利用Jenkins配置Git拉取、Maven构建、SSH部署及邮件通知，完成“推送即构建、构建即部署”的自动化流程。针对开发与生产环境采用不同触发策略（自动/手动），并集成备份与回滚脚本保障发布安全。全文涵盖环境搭建、插件配置、常见坑点及面试高频问题，为DevOps实践提供完整参考。
Spring Boot 多数据源实战：让不同 Mapper 走不同数据源
KevinChen2019的博客
09-18 202
适合需要运行时动态切换数据源的场景，比如读写分离、按租户切换。让不同 Mapper 走不同数据源，核心是让每个 Mapper 绑定到独立的 SqlSessionFactory。如果业务库之间完全独立、互不切换，推荐方案一，简单直观；如果需要运行时动态切换（如读写分离），推荐方案二。实际项目中也可以两者结合：静态分包 + 动态路由兜底。
基于springboot+vue的学生信息管理系统的设计与实现 源码+文档
大学生毕设选题 / 源码文档 → 置顶文章名片交流
09-15 227
本文分享基于SpringBoot3+Vue3的高校选课管理系统项目，涵盖管理员、教师、学生多角色功能，实现课程管理、选课审批、成绩录入、考勤登记及通知公告等。技术栈为Vue3、ElementPlus、ECharts、SpringBoot3、MyBatis-Plus、SpringSecurity与MySQL。提供源码、数据库、万字文档、答辩PPT及部署指导，支持定制开发与持续技术答疑。获取方式见置顶链接（点我进入）。
de风——【从零开始学C++】（二十）红黑树封装map和set
Xiao_running的博客
09-16 575
本文从零实现C++中set与map的封装，核心在于利用泛型与红黑树共用底层结构。通过KeyOfT仿函数统一比较逻辑，确保仅按key排序；借助const修饰使key不可修改，保障数据结构有序性；结合迭代器实现范围遍历，并通过Insert返回pair<iterator, bool>支持map的operator[]功能。最终完成mymap与myset的完整封装，揭示其本质为“红黑树+泛型外壳”，帮助新手彻底理解容器底层机制。
Java 编译、JDK 与 Android 构建入口
trebleZ的博客
09-14 414
Android 项目中的 Java 源码先由 JDK 的 javac 编译成 class，AGP 在 Gradle 任务图里组织后续 Android 构建工作，D8 把字节码转成 dex 并打进 APK。安装后系统启动应用进程，ART 通过类加载器解析 APK 中的 dex，ActivityThread 在绑定应用时经 LoadedApk 和 Instrumentation 创建 Application。所以 Gradle 配置属于构建期，Application.onCreate() 属于运行期；R8 是否
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值