OO Design, aperto/chiuso questione di principio

StackOverflow https://stackoverflow.com/questions/91137

Domanda

Ho pensato di progettazione object oriented domanda per un po ' ora e sono in grado di venire con una soluzione soddisfacente, così ho pensato di buttare aperto al pubblico per alcune opinioni.

Ho un Gioco classe che rappresenta una svolta in base gioco da tavolo, si può assumere che è simile al Monopolio ai fini di questa domanda.Nel mio disegno ho un Giocatore classe contenente un metodo TakeTurn.

Il Gioco scorre tutti Giocatores e chiama il TakeTurn metodo per fare tutte le cose necessarie per completare il turno.Voglio essere in grado di avere un numero n di giocatori, e di essere in grado di impostare un numero arbitrario di loro per essere i giocatori del computer.Quindi, il mio pensiero era quello di avere un HumanPlayer di classe e di un ComputerPlayer classe, sia che derivano dal Giocatore.

Il Gioco conosce solo la Giocatore classe e chiama semplicemente il TakeTurn metodo su ogni Giocatore di volta in volta.Il mio problema nasce nel fatto che ComputerPlayer gli oggetti possono essere completamente automatizzato, cioèmantenere il Monopolio esempio, può decidere di acquistare una proprietà utilizzando alcuni pezzi di logica.Ora, con il HumanPlayer oggetto, è necessario ottenere un input dall'utente per essere in grado di acquistare un immobile, per esempio, che sembra implicare una diversa interfaccia e potenzialmente significa che non dovrebbero derivare

Non sono stato in grado di trovare una buona soluzione al problema senza avere il Gioco classe conoscere le effettive realizzazioni dei vari Giocatore le classi in modo esplicito.Ho sempre potuto fare l'ipotesi in Gioco classe che ci sarà sempre l'uomo e il computer i giocatori ed efficacemente chiudere per estensione, ma non sembra buona programmazione OO.

Ogni opinione su questo sarebbe apprezzato.

È stato utile?

Soluzione

Penso che non si deve lasciare il Gioco classe di gestire IO.in questo modo, il (blocco) TakeTurn metodo di nascondere il tabellone di gioco, le modalità di realizzazione.è possibile utilizzare altri oggetti per comunicare con l'utente.

Tutto il Gioco di classe deve preoccuparsi di stato del consiglio di amministrazione e al turn.i giocatori dovrebbero implementare una singola interfaccia del Lettore, e nascondere tutte attuazione dal Gioco.

Altri suggerimenti

Se il Gioco è la gestione dello stato del gioco e facendo I/O, il Gioco si fa troppo.

Si desidera che il Gioco per essere focalizzato sul solo di regole e di svolte e cambiamenti di stato.Il gioco non sanno cosa sia un giocatore;si sa solo che ha i giocatori.

Si desidera che i Giocatori di esaminare il Gioco di stato e di eseguire le azioni legali durante il loro turno.

I Giocatori umani e il Gioco nel suo complesso entrambi comune I/O pacchetto che mostra stato del gioco e richiede esseri umani per il loro contributo.

Si può fare buon uso di Java Observable facendo l'I/O di un pacchetto Observer del Gioco.In quel modo, Gioco di cambiamenti di stato vengono segnalati i/O per la visualizzazione o la registrazione o entrambi.

Io, probabilmente, non avrebbe due HumanPlayer e ComputerPlayer le classi, ma una sola Player di classe, che è configurato in fase di creazione con ingresso corretta strategia.

Il modo in cui il giocatore ottiene informazioni per decidere la sua mossa nel prossimo turno di gioco è il solo cosa che varia (da originale la descrizione del problema, almeno), quindi basta incapsulare che in un separato astrazione.

Qualunque sia di alto livello che consente di impostare il gioco dovrebbe anche creare due gruppi di giocatori (un umano, un altro computer-simulato), con ingresso corretta strategia per ciascuno, e poi semplicemente dare a questi player oggetti per il gioco in oggetto.Il Gioco di classe sarà quindi solo chiamare il TakeTurn metodo la lista di giocatori, per ogni turno di gioco.

Invece di dire il gioco di classe c'è sempre e solo un umano, perché non lasciate che l'input durante l'menu/inizializzazione del gioco?Se ci sono più giocatori, che può essere deciso tramite una qualche forma di input (selezionare i giocatori nel menu), prima che il gioco inizializzazione della classe.

L'interfaccia che Giocatore presenta Gioco è ortogonale al comportamento della derivata Giocatore classi.

Il fatto che l'attuazione di TakeTurn varia a seconda del tipo di calcestruzzo di Giocatore oggetto non dovrebbe essere un motivo di preoccupazione.

Penso che il Game Classe dovrebbe non preoccupazione per eventuali implementazioni del Giocatore classi, e di ignorare l'Interfaccia Utente.

Qualsiasi input dell'utente deve essere gestita dal HumanPlayer classe.

Direi che, il Gioco la classe non importa se questo e ' un giocatore o un giocatore umano.Si deve sempre chiamare TakeTurn il prossimo giocatore di classe.Se questo è un giocatore umano, è responsabilità del Giocatore classe, per comunicare con l'utente e chiedere all'utente cosa fare.Il che significa che il blocco fino a che l'utente ha effettuato la sua mente.Come al solito interfaccia utente interazione avviene nel thread principale dell'applicazione, l'importante è che un blocco TakeTurn non bloccare l'applicazione come un intero, altrimenti l'input dell'utente non possono essere trattati, mentre Gioco aspetta TakeTurn.

Invece di Gioco classe chiamata TakeTurn su tutti i giocatori i giocatori devono chiamare TakeTurn sul Gioco la classe e la Gioco classe dovrebbe verificare se il giocatore giusto è di prendere il suo turno.

Questo dovrebbe aiutare a risolvere il Utente e Computer lettore problema.

Im non sono sicuro se questo è ciò che si desidera

public abstract class Player 
{
  int position;
  DecisionMaker decisionDependency;

  ...

  public void TakeTurn()
  {
    position += RollDice();
    GameOption option GetOptions(position);
    MakeDescion(option);
  }

  protected int RollDice()
  {
    //do something to get the movement
  }

  protected abstract void MakeDecision(GameOption option);

}

Public class ComputerPlayer : Player
{
  public ComputerPlayer()
  {
    decisionDependency = new AIDecisionMaker();
  }

  protected override void void MakeDecision(GameOption option)
  {
    decisionDependency.MakeDecision(option);
    //do stuff, probably delgate toan AI based dependency
  }
}

Public class HumanPlayer : Player
{
  public HumanPlayer()
  {
    decisionDependency = new UIDecisionMaker();
  }

  protected override void void MakeDecision(GameOption option)
  {
    decisionDependency.MakeDecision(option);
    //do stuff, probably interacting with the a UI or delgate to a dependency
  }
}
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top