[Architettura Classi] Scelta Struttura Classi/Interfacce migliore

[Mrk31]

Come da titolo ho problemi a decidere quale potrebbe essere la "struttura" migliore per il problema che devo risolvere.

Ho una Gerarchia di Classi/Classi Astratte/Interfacce su 3 Livelli "di profondita", ma essenzialmente il mio problema riguarda la "capostipite" (la piu' generica) e l'istanza realmente utilizzata (la piu' specifica).

In sostanza devo creare la classe specifica e poi eseguire il metodo comune e tutte ed ereditato dalla classe generica.

Le soluzioni che mi sono venute in mente sono le seguenti (in "pseudocodice"):

SOLUZIONE 1)
ClasseGenerica istanzaClasse = New ClasseGenerica(id_classe_specifica)
istanzaClasse.metodoComuneDaEseguire()

Creo un'istanza della classe generica passando al costruttore della generica un parametro che identifichi la classe Specifica da creare...

Nel costruttore della Generica ci sara' uno Switch che creera' la giusta classe specifica.

In Questo modo potrei inglobare le due istruzioni in un metodo che in input prende il parametro che poi viene utilizzato dal Costruttore per identificare la classe da creare ed ottenere un metodo unico pre la creazione di tutte le classi specifiche.

SOLUZIONE 2)
ClasseGenerica.metodoComuneDaEseguire(New ClasseSpecifica())

"Disaccoppio" la classe Generica e quella Specifica in modo che quella Generica contenga un'istanza di quella specifica (una sorta di Decorator). quella generica la dichiaro statica e passo al metodo da eseguire l'istanza della classe specifica...

Non mi sono venute in mente altre soluzioni degne di nota...

Secondo Voi tra le due quale e' meglio???
Avete altre soluzioni Migliori???

Vi ringrazio in anticipo per l'aiuto...

[Scara95]

La soluzione più semplice è utilizzare una classe base comune/un'interfaccia e un metodo virtuale, con una funzione per il dispatching.

class ClasseBase {
  virtual metodoComune();
};

class Derivata subclass ClasseBase {
  override metodoComune();
}

class Derivata1 subclass ClasseBase {
  override metodoComune();
}

ClasseBase create(dispatching_arg, args) {
  return (switch(dispatching_arg) {
    dispatch_Derivata: new Derivata(args);
    dispatch_Derivata1: new Derivata1(args);
  });
}

main() {
  //get dispatching_arg and args
  ClasseBase c = create(dispaching_arg, args);
  c.metodoComune();
}

In funzione di quello che devi fare ci sono poi svariate alternative.

[Mrk31]

La soluzione più semplice è utilizzare una classe base comune/un'interfaccia e un metodo virtuale, con una funzione per il dispatching.

class ClasseBase {
  virtual metodoComune();
};

class Derivata subclass ClasseBase {
  override metodoComune();
}

class Derivata1 subclass ClasseBase {
  override metodoComune();
}

ClasseBase create(dispatching_arg, args) {
  return (switch(dispatching_arg) {
    dispatch_Derivata: new Derivata(args);
    dispatch_Derivata1: new Derivata1(args);
  });
}

main() {
  //get dispatching_arg and args
  ClasseBase c = create(dispaching_arg, args);
  c.metodoComune();
}

In funzione di quello che devi fare ci sono poi svariate alternative.

Ciao,
io per semplificare non ho descritto l'interno del metodo comune.

In ogni caso faccio gia' piu' o meno quello che mi suggerisici cioe' il metodo pubblico comune ha una struttura di base che richiama metodi privati di cui faccio l'override nelle classi piu' "specifiche".

Il problema era come gestire la creazione...

Semplificando/astraendo l'override del metodo comune la sola creazione dell'oggetto ed esecuzione del metodo comune ad "alto livello" come rimarrebbe?

[Scara95]

Rimarrebbe esattamente com'è ora.

[Mrk31]

Se non ho interpretato male...dovrebbe essere analoga alla Soluzione 1 da me proposta...ipotizzando che la New(create) non abbia argomenti propri da passare come parametro, ma solamente quello per lo Switch...

Creo un'istanza della classe generica passando al costruttore della generica un parametro che identifichi la classe Specifica da creare...

ClasseGenerica istanzaClasse = New ClasseGenerica(id_classe_specifica)
istanzaClasse.metodoComuneDaEseguire()

  //get dispatching_arg and args
  ClasseBase c = create(dispaching_arg, args);
  c.metodoComune();
}

Nel costruttore della Generica ci sara' uno Switch che creera' la giusta classe specifica.

ClasseBase create(dispatching_arg, args) {
  return (switch(dispatching_arg) {
    dispatch_Derivata: new Derivata(args);
    dispatch_Derivata1: new Derivata1(args);
  });
}

Giusto???

[Scara95]

No. Usi un'altra funzione (static) non membro di ClasseBase.
A dire il vero può anche essere membro, ma in ogni caso non il costruttore.