Cosa fare per molti tipi piccoli, semanticamente simili?

Question

Cosa fare per molti tipi piccoli, semanticamente simili?

#1 da (2 voti)

0

Sto lavorando su un'architettura client-server non generica in Java. Attualmente, affronterò il problema di come affrontare Event -types poiché ogni evento ha attributi diversi, che non si sovrappongono necessariamente. Per ora questo è quello che ho provato:

public interface Event {
   public void send(ServerConnection connection);
}

public static class Events {
   public class Registered implements Event {
       public final int clientId;
       public Registered(int clientId) {
          this.clientId = clientId;
       }
       public send(ServerConnection connection) {
           // ...
       }
   }
   public class Disconnected implements Event {
       public send(ServerConnection connection) {
           // ...
       }
   }
   public class Moved implements Event {
       public final int clientId;
       public final Position position;
       public Moved(int clientId, Position position) {
          this.clientId = clientId;
          this.position = position;
       }
       public send(ServerConnection connection) {
           // ...
       }
   }
   // and many more ....
}

Tuttavia, questo mi rende abbastanza infelice, dal momento che ho voglia di ripetermi spesso. Innanzitutto, stavo pensando di utilizzare un'enumerazione, ma in quel caso avrei valori inutilizzati, poiché gli attributi differiscono da evento a evento.

java interfaces

posta NaCl 26.08.2017 - 16:12

fonte

1 risposta

Leggi altre domande sui tag java interfaces

Livelli multipli di astrazione e chiamate a catena di metodi (programmazione funzionale Java) Normalizzazione programmatica dei sistemi di sicurezza basati sui ruoli

score 2 · Accepted Answer

Questo mi sembra un normale codice Java ... non una ripetizione evitabile. Hai preso in considerazione l'utilizzo di un linguaggio meno dettagliato, come Scala? Le sue case-class potrebbero aiutarti.

Con Java8 ottieni un'altra opzione che a volte può essere utile. Se hai solo bisogno di diverse implementazioni Event#send() ma non di tipi diversi, potresti usare invece una lambda:

@FunctionalInterface
public interface Event {
   public void send(ServerConnection connection);
}

public static class Events {
   public Event registered(int clientID) {
       return connection -> { ... };
   }
   public Event disconnected() {
       return connection -> { ... };
   }
   public Event moved(int clientID, Position position) {
       return connection -> { ... };
   }
   // and many more ....
}

Nella maggior parte degli scenari è sufficiente, ma perdi un po 'di debugabilità e la possibilità di controllare if (ev instanceof Events.Moved) ecc.