超类外观中隐藏非共有方法的实现方案问询

当然有可行的方案来解决这个问题！我来给你梳理几个实用的思路，从语言特性到设计模式都有，能彻底帮你把不该暴露的方法藏起来：

很多面向对象语言（比如Java、Kotlin）都支持包级访问权限——权限介于private和protected之间，只有同一个包内的类才能访问。你可以利用这个特性做分层封装：

• 把抽象超类Animal、相关子类（比如Cat、Dog）以及外观类AnimalManager都放在同一个核心包下，把超类里的敏感方法（比如setAge(int)）设为包级访问（Java里不写修饰符即可）。
• 把无关的子类（比如Bird）放到单独的子包中，这样它们根本看不到核心包里的包级方法。
• 外观类在内部做校验（比如猫的年龄不能超过20岁），对外只暴露安全的接口，比如setCatAge(Cat cat, int age)。

这种方式直接利用语言本身的访问控制，简单高效，不需要额外的设计技巧。

与其让超类承载所有方法，不如把不同子类的行为拆分成独立的接口，只让对应的子类实现自己需要的接口：

• 定义基础接口BasicAnimal，包含所有子类都能公开的方法：getName()、getAge()。
• 定义专属接口CatOperations，只包含Cat特有的敏感方法：setCatAge(int age)（方法名直接明确是猫的操作，避免混淆）。
• 让Cat同时实现BasicAnimal和CatOperations，而Dog只实现BasicAnimal。
• 外观类AnimalManager针对Cat的操作只接收CatOperations类型的参数，其他子类根本看不到这个接口的方法。

这种方式从类型层面就杜绝了误调用的可能——编译器直接会阻止其他子类调用不属于自己的方法，比在方法内部做校验要安全得多。

如果你的语言支持内部类（比如Java、C#），可以把敏感方法放到子类的私有内部类中，只让外观类持有内部类的引用，外部（包括其他子类）完全看不到这些方法：

比如Java的实现示例：

public abstract class Animal {
    // 只保留所有子类共享的公开方法
    public abstract String getName();
}

public class Cat extends Animal {
    // 私有内部类，封装敏感操作
    private class CatInternal {
        public void setAge(int age) {
            if (age > 20) throw new IllegalArgumentException("猫的年龄不能超过20岁");
            // 实际设置年龄的逻辑
        }
    }

    // 仅给同包的外观类提供获取内部类的入口（包级访问权限）
    CatInternal getInternal() {
        return new CatInternal();
    }

    @Override
    public String getName() {
        return "猫";
    }
}

// 外观类，同包下可以访问Cat的getInternal方法
public class AnimalManager {
    public void setCatAge(Cat cat, int age) {
        cat.getInternal().setAge(age);
    }
}

这样一来，其他子类（比如Dog）完全不知道Cat内部有CatInternal这个类，更别说调用里面的setAge方法了，彻底从根源上隐藏了敏感逻辑。

如果需要更灵活的权限管理（比如不同的外观类有不同的访问权限），可以用代理模式给子类对象生成代理，只在代理中暴露允许的方法：

• 创建代理处理器，在调用方法前做校验：如果是敏感方法且调用者不是授权的外观类，直接拒绝或抛出异常。
• 外观类返回给外部的是代理对象，而不是真实的子类对象。

这种方式不需要修改原有类的结构，适合已经存在的代码，但实现起来稍复杂，需要熟悉语言的动态代理机制。

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