Creazione di classi avanzate
Quando si definisce una classe JScript, è possibile assegnarle proprietà in modo che possa in seguito ereditare da altre classi. Le proprietà, che sono membri di classe analoghi ai campi, consentono maggiore controllo sulle modalità di accesso ai dati. Utilizzando l'ereditarietà è possibile fare in modo che una classe estenda un'altra classe, ossia che aggiunga caratteristiche al suo funzionamento.
È possibile definire una classe in modo che le relative istanze supportino le proprietà expando. Grazie a queste è possibile aggiungere in modo dinamico proprietà e metodi agli oggetti basati su classi. Alcune funzionalità disponibili con gli oggetti expando basati su classi sono le stesse di quelli basati su prototipi.
Classi con proprietà
In JScript, per specificare proprietà vengono utilizzate le istruzioni function get e function set. È possibile specificare una o entrambe queste funzioni di accesso per creare proprietà di sola scrittura, di sola lettura o di lettura/scrittura. Si noti, peraltro, che le proprietà di sola scrittura sono rare e possono indicare un problema di progettazione della classe.
Il programma chiamante accede alle proprietà allo stesso modo in cui accede ai campi. La principale differenza è che per accedere ad esse vengono utilizzati i metodi per il richiamo e l'impostazione delle proprietà stesse, mentre l'accesso ai campi è diretto. Una classe dotata di proprietà può controllare che siano immesse solo informazioni valide, tenere traccia del numero di volte in cui la proprietà viene letta o impostata, restituire informazioni dinamiche e così via.
Le proprietà vengono generalmente utilizzate per accedere a campi privati o protetti della classe. I campi privati sono contrassegnati con il modificatore private: ad essi possono accedere solo gli altri membri della classe. I campi protetti sono contrassegnati con il modificatore protected: vi possono accedere solo i membri della classe o delle classi derivate. Per ulteriori informazioni vedere Modificatori JScript.
Nell'esempio riportato di seguito le proprietà vengono utilizzate per accedere a un campo protetto. Il campo è protetto per impedire che codice esterno ne modifichi il valore mentre ne è consentito l'accesso ai membri delle classi derivate.
class Person {
// The name of a person.
// It is protected so derived classes can access it.
protected var name : String;
// Define a getter for the property.
function get Name() : String {
return this.name;
}
// Define a setter for the property which makes sure that
// a blank name is never stored in the name field.
function set Name(newName : String) {
if (newName == "")
throw "You can't have a blank name!";
this.name = newName;
}
function sayHello() {
return this.name + " says 'Hello!'";
}
}
// Create an object and store the name Fred.
var fred : Person = new Person();
fred.Name = "Fred";
print(fred.sayHello());
L'output del codice è il seguente:
Fred says 'Hello!'
Se si assegna un nome vuoto alla proprietà Name, verrà generato un errore.
Ereditarietà da classi
Per definire una classe che è basata su un'altra classe, viene utilizzata la parola chiave extends. In JScript è possibile estendere la maggior parte della classi conformi con lo standard CLS (Common Language Specification). Una classe definita utilizzando la parola chiave extends viene denominata classe derivata, mentre la classe estesa viene denominata classe di base.
Nell'esempio riportato di seguito viene definita una nuova classe Student, che estende la classe Person dell'esempio precedente. La classe Student riutilizza la proprietà Name definita nella classe base, ma definisce un nuovo metodo sayHello che esegue l'override del metodo sayHello della classe base.
// The Person class is defined in the code above.
class Student extends Person {
// Override a base-class method.
function sayHello() {
return this.name + " is studying for finals.";
}
}
var mary : Person = new Student;
mary.Name = "Mary";
print(mary.sayHello());
L'output del codice è il seguente:
Mary is studying for finals.
La ridefinizione di un metodo in una classe derivata non modifica il metodo corrispondente della classe base.
Oggetti expando
Per impostare un oggetto generico come expando, utilizzare il costruttore Object.
// A JScript Object object, which is expando.
var o = new Object();
o.expando = "This is an expando property.";
print(o.expando); // Prints This is an expando property.
Per impostare una classe come expando, definire la classe con il modificatore expando. Per accedere ai membri expando è necessario utilizzare la notazione di indice ([]). Non è possibile accedervi utilizzando la notazione punto (.).
// An expando class.
expando class MyExpandoClass {
function dump() {
// print all the expando properties
for (var x : String in this)
print(x + " = " + this[x]);
}
}
// Create an instance of the object and add some expando properties.
var e : MyExpandoClass = new MyExpandoClass();
e["answer"] = 42;
e["greeting"] = "hello";
e["new year"] = new Date(2000,0,1);
print("The contents of e are...");
// Display all the expando properites.
e.dump();
L'output del programma è il seguente:
The contents of e are...
answer = 42
greeting = hello
new year = Sat Jan 1 00:00:00 PST 2000
Vedere anche
Concetti
Creazione di classi personalizzate