Question

我们假设我有三个频道（它们只是一个概念而不是一个类）：A，B，C。

每个频道都有一些我想要处理的对象，它们之间是不同的。让我们来说：

频道A有A1，A2和A3。
频道B有B1，B2和B3。
频道C有C1，C2和C3。

所有频道都有一个共同的save方法来存储这些对象。

我的方法是使用所有通道方法的接口ATaskProcessor：

a1Process(arguments) a2Process(arguments) a3Process(arguments)
b1Process(arguments) b2Process(arguments) b3Process(arguments)
c1Process(arguments) c2Process(arguments) c3Process(arguments)

然后实现该接口，实现所有这些方法，并使用公共save来存储处理的对象。我需要为每个对象使用不同的进程，但我使用相同的save。

该方法的目标是对所有对象重用相同的save方法，但这不尊重单一责任原则，并且不可扩展。

我考虑过将不同包中的频道分开，这会减少我的课程代码，但我会重复编码而且我也不会尊重这个原则。

我怎样才能尊重单一责任原则并重复尽可能少的代码？

示例：

public interface ATaskProcessor {

  void a1Process(arguments);
  void a2Process(arguments);
  void a3Process(arguments);

  void b1Process(arguments);
  void b2Process(arguments);
  void b3Process(arguments);

  void c1Process(arguments);
  void c2Process(arguments);
  void c3Process(arguments);

}

public class taskProcessor implements ATaskProcessor {

  void a1Process(arguments){ ... }
  void a2Process(arguments){ ... }
  void a3Process(arguments){ ... }

  void b1Process(arguments){ ... }
  void b2Process(arguments){ ... }
  void b3Process(arguments){ ... }

  void c1Process(arguments){ ... }
  void c2Process(arguments){ ... }
  void c3Process(arguments){ ... }

  void save() { ... }
}

感谢。

Answer 1

这确实取决于A，B和C，以及1,2和3之间的关系（A1和B1有点相同吗？）

但如果我做了一些假设，解决这个问题的一种方法是通过继承和泛型：

public abstract class Task { }
public class A extends Task { }
public class B extends Task { }
public class C extends Task { }

public <T extends Task> interface TaskProcessor<T> {
    process1(T task);
    process2(T task);
    process3(T task);
}

public class AProcessor implements TaskProcessor<A> {
    //...
}

public class BProcessor implements TaskProcessor<B> {
    //...
}

public class CProcessor implements TaskProcessor<C> {
    //...
}

然后，如果你想引入另一个任务类型D，你只需要：

public class D extends Task {}
public class DProcessor implements TaskProcessor<D> {
    //...
}

如何在这种情况下使用java来尊重单一责任原则？

1 个答案: