Gibt es eine Möglichkeit, Methoden mit nur funktionalen Schnittstellen zu einer zu vereinheitlichen?

Question

ich viele Klassen haben, die jeweils Umsetzung GeneralInterface und möglicherweise zusätzliche funktionale Schnittstellen:

interface GeneralInterface {} 

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

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

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

Ich habe eine Liste, die diese MyObjectTypeXXX Instanzen

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 
    } 
} 

und 20-40 funktionalen Schnittstellen hält. Hier sind zwei Beispiele:

@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"); 
      } 
     } 
    } 
} 

und

@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"); 
      } 
     } 
    } 
} 

An verschiedenen Stellen im Code muss ich verschiedene iterate Methoden aufrufen:

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

Mein Problem ist, dass ich das halten iterate Methode für alle funktionalen Schnittstellen, während sie effektiv dasselbe tun: Überprüfen, ob das Objekt diese Schnittstelle implementiert, (Casting) und nur aufrufen abstrakte Methode mit den gegebenen Argumenten.

Gibt es einen Weg, über Syntax oder Design, nur 1 Methode, die das tut? Ich weiß, dass mit Reflexion es eine schlechte Art und Weise ist, dies zu tun (ich bin zeigt es nur um zu zeigen, dass ich meine Forschung tat, ich will es nicht):

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

Ich denke, Ihr Code ein paar Punkte hat das muss verbessert werden, aber ich habe mich nur darauf konzentriert, Ihnen eine Antwort auf Ihr spezifisches Problem zu geben. Ich denke, dass Sie diese gängige Methode zu einem Zwischen abstrakte Klasse übergeben müssen:

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"); 
      } 
     } 
    } 
} 

Was dies tut, ist Ihnen das einzige, was zu machen zu implementieren, die für jeden FunctionalInterface anders zu sein scheint Sie zur Verfügung gestellt. Das ist die onInter Methode. Das scheint anders zu sein. Also habe ich das abstrakt gemacht. Der Rest ist geteilt. Ich habe auch die statische von den iterate-Methoden herausgenommen, so dass sie auf die verschiedenen Implementierungen der onInter-Methode zugreifen können. Hoffentlich brauchst du diese nicht, um statisch zu sein. Also die Lösung, die ich präsentiere ist, um Ihre Klassen zu erweitern diese abstrakte Klasse und implementieren die Schnittstellen wie jetzt.