Question

我想找出解决这个问题的正确设计

我有三个类Thread，Consumer和Event

public class Thread {
    private Consumer _consumer = new Consumer();
}

public class Consumer {
    private someMethod() {
        Event event = new Event();
        // do something with event 
    }
}

在我的＆＃34; main＆＃34;创建T并封装其依赖项

Thread t = new Thread();

现在设计已经改变，我们需要多个Consumer，每个Event应该构建一个不同的Consumer。所有代码都相同，因此我不需要更改public class Thread<T extends Event> { private Consumer _c = new Consumer<T>(); } public class Consumer<T extends Event> { private someMethod() { Event event = new T(); } }。

我尝试用泛型来做，因为看起来这是一种简单而干净的方式。但是，看起来似乎无法在泛型类型上使用 new 。（被C ++模板误导）

public interface IEventFactory {
    public Event create();
}

public class EventFactory implements IEventFactory{
    public Event create() {
        return new Event1();
    }
}

public class Thread {
    private Consumer _consumer;

    public Thread (IEventFactory _factory) {
        _consumer = new Consumer(_factory);
    }
}

public class Consumer {
    private IEventFactory _factory;

    public C(IEventFactory factory) {
        _factory = factory;
    }

    private someMethod() {
        Event event = _factory.create();
    }
}

我的另一个选择是通过某种编译时工厂

JSONObject object1= JSONObject(response);
JSONArray array1=object1.getJSONArray("results");
for(int i=0;i<array1.length();i++){
      JSONObject object2=array1.getJSONObject(i);
       JSONArray array1=object1.getJSONArray("opening_hours");
       Boolean open_now=array1.getString("open_now");
}

这种解决方案感觉不那么优雅，一直通过工厂。是否有更好，更优雅的方式接近这个？

Answer 1

工厂在这里只添加样板。您可以使用方法引用完成相同的操作：将Event的构造函数传递给Consumer的构造函数。使用Supplier功能界面执行此操作。

public class Consumer<T extends Event> {
    private final Supplier<T> eventConstructor;

    public Consumer(final Supplier<T> eventConstructor) {
        this.eventConstructor = eventConstructor;
    }

    private void someMethod() {
        final T event = eventConstructor.get();
    }
}

您可以从Thread：

传播构造函数

class Thread<T extends Event> {
    private Consumer<T> consumer;

    public Thread(final Supplier<T> eventConstructor) {
        this.consumer = new Consumer<>(eventConstructor);
    }
}

样本用法：

Thread<Event1> thr = new Thread<>(Event1::new);

如果某些事件具有构造函数参数，这也将起作用，例如：

Thread<Event2> thr2 = new Thread<>(() -> new Event2("some default"));

编译时的工厂模式

1 个答案: