[java] superclasse che richiama costruttore di una sottoclasse?

[citrus]

ciao a tutti,
ho una domanda un po' strana da porvi:
è possibile che ad un certo punto, il costruttore di una superclasse, deleghi la costruzione di parte dell'oggetto ad una sottoclasse più specifica?

per spiegarmi meglio riporto un esempio:
sto costruendo un generatore di log.
dovrei far in modo che si possa leggere da file una stringa, e tramite questa costruire l'oggetto evento.
gli eventi sono di due tipi: ClientEvent e WebEvent.
la striga è suddivisa in 5 parti ciscuna divisa da una "|", la parte che contraddistingue i due eventi si trova nel quarto token.
ora la domanda è questa.
posso far in modo che la superclasse Event riempia i primi tre campi (comuni ad entrambi), e poi, in base al quarto token, deleghi l'istanziazione dei restanti due alla sottoclasse specifica?

so che è parecchio contorto è quasi sicuramente irrealizzabile ma avrei bisognmo almeno di togliermi il dubbio....
grazie a tutti
citrus

[patrix03]

/*
* costruttore AbstractEvent
*/
public AbstractEvent(){
   super();
   this.create();
}

private void create(){
  //elabora i 3 token.
  this.elabLastToken();
}

protected abstract void elabLastToken();

La sottoclasse :

/*
* costruttore ClientEvent 
*/
public ClientEvent (){
   super();
}

protected void elabLastToken(){
   //elabora il 4° token
}

Questo si fa quando si usano classi astratte, quando cioè non si possono concludere tutte le funzioni ma qualcuna deve essere implementata da una Sottoclasse + specifica e come concetto può essere ripreso per il tuo caso.
Questo comporta .. giustamente.. che non possa mai esistere un elemento Event generico in quanto il quarto token non potrebbe essere gestito.


PS: La superclasse non può richiamre il costruttore della sottoclasse.. ma il contrario si .. la sottoclasse richiama il costruttore della superclasse super(); .

[citrus]

ok grosso modo ci sono però mi manca ancora qualche pezzo....
allora io creo la classe generica Event come astratta.
il suo costruttore richiama un metodo Create() interno alla classe che istanzia i primi tre campi con i valori dei primi tre tokens.
a questo punto, sempre nel costruttore o dal metodo Create() dovrei lanciare un altro metodo (implementato nelle due sottoclassi) che istanzia gli ultimi due campi.

la cosa che non capisco è come richiamare direttamente tale metodo.
definiendo il metodo elabLastToken() come astratto voglio dire che ci dovrà essere una classe sottostante che implementi tale metodo ma a me serve di poter specificare anche quale classe usare in base al valore trovato nel quarto token (e poi sopratutto lo devo lanciare!)


praticamente io devo passare una stringa formata da 5 tokens al costruttore della classe generica Event, e questa si deve preoccupare di creare automaticamente un evento di tipo Web o Client a seconda che il quarto token indichi l'una o l'altra....

[patrix03]

ok.. non avevo capito....
resta qualcosa che mi sfugge cmq....
Tu a quanto ho inteso devi leggere da qualche parte questa stringa /file .. quel che è e in base ad un token istanziare l'oggetto appropriato....
Allora.. avrai un Reader / Parser(se xml) che recupare la stringa o il file, interpreta il token e genera l'oggetto.
Event ev = new ConcreteEvent(stringa).

A questo punto la classe astratta Event resta uguale centralizzando la costruzione, mentre la classe concreta sarà del tipo corretto.

i costruttori devono essere modificati per ricevere come parametro la stringa o .. meglio i token visto che li hai già creati nel reader.

mi sono perso qualcosa?

[citrus]

più o meno io l'ho pensata così, poi dimmi tu se può funzionare....
allora passo la stringa (formata da 5 tokens) alla classe generica Event.
questa avrà due costruttori, uno vuoto, ed uno che legge i primi tre tokens ed istanzia i relati campi e successivamente, in base al valore del quarto token, richiama il costruttore della sottoclasse, il quale richiama a sua volta il costruttore vuoto della superclasse e poi valorizza i rimanenti campi.
però a questo punto avrò una situazione un po' scomoda in memoria perchè così avrò creato due oggetti Event!!!
dico bene?

[patrix03]

ehmm... così fai solo un.. sacco di confusione ehehe
scusa ma xè non puoi far generare gli Event a chi per primo legge il file?
Mi sembrerebbe un po più lineare.....

cioè:
1) leggo il file riga x riga (ammesso che sia così)
2) per ogni riga genero e interpreto i token
3) in base al token appropriato creo una nuova istanza dell'evento associato magari inserendolo in una lista.. nn so..

ora ....
se tutti gli eventi hanno costrutti comuni .. è bene e utile creare una classe astratta o interfaccia che definisca queste caratteristiche e .. nel caso di classe astratta implementi le parti comuni.

[Zero-2]

Per il tuo scopo puoi usare una classe chiamata AbstractFactory che ti restituisce in base ad un parametro che gli passi la classe appropriata.
Es.

public class Reader {
private Event e;
private AbstractFactory ab;
public Reader(){
//inzializzi le variabili
//leggi stringa
e=ab.get(parametri);
//esegui le operazioni su e;
}
}
public class AbstractFactory{
public Event get(parametri){
if(parametri==ClientEvent)
 return new ClientEvent();
else if(parametri==WebEvent)
 return new WebEvent();
return null;
}
}

Ti salvi i token precedenti , e in base al quarto ti fai restituire la classe appropriata.
Spero di aver capito

[citrus]

Originariamente inviato da patrix03

...
1) leggo il file riga x riga (ammesso che sia così)
2) per ogni riga genero e interpreto i token
3) in base al token appropriato creo una nuova istanza dell'evento associato magari inserendolo in una lista.. nn so..
...

questo è il metodo che usavo e in effeti fila liscio come l'olio...
volevo solo provare altre strade, anche perchè in questo modo mi tocca tokenizzare la stringa più volte quando potrebbe essere sufficiente farlo una volta sola (o al massimo due).....

in altre parole devo prima tokenizzare la stringa (nel main), vedere la natura del quarto token ed in base a questa passare la stringa alla classe appropriata la quale dovrà passarla a sua volta alla superclasse la quale tokenizzaerà a sua volta per istanziare i primi tre campi. infine mi toccherà tokenizzarla di nuovo nella sottoclasse per riempire gli ultimi due campi!!!
so che è un casino ma ho dei limiti sui costruttori (parametri ecc...) imposti dal mio professore (si tratta di un esercizio per l'università) e quindi speravo di aggirare questo tram tram affidando tutto direttamente alla classe generica Event sperando che fosse poi lei a "specializzare" l'oggetto.

comunque niente...
mi sembra di aver capito che così è ancora più incasinato quindi opterò per la prima strada...
grazie comunque a tutti per l'interessamento
citrus

[patrix03]

perchè tokenizzare 2, 3 4 volte???
scusa...
esegui il main.. o quel che è...
e crei i primi token che puoi comodamente inserire in un array o lista.
A questo punto (ottimo il suggerimento del factory) chiami il factory passando l'array di token. il factory farà le opportune valutazioni sul token che gli interessa e istanzierà l'oggetto opportuno. Chiamerà il costruttore dell'oggetto che come parametri riceverà semplicemente l'array di token.. tutti!
A questo punto puoi fare diverse cose....
Usare la struttura di prima.. con classe astratta e metodi nel costruttore....
Usare una classe astratta che ha un metodo generico per trattare i 3 token comuni così da lasciare alla classe che la estende la sola elaborazione del token specifico....
e via dicendo...

in tutto questo giro.. i token .. vengono creati solo una volta.. e passati poi a chi li sa trattare.

[citrus]

ahimè purtroppo non è così semplice perchè ho dei limiti imposti del mio professore sul progetto.
ex: i costruttori devono ricevere in argomento la stringa intera!
quindi comunque ciascuno di essi deve smazzarsi lo sbattimento di tokenizzare la stringa!
purtroppo su questo non posso farci molto anche perchè ho già "disertato" usando uno stack al posto dell'array richiesto e non vorrei infastidire troppo chi poi tra parentesi dovrà giudicarmi...


però mi interessa molto il discorso sulla factory:
"Per il tuo scopo puoi usare una classe chiamata AbstractFactory che ti restituisce in base ad un parametro che gli passi la classe appropriata."

potresti dirmi qualcosa di più?
ancora grazie mille!!!