Provenendo da VB6 non ho una gran dimestichezza con l’ereditariet, per cui ho bisogno del vostro aiuto.
In un progetto ho una Superclasse che, tra gli Event Handlers, presenta l’evento “PincoPallo”; tra l’altro questa Superclasse ha una serie di Event Definitions, che, se ho capito bene, sono gli eventi che vedo e che posso implementare nella Subclasse.
Ora la mia Subclasse ha bisogno di implementare l’evento “PincoPallo” in maniera diversa da come implementato nella Superclasse, e qui mi sono incagliato.
Mi potete dare una mano? (magari tenendo presente che non sono un esperto di ereditariet)
Grazie a tutti.
Nedi
Add the modified PincoPallo event definition to the subclass. Then, invoke it from within the subclass’ event handler for the original superclass event. Example project
In questo caso devi definire gli eventi come ad esempio sono implementati gli eventi relativi al mouseDown o keyDown.
classeA
defineEvent PincoPallo as boolean
sub chiamaPincoPallo()
if not raiseEvent PincoPallo() then
//Utilizza il metodo standard
end if
end sub
implementation:
event PincoPallo as boolean
//fai qualcosa
return true //per evitare di utilizzare il "metodo" standard o false per farlo eseguire
end event
Grazie Andrew e Antonio per le vostre risposte, anche se non ci ho capito moltissimo, in virtù delle mie scarse conoscenze in materia.
Credo di aver risolto il problema in questo modo:
a) la super-classe è un Listbox con tante funzionalità in più: questa super-classe gestisce l’evento “standard” CellClick in un certo modo.
b) ho un mio Listbox che è una sub-classe e che non può gestire l’evento CellClick
c) nella super-classe ho inserito la definizione dell’evento CellClick che riceve due parametri anziché quattro, come invece fa l’evento “standard”; nell’handler dell’evento CellClick, in fondo al codice personalizzato, ho aggiunto “CellClick(row, column)”.
Così funziona, ma non so se ho fatto le cose come OOP comanda!
Attendo il vostro parere…e grazie ancora!
Puoi definire un evento come vuoi e quindi anche con lo stesso nome e diversi parametri o con lo stesso nome e gli stessi parametri (c’ una scorciatoia nell’IDE per questo)
Il punto come viene chiamato l’evento
Nella tua superasse nell’evento CellClick metti:
if not cellClick(row, column) then
//il resto del codice
end if
In questo modo l’evento cellClick viene scatenato, gestito inizialmente dalla superclasse, poi inviato (nella tua versione ridotta) alla sottoclasse o istanza dove se implementato fa le sue cose e pu ritornare true o false, se invece non implementato ritorna implicitamente false.
Se ritorna false procede con il tuo codice classico altrimenti no.
Questo il motivo per cui mouseDown, keyDown etc hanno il parametro di ritorno come boolean.
Grazie Antonio! Vediamo se comincio a capirci qualcosa:
quindi tu mi dici di definire, nella super-classe, l’evento “ridotto” CellClick" come una function che ritorna un Boolean.
Nella sub-classe faccio quello che devo fare per l’evento CellClick e poi chiudo ritornando True o False, a seconda di come voglio che si comporti la super-classe.
Nel tuo esempio quando scrivi “il resto del codice” intendi il codice che presente nell’evento CellClick della super-classe?
Perch se cosi allora io, dalla sub-classe, posso decidere se la super-classe deve eseguire il suo codice oppure no. Nel tuo esempio se la sub-classe ritorna False il codice della super-classe viene eseguito, altrimenti no.
Ho capito bene?
Grazie.
Si.
Prendi come esempio l’evento keydown di un textField normale.
Se non implementi l’evento nell’oggetto nella finestra o in una sottoclasse allora il testo scritto appare nel campo.
se invece nell’evento, ad esempio in una istanza in una finestra, scrivi qualcosa tipo
return key="A"
che sarebbe ritorna vero se l’utente ha premuto il carattere A allora l’evento “principale” viene interrotto, altrimenti no.
In pratica controlli dall’istanza (o dalla sottoclasse) cosa vuoi far avvenire
Altra pratica “propagare l’evento” ovvero chiamare dalla superclasse uno o pi eventi della sottoclasse e fare altre cose.
Ad esempio, poniamo che hai del codice nell’evento open della superclasse.
Vuoi che sia possibile del codice “locale” prima e dopo questo evento.
Allora nella superclasse nell’evento open avrai:
openBefore //evento nuovo che puoi implementare nella sottoclasse/istanza
//Il tuo codice open della classe
openAfter //evento nuovo che puoi implementare nella sottoclasse/istanza
(questo fattibile con ogni evento ovviamente non solo con open)
Ma in questo caso tu inserisci codice prima e/o dopo il tuo evento base (se vuoi) ma non impedisci l’evento base.
Con il booleano (come parametro di ritorno) puoi decidere se questo codice base deve essere eseguito (o con una enumerazione ad hoc potresti anche decidere come deve essere eseguito)
Dipende dalla necessit
Ok, la nebbia comincia a diradarsi. Grazie tante, Antonio!!