[OOP] usare una sottoclasse al posto della sua classe

[thomas]

Allora, premettendo che ne so' poco di Java (e ne voglio sapere lo stretto indispensabile), mi trovo di fronte ad un quesito.

Ho una classe astratta 'Element' con un paio di variabili e qualche metodo.
Da questa classe, "estendono" altre due classi diverse, Street e Building, che aggiungono ad Element qualche variabile e qualche altro metodo.

Ho un'altra classe, che definisce una matrice di Element: Element[][] cityInstance

Ora, nel corso del programma, clonerò dei prototipi delle classi Street e Building (utilizzando un metodo della classe astratta Element) per poi assegnarli ad una posizione nella matrice cityInstance.

Codice: Seleziona tutto

cityInstance[x][y] = (Street) Street.cloneMe()


Il codice sembra funzionare, ma il mio problema, più che altro di letteratura è se posso fare quello che ho fatto!
Gli elementi di cityInstance sono di tipo Element, mentre, seppur cloneMe() è definita in Element quindi mi ritorna un oggetto Element, io castizzo questo Element nel tipo definito dalla sottoclasse Street.

Spero di aver chiarito il problema... intanto, visto che funziona vado avanti, ma vorrei un riscontro su questa cosa, grazie!

Ciao

[thomas]

Ho fatto altre prove...
Il codice di cui sopra si utilizza nel seguente modo

Codice: Seleziona tutto

cityInstance[x][y] = (Street) Street.cloneMe()
((Street) cityInstance[x][y]).setExit('s');   // per i metodi definiti in Street
cityInstance[x][y].setPosition(2,2);          // per i metodi definiti in Element


Mi son chiarito il fatto che il metodo cloneMe() clona il prototipo (quindi se è una Street clona un oggetto di tipo Street); essendo però definita in Element, mi ritorna un oggetto di quel tipo, che io vado a forzare a comportarsi come una Street "allorchè" (azz, mi sembra di parlare come Ollari eh Leo!!) il suo utilizzo.

Il problema di letteratura continua ad esserci (date anche le mie base NON ad oggetti): se creo un modello, una matrice in questo caso, di tipo Element, ogni "buco" nella matrice avrà spazio a sufficienza per un oggetto di tipo Element (occupazione di memoria).
Se io in quel "buco" vado ad insere un oggetto di tipo diverso (Street che estende comunque Element, ma che ha "qualcosa in più - occupazione di memoria quindi differente), cosa accade? Una magia del subclassing??? E' concepibile tutto ciò?
Questo ancora non riesco a capirlo.

Quello che mi chiedo: forzo la struttura matrice? la rompo?

[Ices_Eyes]

Mmmmh...Ci ho capito poco del tuo problema, ma...Se il codice compila e non da errori in escuzione...la cosa si può fare...

[morskott]

allora, il metodo cloneMe non capisco a che serva, java ha il suo metodo da overridare chiamato clone() che in Object è protected ed è quindi da ridefinire nelle sottoclassi di interesse (nel tuo caso sia in Element che nelle 2 sue sottoclassi), ricordati solo di implementare nella classe che vuoi clonare l'interfaccia Cloneable, di catturare sempre l'eccezione "CloneNotSupportedException" e di fare una "super.clone()" come prima istruzione. Per es:

Codice: Seleziona tutto

public class MiaClass implements Cloneable{
private int a;
private int b;

...
...

public Object clone(){
try{
MiaClass ris=(MiaClass)super.clone();
ris.a=this.a;
ris.b=this.b;
return ris;
} catch(CloneNotSupportedException c){
throws new InternalError("non lo lancerà mai");
}
}

nelle 2 tue sottoclassi puo pure non implementare Cloneable e non catturare l'eccezione, basta che lo fai nella superclasse comune.
Per quanto riguarda se la superclasse può contenere la sottoclasse ovviamente si, senza nemmeno fare il casting, visto che un oggetto della sottoclasse è a tutti gli effetti un istanza anche della superclasse, ovviamente quando poi te la riprendi per usarla come sottoclasse da una variabile di tipo superclasse ci devi fare il casting.
E pure quando invochi il clone di una variabile di tipo superclasse java ti chiama invece il clone corretto, cioè quello della sottoclasse per il concetto del late binding, come pure ogni metodo della superclasse di cui fai overriding java chiama quello corretto, cioè quello della sottoclasse.
Se ti servono altri chiarimenti sull'ereditarietà fai un salto qui.
Spero di esserti stato d'aiuto

[thomas]

Per quanto riguarda se la superclasse può contenere la sottoclasse ovviamente si, senza nemmeno fare il casting, visto che un oggetto della sottoclasse è a tutti gli effetti un istanza anche della superclasse, ovviamente quando poi te la riprendi per usarla come sottoclasse da una variabile di tipo superclasse ci devi fare il casting.
E pure quando invochi il clone di una variabile di tipo superclasse java ti chiama invece il clone corretto, cioè quello della sottoclasse per il concetto del late binding, come pure ogni metodo della superclasse di cui fai overriding java chiama quello corretto, cioè quello della sottoclasse.
Se ti servono altri chiarimenti sull'ereditarietà fai un salto qui.
Spero di esserti stato d'aiuto

Per quello che riguarda la prima parte, non l'ho scritto, ma ho comunque implementato il metodo clone() dell'interfaccia Cloneable (addirittura solo nella superclasse Element...)

Per il resto, anche grazie alle tue parole, ho capito che quando istanzio la mia matrice di Element, gli oggetti interni non vengono dimensionati (e quindi la matrice "occupa zero byte") ma bensì impostati a null.
Quindi quando andrò ad istanziare il giusto oggetto (Street o Building nel mio caso) erede di Element, il tutto funziona correttamente proprio perché l'overriding ha fatto il suo compito.

Grazie
Pomeriggio mi butto sull'algoritmo del GPS così termino il progetto hihihi