INHERITS - Cronologia

Vuott il 14:41, 22 ago 2025

2025-08-22T14:41:46Z

← Versione meno recente		Versione delle 08:41, 22 ago 2025
Riga 47:		Riga 47:

	----		----
	Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto "_new()" ~~([[Metodi nascosti~~]]), ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).		Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto [[Metodi_nascosti:_New()_e_Free()\|"_new()"]], ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).
	Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:		Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:
	----		----

Vuott: Annullata la modifica 2737 di 38.98.197.215 (discussione)

2012-12-05T09:55:41Z

Annullata la modifica 2737 di 38.98.197.215 (discussione)

← Versione meno recente		Versione delle 03:55, 5 dic 2012
Riga 1:		Riga 1:
	~~There~~'s a ~~seerct about your post~~. ~~ICTYBTIHTKY~~		'''INHERITS''' <ParentClass>

			Questa istruzione nella costruzioni di oggetti (o classi), basati su una specifica classe padre (Parent), e da cui prende tutte le caratteristiche che la identifica: proprietà e metodi. In realtà, dalla classe padre, è possibile derivare solo le proprietà e i metodi dichiarati '''PUBLIC''', mentre per quanto riguarda il resto, '''PRIVATE''', resta di uso strettemente della classe in cui sono dichiarati.
			In questa logica sono anche comprese le costanti '''CONST''' (PUBLIC CONST) e le proprietà e i metodi '''STATIC''' (STATIC PUBLIC).

			Anche nelle librerie Gambas sono presenti oggetti, le cui caratteristiche derivano dalla inerenza da oggetti superiori; un esempio potrebbe essere la classe Button, che discende dalla classe Control. Un'altro esempio è la stessa classe Form, che seppur dichiarata non creabile dinamicamente, discende dalla classe Window, che a sua volta discende dalla classe Container, che a sua volta discende dalla classe Control.
			Come si può notare, la discendenza, o inerenza, tra gli oggetti può essere molto complessa, ma ad ogni passaggio, ogni fliglio apporta nuove caratteristiche alla classe, rendendola sempre più specializzata.
			Non sono qui ad aprire un discorso sul tema della classi, perchè sarebbe lungo e fuori luogo, e inoltre esiste una montagna si documentazione in giro, che il mio risulterebbe un contributo piuttosto striminzito.

			Ma torniamo a noi...

			L'istruzione '''INHERITS''' è molto semplice, ma deve essere necessariamente la prima istruzione della classe (ad esclusione delle note...), e l'oggetto ParentClass deve essere già presente nel progetto, o nelle librerie di Gambas.
			Diversamente dalle versioni precedenti di Gambas, ora è possibile derivare un numero imprecisato di sottoclassi, ma non è possibile creare oggetti dipendenti da più di una classe parent contemporaneamente.
			Tranne che per gli oggetti Form, e gli oggetti STATIC in generale, inclusi nelle librerie di base, è possibile creare nuove classi derivandoli da quelli già presenti in Gambas.
			E' sottinteso che qualsiasi altro nostro oggetto, può essere subclassato senza alcun problema.

			Una volta che una classe è stata dichiarata sottoclasse di un'altra, ne prende le caratteristiche; ogni modifica alle sue proprietà viene riflessa anche alle proprietà della classe superiore, questo include anche la possibilità di sovrascrivere un determinato metodo in modo che si comporti in modo diverso rispetto alla classe superiore.

			Per fare un esempio, vogliamo creare un oggetto di tipo Button, a cui però vogliamo modificare o aggiungere nuove caratteristiche, oppure addirittura modificarne il comportamento, è sufficiente creare una nuova classe, e dichiararla '''INHERITS''' a Button:

			----
			'''INHERITS''' Button

			----

			Una volta definita la sua discendenza dalla classe superiore Button, non è necessario richiarare e ridefinire le caratteristiche che la nuova classe si ingloba con questa unione; questo a meno che non si voglia condizionare alcune delle funzionalità della classe superiore, per meglio adattarle alla nuova classe. Ma, a parte questo, lo scopo reale nell'avere costruito questa nuova classe, sarebbe quello di specializzarne la funzione, rispetto alla classe padre.
			Di idee ce ne potrebbero diverse, ma possiamo cercare di capire con un semplice esempio.

			Ammettiamo di voler creare questa nuova classe Button, con lo scopo di renderla standard e utilizzabile per un determinato scopo all'interno della nostra applicazione; questo fa sì che una volta definite le caratteristiche particolari di questo nuovo pulsante, non ci si debba più preoccupare del suo funzionamento all'interno delle procedure in cui lo inseriremo.
			Ammettiamo il molto semplice caso di un pulsante utilizzabile per l'uscita da una Form, ovvero, cliccando su questo pulsante, l'evento di Click ci chiude la form:

			----
			Creiamo il pulsante e le proprietà e i metodi che ci servono:

			'''INHERITS''' Button
			...
			...
			PUBLIC SUB _new()
			...
			Object.Attach(ME, ME, "Event")
			...
			END

			PUBLIC SUB Event_Click()
			ME.Parent.Close()
			END

			----
			Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto "_new()" ([[Metodi nascosti]]), ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).
			Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:
			----

			...
			DIM MyButton AS NEW CloseButton(hForm)
			...

			----
			In questo esempio, mi pare ovvio che la parent diretta del nostro pulsante sia un Form, ma potrebbe anche essere un Panel, o un'altro oggetto contenitore; in questo caso è sufficiente passare l'esatto riferimento alla form per la sua chiusura.

			A parte il puerile esempio che ho descritto, la particolare funzione dell'istruzione '''INHERITS''' è di indubbia utilità, e apre un vasto mondo di possibilità, slegando enormemente lo sviluppo di applicazioni dalle sole librerie di base di Gambas.

38.98.197.215: Annullata la modifica 1573 di Md9327 (discussione)

2011-07-29T10:58:44Z

Annullata la modifica 1573 di Md9327 (discussione)

← Versione meno recente		Versione delle 04:58, 29 lug 2011
Riga 1:		Riga 1:
	'~~''INHERITS''' <ParentClass>~~		There's a seerct about your post. ICTYBTIHTKY

	Questa istruzione nella costruzioni di oggetti (o classi), basati su una specifica classe padre (Parent), e da cui prende tutte le caratteristiche che la identifica: proprietà e metodi. In realtà, dalla classe padre, è possibile derivare solo le proprietà e i metodi dichiarati '''PUBLIC''', mentre per quanto riguarda il resto, '''PRIVATE''', resta di uso strettemente della classe in cui sono dichiarati.
	~~In questa logica sono anche comprese le costanti '''CONST''' (PUBLIC CONST) e le proprietà e i metodi '''STATIC''' (STATIC PUBLIC).~~

	Anche nelle librerie Gambas sono presenti oggetti, le cui caratteristiche derivano dalla inerenza da oggetti superiori; un esempio potrebbe essere la classe Button, che discende dalla classe Control. Un'altro esempio è la stessa classe Form, che seppur dichiarata non creabile dinamicamente, discende dalla classe Window, che a sua volta discende dalla classe Container, che a sua volta discende dalla classe Control.
	Come si può notare, la discendenza, o inerenza, tra gli oggetti può essere molto complessa, ma ad ogni passaggio, ogni fliglio apporta nuove caratteristiche alla classe, rendendola sempre più specializzata.
	Non sono qui ad aprire un discorso sul tema della classi, perchè sarebbe lungo e fuori luogo, e inoltre esiste una montagna si documentazione in giro, che il mio risulterebbe un contributo piuttosto striminzito.

	~~Ma torniamo a noi...~~

	L'istruzione '''INHERITS''' è molto semplice, ma deve essere necessariamente la prima istruzione della classe (ad esclusione delle note...), e l'oggetto ParentClass deve essere già presente nel progetto, o nelle librerie di Gambas.
	Diversamente dalle versioni precedenti di Gambas, ora è possibile derivare un numero imprecisato di sottoclassi, ma non è possibile creare oggetti dipendenti da più di una classe parent contemporaneamente.
	~~Tranne che per gli oggetti Form, e gli oggetti STATIC in generale, inclusi nelle librerie di base, è possibile creare nuove classi derivandoli da quelli già presenti in Gambas.~~
	~~E' sottinteso che qualsiasi altro nostro oggetto, può essere subclassato senza alcun problema.~~

	Una volta che una classe è stata dichiarata sottoclasse di un'altra, ne prende le caratteristiche; ogni modifica alle sue proprietà viene riflessa anche alle proprietà della classe superiore, questo include anche la possibilità di sovrascrivere un determinato metodo in modo che si comporti in modo diverso rispetto alla classe superiore.

	Per fare un esempio, vogliamo creare un oggetto di tipo Button, a cui però vogliamo modificare o aggiungere nuove caratteristiche, oppure addirittura modificarne il comportamento, è sufficiente creare una nuova classe, e dichiararla '''INHERITS''' a ~~Button:~~

	~~----~~
	~~'''INHERITS''' Button~~

	~~----~~

	Una volta definita la sua discendenza dalla classe superiore Button, non è necessario richiarare e ridefinire le caratteristiche che la nuova classe si ingloba con questa unione; questo a meno che non si voglia condizionare alcune delle funzionalità della classe superiore, per meglio adattarle alla nuova classe. Ma, a parte questo, lo scopo reale nell'avere costruito questa nuova classe, sarebbe quello di specializzarne la funzione, rispetto alla classe padre.
	~~Di idee ce ne potrebbero diverse, ma possiamo cercare di capire con un semplice esempio.~~

	Ammettiamo di voler creare questa nuova classe Button, con lo scopo di renderla standard e utilizzabile per un determinato scopo all'interno della nostra applicazione; questo fa sì che una volta definite le caratteristiche particolari di questo nuovo pulsante, non ci si debba più preoccupare del suo funzionamento all'interno delle procedure in cui lo inseriremo.
	~~Ammettiamo il molto semplice caso di un pulsante utilizzabile per l'uscita da una Form, ovvero, cliccando su questo pulsante, l'evento di Click ci chiude la form:~~

	~~----~~
	~~Creiamo il pulsante e le proprietà e i metodi che ci servono:~~

	~~'''INHERITS''' Button~~
	~~...~~
	~~...~~
	~~PUBLIC SUB _new()~~
	~~...~~
	~~Object.Attach(ME, ME, "Event")~~
	~~...~~
	~~END~~

	~~PUBLIC SUB Event_Click()~~
	~~ME.Parent.Close()~~
	~~END~~

	~~----~~
	Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto "_new()" ([[Metodi nascosti]]), ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).
	Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:
	~~----~~

	~~...~~
	~~DIM MyButton AS NEW CloseButton(hForm)~~
	~~...~~

	~~----~~
	In questo esempio, mi pare ovvio che la parent diretta del nostro pulsante sia un Form, ma potrebbe anche essere un Panel, o un'altro oggetto contenitore; in questo caso è sufficiente passare l'esatto riferimento alla form per la sua chiusura.

	A parte il puerile esempio che ho descritto, la particolare funzione dell'istruzione '''INHERITS''' è di indubbia utilità, e apre un vasto mondo di possibilità, slegando enormemente lo sviluppo di applicazioni dalle sole librerie di base di Gambas.

Md9327: Inherits moved to INHERITS: Parole chiave, non funzioni

2008-09-28T10:59:40Z

Inherits moved to INHERITS: Parole chiave, non funzioni

← Versione meno recente	Versione delle 04:59, 28 set 2008
(Nessuna differenza)

213.203.155.10 il 00:13, 26 set 2008

2008-09-26T00:13:57Z

← Versione meno recente		Versione delle 18:13, 25 set 2008
Riga 47:		Riga 47:

	----		----
	Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto "_new()" ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).		Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto "_new()" ([[Metodi nascosti]]), ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).
	Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:		Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:
	----		----

213.203.155.10 il 00:12, 26 set 2008

2008-09-26T00:12:14Z

Nuova pagina

'''INHERITS''' <ParentClass>

Questa istruzione nella costruzioni di oggetti (o classi), basati su una specifica classe padre (Parent), e da cui prende tutte le caratteristiche che la identifica: proprietà e metodi. In realtà, dalla classe padre, è possibile derivare solo le proprietà e i metodi dichiarati '''PUBLIC''', mentre per quanto riguarda il resto, '''PRIVATE''', resta di uso strettemente della classe in cui sono dichiarati.
In questa logica sono anche comprese le costanti '''CONST''' (PUBLIC CONST) e le proprietà e i metodi '''STATIC''' (STATIC PUBLIC).

Anche nelle librerie Gambas sono presenti oggetti, le cui caratteristiche derivano dalla inerenza da oggetti superiori; un esempio potrebbe essere la classe Button, che discende dalla classe Control. Un'altro esempio è la stessa classe Form, che seppur dichiarata non creabile dinamicamente, discende dalla classe Window, che a sua volta discende dalla classe Container, che a sua volta discende dalla classe Control.
Come si può notare, la discendenza, o inerenza, tra gli oggetti può essere molto complessa, ma ad ogni passaggio, ogni fliglio apporta nuove caratteristiche alla classe, rendendola sempre più specializzata.
Non sono qui ad aprire un discorso sul tema della classi, perchè sarebbe lungo e fuori luogo, e inoltre esiste una montagna si documentazione in giro, che il mio risulterebbe un contributo piuttosto striminzito.

Ma torniamo a noi...

L'istruzione '''INHERITS''' è molto semplice, ma deve essere necessariamente la prima istruzione della classe (ad esclusione delle note...), e l'oggetto ParentClass deve essere già presente nel progetto, o nelle librerie di Gambas.
Diversamente dalle versioni precedenti di Gambas, ora è possibile derivare un numero imprecisato di sottoclassi, ma non è possibile creare oggetti dipendenti da più di una classe parent contemporaneamente.
Tranne che per gli oggetti Form, e gli oggetti STATIC in generale, inclusi nelle librerie di base, è possibile creare nuove classi derivandoli da quelli già presenti in Gambas.
E' sottinteso che qualsiasi altro nostro oggetto, può essere subclassato senza alcun problema.

Una volta che una classe è stata dichiarata sottoclasse di un'altra, ne prende le caratteristiche; ogni modifica alle sue proprietà viene riflessa anche alle proprietà della classe superiore, questo include anche la possibilità di sovrascrivere un determinato metodo in modo che si comporti in modo diverso rispetto alla classe superiore.

Per fare un esempio, vogliamo creare un oggetto di tipo Button, a cui però vogliamo modificare o aggiungere nuove caratteristiche, oppure addirittura modificarne il comportamento, è sufficiente creare una nuova classe, e dichiararla '''INHERITS''' a Button:

----
'''INHERITS''' Button

----

Una volta definita la sua discendenza dalla classe superiore Button, non è necessario richiarare e ridefinire le caratteristiche che la nuova classe si ingloba con questa unione; questo a meno che non si voglia condizionare alcune delle funzionalità della classe superiore, per meglio adattarle alla nuova classe. Ma, a parte questo, lo scopo reale nell'avere costruito questa nuova classe, sarebbe quello di specializzarne la funzione, rispetto alla classe padre.
Di idee ce ne potrebbero diverse, ma possiamo cercare di capire con un semplice esempio.

Ammettiamo di voler creare questa nuova classe Button, con lo scopo di renderla standard e utilizzabile per un determinato scopo all'interno della nostra applicazione; questo fa sì che una volta definite le caratteristiche particolari di questo nuovo pulsante, non ci si debba più preoccupare del suo funzionamento all'interno delle procedure in cui lo inseriremo.
Ammettiamo il molto semplice caso di un pulsante utilizzabile per l'uscita da una Form, ovvero, cliccando su questo pulsante, l'evento di Click ci chiude la form:

----
Creiamo il pulsante e le proprietà e i metodi che ci servono:

'''INHERITS''' Button
...
...
PUBLIC SUB _new()
...
Object.Attach(ME, ME, "Event")
...
END

PUBLIC SUB Event_Click()
ME.Parent.Close()
END

----
Come si può vedere, nell'esempio ho derivato la classe (chiamiamola 'CloseButton') dalla classe Button, in modo da prenderne tutte le caratteristiche; tramite il metodo nascosto "_new()" ho fatto in modo da definire un'etichetta precisa "Event" per tutti gli eventi legati al pulsante, e che questi eventi sono dichiarati all'interno della stessa classe: Object.Attach(<oggetto pulsante>, <classe gestore eventi>, <nome eventi>).
Poi ho dichiarato il metodo Event_Click(), per la risposta all'evento di click sul pulsante; all'interno dell'evento è il codice per chiusura della form. Il puntamento alla form viene fatto dalla proprietà "Parent" derivata dalla classe padre Button, a cui è stato passato il riferimento all'oggetto contenitore (la Form), infatti, la creazione del pulsante:
----

...
DIM MyButton AS NEW CloseButton(hForm)
...

----
In questo esempio, mi pare ovvio che la parent diretta del nostro pulsante sia un Form, ma potrebbe anche essere un Panel, o un'altro oggetto contenitore; in questo caso è sufficiente passare l'esatto riferimento alla form per la sua chiusura.

A parte il puerile esempio che ho descritto, la particolare funzione dell'istruzione '''INHERITS''' è di indubbia utilità, e apre un vasto mondo di possibilità, slegando enormemente lo sviluppo di applicazioni dalle sole librerie di base di Gambas.