个人简历面试复习-----设计模式篇（一）

1.责任链模式

2.策略模式

3.单例模式

[1. 饿汉式（最简单，线程安全，推荐新手）](#1. 饿汉式（最简单，线程安全，推荐新手）)

[2. 懒汉式（用的时候才创建，节省资源）](#2. 懒汉式（用的时候才创建，节省资源）)

[3. 静态内部类（最优雅、最推荐）](#3. 静态内部类（最优雅、最推荐）)

1.责任链模式

把多个处理步骤串成一条链，请求从第一个开始往后传，每个步骤只干自己的事，干完传给下一个；失败就中断，成功就继续。

核心结构（只有 3 个角色）

抽象处理器（Handler） 定义统一的处理方法，持有下一个处理器。
**具体处理器（A、B、C...）**真正干活的，比如：校验用户 → 扣奖品 → 更新活动。
客户端（Client） 把处理器串成一条链，然后发起请求。

抽奖请求 → 校验人员状态 → 变更奖品状态 → 变更活动状态

奖品不变更成功，活动就不执行。

代码示例：

复制代码

// 请假请求
class LeaveRequest {
    int days; // 请假天数
    public LeaveRequest(int days) { this.days = days; }
}

// 抽象处理者（领导）
abstract class Leader {
    protected Leader next; // 下一个领导

    public void setNext(Leader next) { this.next = next; }
    public abstract void handle(LeaveRequest req);
}

// 组长：处理 ≤1 天
class GroupLeader extends Leader {
    public void handle(LeaveRequest req) {
        if (req.days <= 1) {
            System.out.println("组长审批：请假" + req.days + "天，通过");
        } else if (next != null) {
            System.out.println("组长无权，交给经理");
            next.handle(req);
        }
    }
}

// 经理：处理 ≤3 天
class Manager extends Leader {
    public void handle(LeaveRequest req) {
        if (req.days <= 3) {
            System.out.println("经理审批：请假" + req.days + "天，通过");
        } else if (next != null) {
            System.out.println("经理无权，交给老板");
            next.handle(req);
        }
    }
}

// 老板：处理所有
class Boss extends Leader {
    public void handle(LeaveRequest req) {
        System.out.println("老板审批：请假" + req.days + "天，通过");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Leader group = new GroupLeader();
        Leader manager = new Manager();
        Leader boss = new Boss();

        // 构建责任链：组长 → 经理 → 老板
        group.setNext(manager);
        manager.setNext(boss);

        // 测试请假 4 天
        group.handle(new LeaveRequest(4));
    }
}

这就是标准责任链。

2.策略模式

同一个行为，有多种不同的实现方案，你可以随时切换方案，只执行其中一个。

就像：你要出门，可以选：开车、地铁、飞机 ------ 一次只选一种，随时换。

就像：你要支付，可以选：微信、支付宝、银行卡 ------ 想换就换。

复制代码

// 1. 策略接口：定义规则
interface Pay {
    void pay();
}

// 2. 具体策略A：微信支付
class WeChatPay implements Pay {
    public void pay() {
        System.out.println("微信支付");
    }
}

// 3. 具体策略B：支付宝支付
class AliPay implements Pay {
    public void pay() {
        System.out.println("支付宝支付");
    }
}

// 4. 上下文：切换策略
class PayContext {
    private Pay pay;

    // 想换哪种支付，传进来就行
    public PayContext(Pay pay) {
        this.pay = pay;
    }

    public void doPay() {
        pay.pay();
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        // 用支付宝
        PayContext context = new PayContext(new AliPay());
        context.doPay();

        // 切换成微信
        context = new PayContext(new WeChatPay());
        context.doPay();
    }
}

3.单例模式

一个类，全局只能创建唯一一个对象，无论在哪调用，都是同一个实例

构造方法私有（别人不能 new）

自己创建唯一实例

提供全局访问点（给外面用）

全局只有一个对象

1. 饿汉式（最简单，线程安全，推荐新手）

上来就创建对象，不管你用不用，绝对线程安全。

复制代码

// 单例类
public class Singleton {
    // 1. 自己创建唯一实例
    private static final Singleton INSTANCE = new Singleton();

    // 2. 构造方法私有！禁止外部 new
    private Singleton() {}

    // 3. 全局获取唯一实例
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

// 使用
public class Test {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true → 同一个对象
    }
}

2. 懒汉式（用的时候才创建，节省资源）

双重校验锁（DCL），企业最常用

复制代码

public class Singleton {
    private static volatile Singleton INSTANCE;

    private Singleton() {}

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

3. 静态内部类（最优雅、最推荐）

懒加载 + 线程安全 + 代码简洁

复制代码

public class Singleton {
    private Singleton() {}

    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}