linking methods from an enum to member variables of client class

Question

Hello,

The following enum structure performs certain operations while remaining agnostic to the client class (for encapsulation reasons)

    public enum MyEnum implements Commands{
    A{
     public int method1(int varY) {   
      return varY+2;
     }

     public MyEnum method2(){
                       return MyEnum.B;
              }

             //...other methods implementing Commands interface
    },
    B{

     public int method1(int varX) {
      return varX-2;
     }


               public MyEnum method2(){
                       return MyEnum.C;
              }

     //...other methods implementing Commands interface
    },
    C{

     public int method1(int varY) {
      return varY-2;
     }

     public MyEnum method2(){
                        return MyEnum.D;
               }


              //...other methods implementing Commands interface
    },
    D{

     public int method1(int varX) {
      return varX+2;
     }

     public MyEnum method2(){
                      return MyEnum.A;
                 }


             //...other methods implementing Commands interface
    }

The client class

    public class Client {
    private int varX;
    private int varY;
    private MyEnum enum;

    MyEnum getEnum(){
     return enum;
    }

    int varX(){
     return varX;
    }

    int getVarY(){
     return varY;
    }

    public Client(int varX, int varY, MyEnum enum){
     this.varX = varX;
     this.varY = varY;
     this.enum = enum;
    }

    public void performMethod1(MyEnum enum){  
     varX = getEnum().method1(getVarX()); //???
     varY = getEnum().method1(getVarY()); //???
    }

     public void performMethod2(...){
                enum = getEnum().method2();
      }
}

My question is how to link the specific implementations of method1() belonging to MyEnum.A and MyEnum.C so that they operate on Client class member varY, and the method1() implementations of MyEnum.B and MyEnum.D to operate only on Client class member variable varX.

For example within a main() method:

Client aClient = new Client(aVarX, aVarY, anEnum);    
aClient.performMethod1(aClient.getEnum());

So, depending in the current enum state, the above statement should operate only on varX or varY and change the state on aClient.

Let's say for:

aClient.performMethod1(MyEnum.A);

The state of aClient represented by varY should be changed to varY+2. varX should remain unchanged.

As you can see by the simple naming convention, at this time varX in MyEnum is not linked to varX in Client class in any way. My thoughts lean toward the type of the variables. Since I am working with primitives (int) there is no way to distinguish..

Would you recommend I create different custom types for each of the varX and varY (wrap them somehow?) in Client class?

I hope I am not too verbose with the question. Please let me know in case I am not being clear with it. Many thanks.

Answer 1

You want different things to happen to the Client depending on different values of the MyEnum. If the MyEnum has to be client agnostic then either the Client will have to recognize different states of the MyEnum (a switch in Client.performMethod1) or a separate processor class will have implement that logic.