创建接口具体实现类的正确模式：自定义工厂方案是否合理？

你的当前方案是正确且完全符合需求的，它完美实现了以下目标：

• 将FooImplA、FooImplB隐藏为包私有，客户端无法直接依赖具体实现类
• 通过工厂类对外提供实例创建入口，同时适配了不同实现类的构造参数差异

现有方案的优势 #

• 封装性良好：客户端仅需依赖Foo接口和FooFactory，后续修改实现类的内部逻辑甚至替换实现类，都不会影响客户端代码
• 直观易维护：每个工厂方法对应一个实现类，参数列表与实现类构造器一一对应，代码可读性高，新增实现类时只需新增对应工厂方法即可

更优替代方案 #

1. 接口静态工厂方法（Java 8+） #

无需单独创建FooFactory类，直接在Foo接口中定义静态工厂方法，进一步简化结构：

public interface Foo {
    void doSomething();

    // 创建FooImplA的静态方法
    static Foo createFooA(String prop1, Integer prop2) {
        return new FooImplA(prop1, prop2);
    }

    // 创建FooImplB的静态方法
    static Foo createFooB(String prop1) {
        return new FooImplB(prop1);
    }
}

客户端调用时直接通过Foo.createFooA("xxx", 123)获取实例，减少类的数量，接口作为单一入口更符合设计直觉。

2. 参数对象+工厂方法（适合复杂参数场景） #

如果后续实现类的构造参数增多、逻辑变复杂，可以为每个实现类定义专属参数对象，避免工厂方法参数列表过长：

// FooImplA的参数对象
public class FooImplAParams {
    private final String prop1;
    private final Integer prop2;

    private FooImplAParams(Builder builder) {
        this.prop1 = builder.prop1;
        this.prop2 = builder.prop2;
    }

    // Builder模式构建参数对象
    public static class Builder {
        private String prop1;
        private Integer prop2;

        public Builder prop1(String prop1) {
            this.prop1 = prop1;
            return this;
        }

        public Builder prop2(Integer prop2) {
            this.prop2 = prop2;
            return this;
        }

        public FooImplAParams build() {
            return new FooImplAParams(this);
        }
    }

    // getter方法
    public String getProp1() { return prop1; }
    public Integer getProp2() { return prop2; }
}

// 工厂类对应方法
public class FooFactory {
    public Foo createFooA(FooImplAParams params) {
        return new FooImplA(params.getProp1(), params.getProp2());
    }

    public Foo createFooB(String prop1) {
        return new FooImplB(prop1);
    }
}

这种方式提升了代码的可读性和安全性，避免因参数顺序错误导致的问题，适合参数较多的实现类。

3. 枚举标记+统一工厂方法（谨慎使用） #

如果实现类数量不多且参数规则较为统一，可以用枚举标记类型，提供单个工厂方法统一创建入口，但这种方式存在类型不安全的问题（需要强转参数），仅适合简单场景：

public enum FooType {
    TYPE_A, TYPE_B
}

public class FooFactory {
    public Foo createFoo(FooType type, Object... params) {
        switch (type) {
            case TYPE_A:
                return new FooImplA((String) params[0], (Integer) params[1]);
            case TYPE_B:
                return new FooImplB((String) params[0]);
            default:
                throw new IllegalArgumentException("未知的Foo类型");
        }
    }
}

总结 #

你的原始方案是最推荐的选择，尤其是在实现类数量不多、参数差异明确的场景下，它平衡了简洁性和可维护性。如果追求更精简的API，可以选择接口静态工厂方法；如果参数复杂，则优先考虑参数对象的方式。

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