Java - Verwenden von Anmerkungen zum Aufrufen verschiedener Funktionen?

Question

Ich überarbeite gerade einen Chat-Bot, den ich in Java erstellt habe, der sich mit mehreren verschiedenen Websites verbindet, und muss abhängig von der Plattform verschiedene Aktionen ausführen. Jede Plattform muss gleich funktionieren, wird aber einfach anders ausgeführt, abhängig von der Website-API.

Zur Erläuterung werde ich verwenden Plattformen Alpha und Beta (Plattformen Plattformen IRC/Websocket ist, nicht Betriebssysteme/Geräte.)

public class MyMainClass { 
    public static void main(String[] args) { 
    sharedClass Alpha = new sharedClass("Alpha"); 
    sharedClass Beta = new sharedClass("Beta"); 
    } 
} 

SUBKLASSE

/* To do so, I have created a shared class */ 
public class sharedClass { 
    public String platformName = null; 

    public sharedClass(String name) { 
    this.platformName = name; 
    } 

    /* Both platforms use many shared 
    * functions, so I want to keep them 
    * in the same class file, rather than 
    * separating them. 
    */ 
    public String sharedFunctionA() { return null; } 
    public String sharedFunctionB() { return null; } 
    /* ... */ 

    /* However, some functions that touch 
    * on the APIs required picking out 
    * different information. 
    * 
    * My goal is to get rid of these functions 
    * so I can leave them as-is and not have 
    * to add a new else to it every time I 
    * add a new platform. 
    */ 
    public String nitpickFunction() { 

    /* Many similar functions exist, 
    * where I am required to use more 
    * than just two platforms. 
    */ 
    if (this.platformName.equals(/* Platform-Alpha */)) { 
     /* Do Stuff For Platform Alpha */ 

    } else if (this.platformName.equals(/* Platform-Beta */)) { 
     /* Do Stuff For Platform Beta */ 

    } /* else if (Platform-Gamma) { 
    } else if (Platform-Delta) { 
    } else if (Platform-Epsilon) { 
    } else if (Platform-Zeta) { 
    } ... 
    */ 

    } 

    public String properFunction() { 
    /* My hope (New To Creating Annotations) 
    * is to do something similar to the following, 
    * so that I can call what would have been inside 
    * an if/else block, from the platforms respective 
    * class file. 
    */ 
    @DoPlatformNitpick 
    myNitpickFunction(); 
    /* 
    * Or just something like this 
    */ 
    MyPlatform mySelectedFunction = new MyPlatform(); 
    mySelectedFunction.nitpick(); 
    /* However I believe that would require my 
    * Alpha and Beta platforms to use the same 
    * class type. 
    */ 
    } 

    /* Please ignore the possible NullPointerException, 
    * this is just an example. 
    */ 
} 

Kann mir jemand erklären, wie ich das durchziehen kann oder ob es gerade ist möglich oder nicht? Kommentar, wenn ich besser erklären muss. Ich habe ein bisschen gesucht, um zu sehen, ob ich etwas Ähnliches finden könnte, aber vielleicht etwas verpasst.

Answer 1

Es gibt mehrere Möglichkeiten, dies zu tun, jedes kann als ein Entwurfsmuster betrachtet werden.

Abstrakte Klasse:

Für so etwas wie ich normalerweise abstrakte Klasse über Annotation verwenden würde.

In einer abstrakten Klasse können Sie entscheiden, für welche Funktionen die Elternklasse die Implementierung bereitstellt und welche die untergeordneten Klassen. Sie können etwas Formales tun und neue Klassen namens Alpha und Beta erstellen oder anonyme Klassen erstellen. Im Folgenden finden Sie ein Beispiel für eine anonyme Klasse.

static abstract class Parent { 

    public void sharedFunction() { 

    } 

    abstract void nitpick(); 

} 

public static void main(String [] args) { 

    Parent alpha = new Parent() { 
     @Override 
     void nitpick() { 
      /* 
      alpha specific code here 
      */ 
     } 
    }; 

} 

Unten ist ein Beispiel einer formalen Klasse für Beta vs. anonymen Klasse mit

class Beta extends Parent { 

    @Override 
    void nitpick() { 
     /* 
     beta speicfic code goes here 
     */ 
    } 

} 

Funktionsschnittstelle:

Ähnlich wie abstrakte Klasse, aber mit ein paar Einschränkungen. Die gemeinsame Funktion muss die Klausel default verwenden. Und die Schnittstelle hat eine Methode, die implementiert werden muss.

static interface Parent { 

    default public void sharedFunction() { 
    } 

    abstract void nitpick(); 

} 

public static void main(String[] args) { 

    Parent alpha =() -> {/* alpha specific code goes here*/ 
    }; 

} 

übergeben Sie die Implementierung als Eingang:

Bei diesem Ansatz der Umsetzung der nitpick Funktion zum Parent Klasse Konstruktor übergeben wird.

static class Parent { 

    public void sharedFunction() { 
    } 

    final Runnable nitpick; 

    public void nitPick() { 
     nitpick.run(); 
    } 

    public Parent(Runnable nitpick) { 
     this.nitpick = nitpick; 
    } 

} 

public static void main(String[] args) { 

    Parent alpha = new Parent(() -> {/* alpha specific code goes here*/}); 

}