Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Come usare il costruttore Class

Un componente fondamentale della libreria
Un componente fondamentale della libreria
Link copiato negli appunti

Il costruttore Class rappresenta la parte fondamentale di MooTools, quella dalla quale prende vita la maggior parte degli altri componenti.

Il costruttore Class è un oggetto "factory", il che significa che permette di creare altri oggetti, che siano altre classi oppure oggetti istanza che costituiscono appunto delle "rappresentazioni pratiche" delle nostre classi.

Nella prima lezione abbiamo visto che MooTools è un framework completamante orientato agli oggetti. Questa caratteristica diviene realtà proprio grazie al costruttore Class, che rappresenta una rivoluzione rispetto alle normali meccaniche basate sull'ereditarietà dei prototipi degli oggetti offerte nativamanete da Javascript, pur basandosi sullo stesso meccanismo.

Superclassi e sottoclassi

Prima di passare all'analisi dell'oggetto Class, riprendiamo i concetti di superclasse e sottoclasse tipici della programmazione object-oriented. Una superclasse è una classe "astratta" che contiene funzionalità di base condivisibili tra più sottoclassi. Una sottoclasse, invece, è una classe che estende le funzionalità di una superclasse (detta anche classe parente) e da essa ne eredita le funzionalità. In MooTools esistono molte superclassi (Fx ad esempio) che vengono estese dalle rispettive sottoclassi (Fx.Tween, Fx.Morph e cosi via). Infine, una gerarchia non è limitata a sole due classi, ma può avere un qualsiasi numero di diramazioni e sottoclassi.

Creare una gerarchia di classi utilizzando l'oggetto Class

Per creare una classe è necessario passare al costruttore Class un oggetto che contiene i metodi e le proprietà della nostra nuova classe. In particolare il metodo initialize rappresenta il metodo che funge da costruttore per le nostre istanze. Vediamo un esempio pratico: la classe Person.

var Person = new Class({

	initialize: function(name, age) {
		this.name = name;
		this.age = age;
	},
	
	setName: function(name) {
		this.name = name;
	},
	
	setAge: function(age) {
		this.age = age;
	},
	
	getName: function() {
		return this.name;
	},
	
	getAge: function() {
		return this.age;
	}

});

Come detto in precedenza, initialize rappresenta il metodo costruttore mentre i metodi setName, setAge, getName e getAge costituiscono i metodi pubblici che possiamo utilizzare. Vediamo ora come creare un'istanza della classe Person:

var george = new Person('George', 48);

// restituisce 48
george.getAge();

// ora la proprietà age è pari a 49
george.setAge(49);

Ovviamente la classe Person è una classe molto astratta. Se vogliamo creare qualcosa di più specifico, dobbiamo creare delle sottoclassi che ereditano da Person ed estendono le sue funzionalità. Vediamo ad esempio la classe Boy:

var Boy = new Class({

	Extends: Person,

	initialize: function(name, age) {
		this.parent(name, age);
	},
	
	likesFootball: function() {
		return true;
	}

});

Tramite la proprietà Extends, la classe Boy eredita tutti i metodi e le proprietà offerti dalla superclasse Person, che ovviamente possono essere ampliati con nuove funzionalità. Il metodo parent infine, richiama il metodo con lo stesso nome presente nella superclasse.

Tutte le classi avanzate presenti in MooTools sono create attraverso questa modalità, il che favorisce una solida struttura OOP basata sulle classi, mai ripetitiva o ridondante.

Implementare nuove funzionalità nella superclasse

Se vogliamo aggiungere nuove proprietà o metodi alla nostra superclasse Person, ma non vogliamo alterare la struttura di base (ad esempio, possiamo compiere questa operazione all'interno di un secondo script), possiamo utilizzare il metodo implement che accetta un oggetto contenente i nuovi metodi/proprietà.

Person.implement({

	setGender: function(gender) {
		this.gender = gender;
	},
	
	getGender: function() {
		return this.gender;
	}

});

In questo caso abbiamo aggiunto i due nuovi metodi alla classe Person, alterando il suo oggetto prototype.

La resa data da questa modalità è la stessa data dall'utilizzo della proprietà Implements, con la differenza che con il metodo implement l'estensione può essere effettuata in un secondo momento.

Conclusione

In questa lezione abbiamo visto l'importanza del costruttore Class e come creare una semplice gerarchia avvalendoci di quest'ultimo. Ma non abbiamo ancora detto tutto su Class: nella prossima lezione infatti, ci aspettano le Class Extras.


Ti consigliamo anche