Potrei farlo molto più semplice con Reflection. Dovrei?

Question

Quindi sto scrivendo un gioco e mi sono imbattuto in un enigma in cui credo che Reflection potrebbe essere una soluzione migliore. Ma sapendo che Reflection è scoraggiato e la mia altra soluzione non sembra così carina, ho pensato di chiedere qui e vedere cosa è in realtà un'idea migliore in questo scenario.

In sostanza ho una classe di carta astratta, e avrà diverse implementazioni di esso. Ho un caso in cui mi viene dato il nome di una carta e ho bisogno di costruirne un oggetto, dato solo il nome.

So che avrei potuto utilizzare:

a) Riflessione e utilizzare forName e invocare. Sarà un codice molto corto, scalabile e facile da scrivere. Detto questo, è Reflection, e io sono tutto per evitarlo quando non ne ho particolarmente bisogno.

b) Utilizzare un modello di progettazione di fabbrica e poi hanno un controllo condizionale gigante, chiamando la classe appropriata in base al nome fornisco. Non è difficile da scrivere ma richiede una manutenzione costante e impiegherà un po 'di tempo a scrivere, inoltre non sarà scalabile. Detto questo, è una soluzione senza riflessione.

Quindi qual è la soluzione ideale? Uso semplicemente Reflection perché mantiene il mio codice piacevole e breve?

Answer 1

Vorrei suggerire di utilizzare un modello di fabbrica e utilizzare una fabbrica precompilati come molla che è possibile utilizzare per definire le istanze di fagioli con là piuttosto che implementare la propria fabbrica. Si ridimensionerà più facilmente poiché è possibile definire più tipi di bean in codice Java XML o annotato. Assicurati di utilizzare i fagioli non singleton e ogni volta che chiedi alla tua fabbrica di primavera un fagiolo con un nome, chiamerà correttamente il costruttore. Ti permetterà anche di fare un'iniezione di dipendenza allo stesso tempo gratuitamente.

Answer 2

Ecco un'alternativa (non so se è la "soluzione ideale" come hai menzionato, ma penso che sia opportuno prendere in considerazione): enumerati i tipi. Sarà ancora una lista enorme, ma forse un po 'più pulita? E devi definirli tutti da qualche parte.

Un esempio di ciò che intendo:

enum CardType { 
    CARD_ONE(new Card(arg0, arg1, arg2, ..., argN)), 
    CARD_TWO(new Card(arg0, arg1, arg2, ..., argN)), 

    ... 

    CARD_N(new Card(arg0, arg1, arg2, ..., argN)); 

    private final Card card; 

    private CardType(Card card) { 
    this.card = card; 
    } 

    public Card getCard() { 
    return card; 
    } 
} 

Poi, quando è necessario ottenere uno per nome, basta fare:

public Card getCardByName(String cardName) { 
    return CardType.valueOf(cardName).getCard(); 
} 

Questo presuppone le carte sono single, ma si potrebbe altrettanto facilmente fare il metodo getCard fare una sorta di logica di fabbrica per crearne uno nuovo.