如何在类中使用接口的多种实现并隐藏具体实例？求解决方案与设计模式

当然可以实现！这是典型的「解耦实现细节与业务逻辑」的需求，咱们可以用几种成熟的设计模式来把具体实现类的创建逻辑从MyClass中抽离，彻底隐藏底层细节。下面是最常用的几种方案：

这是最直接的解决方案，专门用来封装对象的创建逻辑。你可以创建一个工厂类，由它负责生成MyInterface的具体实例，MyClass只需要和工厂、接口打交道，完全不用知道MyInterfaceA/MyInterfaceB的存在。

示例代码：

// 工厂类：封装所有实例创建逻辑
public class MyInterfaceFactory {
    public static MyInterface createInstance(String type) {
        return switch(type) {
            case "A" -> new MyInterfaceA();
            case "B" -> new MyInterfaceB();
            default -> throw new IllegalArgumentException("未知的实现类型");
        };
    }
}

// 修改后的MyClass：不再直接依赖具体实现
public class MyClass {
    public void firstMethod() {
        MyInterface instance = MyInterfaceFactory.createInstance("A");
        instance.method();
    }
    public void secondMethod() {
        MyInterface instance = MyInterfaceFactory.createInstance("B");
        instance.method();
    }
}

核心思路是「把依赖的对象从外部传入」，而不是在MyClass内部创建。这样MyClass只依赖抽象的MyInterface，完全不关心具体实现是什么。常用的注入方式有两种：

构造注入（推荐） #

在MyClass初始化时就传入所需的所有实例，适合依赖关系稳定的场景：

public class MyClass {
    private final MyInterface instanceA;
    private final MyInterface instanceB;

    // 通过构造函数注入依赖
    public MyClass(MyInterface instanceA, MyInterface instanceB) {
        this.instanceA = instanceA;
        this.instanceB = instanceB;
    }

    public void firstMethod() {
        instanceA.method();
    }
    public void secondMethod() {
        instanceB.method();
    }
}

// 在外部创建实例并注入（比如启动类、配置类中）
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass(new MyInterfaceA(), new MyInterfaceB());
        myClass.firstMethod();
        myClass.secondMethod();
    }
}

方法注入 #

如果依赖关系不需要全局持有，也可以在调用方法时传入实例：

public class MyClass {
    public void firstMethod(MyInterface instance) {
        instance.method();
    }
    public void secondMethod(MyInterface instance) {
        instance.method();
    }
}

如果你需要更灵活的实例获取方式（比如全局复用单例实例），可以用服务定位器。它相当于一个全局的「实例仓库」，MyClass从定位器中获取实例，不用关心实例的创建逻辑：

public class ServiceLocator {
    private static final Map<String, MyInterface> SERVICE_MAP = new HashMap<>();

    // 初始化服务（可放在配置类或外部加载）
    static {
        SERVICE_MAP.put("serviceA", new MyInterfaceA());
        SERVICE_MAP.put("serviceB", new MyInterfaceB());
    }

    public static MyInterface getService(String serviceName) {
        return SERVICE_MAP.get(serviceName);
    }
}

// 修改后的MyClass
public class MyClass {
    public void firstMethod() {
        MyInterface service = ServiceLocator.getService("serviceA");
        service.method();
    }
    public void secondMethod() {
        MyInterface service = ServiceLocator.getService("serviceB");
        service.method();
    }
}

这些方案都遵循依赖倒置原则：高层模块（MyClass）依赖抽象（MyInterface），而非具体实现；具体实现依赖抽象。这样不仅彻底隐藏了实现细节，还让代码更易扩展——比如新增MyInterfaceC时，只需要修改工厂/注入配置，MyClass完全不用改动。

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