Java-使用注释来调用不同的函数？

Question

I am currently refactoring a chat bot that I've created in Java that connects to multiple different websites, and must carry out actions differently depending on the platform. Each platform must function the same, but is simply executed differently, depending on that websites API.

For explanation, I will use platforms Alpha and Beta ( Platforms being IRC/Websocket platforms, not Operating Systems / Devices. )

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

Sub Class

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

Could somebody explain a bit on how I could pull this off, or whether it's even possible or not? Comment if I need to explain better. I searched around a bit to see if I could find something similar, but may have missed something.

Answer 1

There are multiple ways to do this, each can be considered a design pattern.

Abstract class:

For something like I would normally use abstract class over annotation.

In an abstract class you can decide which functions the parent class provides the implementation for and which the child classes. You can do something formal and create new classes called Alpha and Beta or you can do anonymous classes. Below is example of anonymous class.

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
            */
        }
    };

}

Below is an example using a formal class for Beta vs. anonymous class

    class Beta extends Parent {

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

}

Functional interface:

Similar to abstract class but with a few restrictions. The shared function must use the default clause. And the interface has one method that must be implemented.

    static interface Parent {

    default public void sharedFunction() {
    }

    abstract void nitpick();

}

public static void main(String[] args) {

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

}

Pass the implementation as input:

In this approach the implementation of the nitpick function is passed to the Parent class' constructor.

    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*/});

}