java - 使用不同的构建器创建 java 子类型

Question

我有课Foo它有一个子类型SubFoo ，我有一个生成器 FooBuilder它创建了 Foo对象。

这就是Foo看起来像:

class Foo {
    protected Object superField;
}

SubFoo

class SubFoo extends Foo {
     private Object subField;
}

class FooBuilder {
 protected Object superField;

 withSuperField(Object field){
   this.superField = field;
 }

 Foo build(){
   return new Foo(superField);
 }
}

class SubFooBuilder extends FooBuilder{
 protected Object subField;

 withSubField(Object field){
   this.subField = field;
 }

 Foo build(){
   return new SubFoo(superField, subField);
 }
}

并且有一些代码可以根据某些标准创建足够的构建器。

FooBuilder create(){
 return someCriterion ? new FooBuilder() : new SubFooBuilder();
}

是否有办法或进行更改，以便构建器的客户端代码创建 Foo或SubFoo对象而不知道它使用哪个构建器？因为我不想打破Dependency inversion原理。

Answer 1

我想你想要一个Abstract factory

首先，您需要为 Foo 对象声明一个接口(interface)，我们将其称为 Foo:

public interface Foo {
    public void fooMethod();
}

其次，提供任意数量的接口(interface)实现，例如 FooImpl1 和 FooImpl2 (与您的 Foo 和 SubFoo)

public class FooImpl1 implements Foo {
    public void fooMethod() {
        //first implementation goes here
    }
}

//NOTE: this class can also extend FooImpl1, if you wish
public class FooImpl2 implements Foo {
    public void fooMethod() {
        //second implementation goes here
    }
}

接下来，声明 Foo 工厂的接口(interface):

public interface FooFactory {
    public Foo build();
}

现在您可以根据需要创建任意数量的工厂:

public class FooFactoryImpl1 implements FooFactory {
    public FooImpl1 build() {
        // create and return FooImpl1
    }
}

public class FooFactoryImpl2 implements FooFactory {
    public FooImpl2 build() {
        // create and return FooImpl2
    }
}

通过这种方法，您的客户端代码仅依赖于接口(interface)。您可以为其提供 FooFactory 的任何实现，这样客户端就无法知道到底使用的是哪个工厂，以及 Foo 对象的真正实现。