méthodes de liaison à partir d'une énumération de variables membres de la classe de client

Question

La structure d'énumération suivante effectue certaines opérations, tout en restant agnostique à la classe client (pour des raisons d'encapsulation)

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 
    } 

La classe client

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

Ma question est de savoir comment lier les implémentations spécifiques de method1() appartenant à MyEnum.A et MyEnum.C afin qu'elles fonctionnent sur le membre de la classe Client varY, et les implémentations de method1() de MyEnum.B et MyEnum.D pour fonctionner uniquement sur Variable membre de la classe client varX.

Par exemple dans une méthode main():

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

Ainsi, selon dans l'état actuel ENUM, l'énoncé ci-dessus devrait fonctionner uniquement sur varX ou modifier et changer l'état sur AClient.

Disons que pour:

aClient.performMethod1(MyEnum.A); 

L'état de AClient représenté par VARY devrait être remplacé VARY + 2. varX devrait rester inchangé.

Comme vous pouvez le voir par la convention de nommage simple, à ce moment, varX dans MyEnum n'est pas lié à varX dans la classe Client en aucune façon. Mes pensées se penchent sur le type de variables. Puisque je travaille avec des primitives (int) il n'y a aucun moyen de distinguer ..

Recommanderiez-vous que je crée différents types personnalisés pour chacun des varX et varY (envelopper en quelque sorte?) Dans la classe client?

J'espère que je ne suis pas trop verbeux avec la question. S'il vous plaît laissez-moi savoir au cas où je ne suis pas clair avec elle. Merci beaucoup.

Answer 1

Vous souhaitez que différentes choses se produisent au Client en fonction des différentes valeurs du MyEnum. Si le MyEnum doit être agnostique client alors le Client devra reconnaître différents états du MyEnum (un commutateur dans Client.performMethod1) ou une classe de processeur distincte implémentera cette logique.