1

我有一个Foo具有 subtype的类，并且我有一个创建对象SubFoo的构建器。FooBuilderFoo

这是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原则。

4

1 回答 1

1

我想你想要一个抽象工厂

首先，您需要为Foo对象声明一个接口，我们称之为Foo：

public interface Foo {
    public void fooMethod();
}

其次，提供尽可能多的接口实现，例如FooImpl1and FooImpl2（与您的Fooand相关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工厂声明一个接口：

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
    }
}

使用这种方法，您的客户端代码仅依赖于接口。您可以为它提供任何实现FooFactory，因此客户端不知道究竟正在使用哪个工厂，以及Foo对象的实际实现。

于 2019-12-13T10:51:36.203 回答