Как соблюдать принцип единой ответственности в этой ситуации, используя 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> {
    //...
}