Есть ли способ унифицировать методы, включающие только функциональные интерфейсы в один?

Question

У меня есть много классов, каждый из которых, реализующие GeneralInterface и, возможно, дополнительные функциональные интерфейсы:

interface GeneralInterface {} 

class MyObjectTypeOne implements GeneralInterface { /*...*/} 

class MyObjectTypeTwo implements GeneralInterface, InterOne { /*...*/} 

class MyObjectTypeThr implements GeneralInterface, InterOne, InterTwo { /*...*/} 

У меня есть список, который держит эти MyObjectTypeXXX экземпляры

class ListHolder { 

    public static List<GeneralInterface> list = new ArrayList<>(); 

    ListHolder() { 

     list.add(new MyObjectTypeOne()); 
     list.add(new MyObjectTypeTwo()); 
     list.add(new MyObjectTypeTwo()); 
     // add any number of any of the types 
    } 
} 

и 20-40 функциональные интерфейсы. Вот 2 примера:

@FunctionalInterface 
public interface InterOne { 

    boolean onInterOne(); 

    static void iterate() { 

     for (GeneralInterface obj : ListHolder.list) { 
      if (obj instanceof InterOne) { 
       if (((InterOne) obj).onInterOne()) 
        System.out.println("yes"); 
      } 
     } 
    } 
} 

и

@FunctionalInterface 
public interface InterTwo { 

    boolean onInterOne(String string); 

    static void iterate(String string) { 

     for (GeneralInterface obj : ListHolder.list) { 
      if (obj instanceof InterTwo) { 
       if (((InterTwo) obj).onInterTwo(string)) 
        System.out.println("yes"); 
      } 
     } 
    } 
} 

В разных местах в коде мне нужно вызвать различные iterate методы:

InterTwo.iterate("S"); 
InterOne.iterate(); 

Моя проблема заключается в том, что мне нужно поддерживать iterate метод для всех функциональных интерфейсов, в то время как они эффективно выполняют одно и то же: проверяя, реализует ли этот объект этот интерфейс (отбрасывает его) и вызывает его только абстрактного метода с данными аргументами.

Есть ли способ, через синтаксис или дизайн, поддерживать только один метод, который делает это? Я знаю, что с отражением есть плохой способ сделать это (я показываю это просто, чтобы показать, что я сделал свое исследование, я не хочу его):

static void iterate(Class<?> clazz, Object arg) { 

    for (GeneralInterface obj : ListHolder.list) { 
     if (clazz.isAssignableFrom(obj.getClass())) { 
      Method[] methods = clazz.getMethods(); 
      Method functional; 
      for (Method m : methods) { 
       if (m.getModifiers() == Modifier.ABSTRACT) { 
        functional = m; 
        break; 
       } 
      } 
      if ((boolean) functional.invoke(obj, arg)) // cast arg or do some other trick 
       System.out.println("yes"); 
     } 
    } 
} 

Answer 1

Я думаю, что ваш код имеет несколько точек которые нуждаются в улучшении, но я сосредоточен только на том, чтобы дать вам ответ на вашу конкретную проблему. Я думаю, что вам нужно передать этот общий метод промежуточного абстрактного класса:

abstract class MyObjectTypeAbstract { 
    abstract boolean onInter(String ... testString); 
    abstract boolean onInter(); 
    void iterate(String string) { 

     for (GeneralInterface obj : ListHolder.list) { 
      if (obj instanceof InterTwo) { 
       if (onInter(testString)) 
        System.out.println("yes"); 
      } 
     } 
    } 
    void iterate() { 

     for (GeneralInterface obj : ListHolder.list) { 
      if (obj instanceof InterTwo) { 
       if (onInter()) 
        System.out.println("yes"); 
      } 
     } 
    } 
} 

Что это делает, чтобы вы реализуете только то, что, кажется, отличается для каждого FunctionalInterface вы предоставили. Это метод onInter. Это кажется другим. Поэтому я сделал этот реферат. Остальное поделено. Я также вынул статические из методов итерации, чтобы они могли обращаться к различным реализациям метода onInter. Надеюсь, вам не понадобится эта статичность. Поэтому решение, которое я представляю, состоит в том, чтобы сделать ваши классы extendаннотация класс и реализовать интерфейсы как сейчас.