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

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> {
    //...
}