请教：我实现的两种门是否违反了里氏替换原则（LSP）？

嘿，我帮你把这段代码整理得更规范，还补全了没写完的RegularDoor实现，同时给LockedDoor补充了必要的锁逻辑，让整个代码更完整可运行：

首先是定义所有门的基础契约——Door接口，它规定了门必须具备的核心行为：

public interface Door {
    void open();
    void close();
}

不带锁的普通门（RegularDoor） #

普通门没有额外限制，直接维护开关状态即可，我补全了它的实现：

public class RegularDoor implements Door {
    private boolean isOpen;

    @Override
    public void open() {
        this.isOpen = true;
        System.out.println("普通门已打开");
    }

    @Override
    public void close() {
        this.isOpen = false;
        System.out.println("普通门已关闭");
    }

    // 方便外部查询门的状态
    public boolean isOpen() {
        return isOpen;
    }
}

带锁的门（LockedDoor） #

你原来的代码里用到了Lock但没定义，我补充了一个基础的Lock接口和实现，同时优化了LockedDoor的逻辑——比如关门后自动上锁，解锁才能开门，还增加了状态提示让行为更清晰：

// 定义锁的行为接口
public interface Lock {
    boolean isLocked();
    void lock();
    void unlock();
}

// 基础锁实现
public class BasicLock implements Lock {
    private boolean locked = true; // 默认初始上锁

    @Override
    public boolean isLocked() {
        return locked;
    }

    @Override
    public void lock() {
        this.locked = true;
        System.out.println("锁已上锁");
    }

    @Override
    public void unlock() {
        this.locked = false;
        System.out.println("锁已解锁");
    }
}

// 带锁的门实现
public class LockedDoor implements Door {
    private Lock lock;
    private boolean isOpen;

    // 通过构造方法注入锁，方便替换不同锁实现（比如密码锁、指纹锁）
    public LockedDoor(Lock lock) {
        this.lock = lock;
        this.isOpen = false;
    }

    @Override
    public void open() {
        if (!lock.isLocked()) {
            this.isOpen = true;
            System.out.println("带锁的门已打开");
        } else {
            System.out.println("门处于上锁状态，无法打开");
        }
    }

    @Override
    public void close() {
        this.isOpen = false;
        lock.lock(); // 关门后自动上锁，符合日常使用逻辑
        System.out.println("带锁的门已关闭并自动上锁");
    }

    // 暴露锁的操作方法，让外部可以解锁/上锁
    public void unlockDoor() {
        lock.unlock();
    }

    public void lockDoor() {
        lock.lock();
    }

    public boolean isOpen() {
        return isOpen;
    }
}

一些小优化说明： #

• 用依赖注入给LockedDoor传入锁，而不是在类内部创建，这样后续可以轻松替换成不同的锁实现，符合开闭原则；
• 增加了状态打印语句，方便调试和直观看到门的状态变化，实际项目中可以换成日志框架输出；
• 完善了边界逻辑，比如锁着的门无法打开，关门后自动上锁，更贴近真实场景。

内容的提问来源于stack exchange，提问作者JacobKreynin