scambio di info senza cast

[stirkland]

Ciao amici, ho un quesito:

sto sviluppando una classe astratta padre A che implemente il pattern Template, quindi all'interno di un metodo esegui() riporta la lista di esecuzione di alcuni metodi astratti da implementare nelle classi figlie:

public final Object esegui() {
  init(x);
  Y y = call(x);
  return elaborate(y);
}

Il concetto è che un oggetti di tipo X viene inizializzato (init), viene avviato (call) e il risultato, l'oggetto di tipo Y viene elaborato (elaborate).

Ora il problema: X e Y sono interfacce, ogni classe derivata da A (la classe che contiene il metodo esegui()) utilizzerà le sue personali classi che implementano X e Y: ciò significa che all'interno della classe B, volendo implementare il metodo init():

@Override
protected void init(X x) {
  X1 x1 = (X1) x;
  x1.set(...
  x1.get()
}

posta X1 una classe derivata da X, io dovrò ogni volta castare a X1 i riferimenti di X; idem per quanto riguarda le classi derivate da Y!
E questo limita la flessibilità del codice.

Sapete come posso risolvere il problema? Non esiste un pattern che mi permetta di passare da classe padre a classe figlia senza trasformare i tipi delle variabili che passo?


Fatemi sapere se non sono stato chiaro.

Grazie!

[Patrick Jane]

Ho letto con molta fretta, spero quindi di poterti aiutare comunque.

Sei costretto a castare se X1 contiene informazioni che X non conosce. E' l'esempio di Graphics; per utilizzare i metodi di Graphics2D sei costretto a fare

Graphics2D g2 = (Graphics2D) g;

dove g è Graphics.


L'unica cosa che ti evita ciò, è il polimorfismo. Quindi se hai un interfaccia I che viene implementata da due classi, e che quindi le classi offrono gli stessi metodi, facendo

A a = new A();
B b = new B();

Interfaccia I = a;
I.metodo();

Interfaccia I = b;
I.metodo();

dove metodo() ha appunto la stessa firma. La chiamata avviene in base all'oggetto a cui fai riferimento.
Questa è proprio la forza del polimorfismo.