Metodi -- Flash CS3

I metodi sono funzioni che fanno parte di una definizione di classe. Una volta creata un'istanza della classe, un metodo viene associato a tale istanza. A differenza delle funzioni dichiarate all'esterno delle classi, i metodi possono essere utilizzati esclusivamente dall'istanza alla quale sono associati.

I metodi vengono definiti utilizzando la parola chiave function. È possibile utilizzare una funzione con istruzione, come nell'esempio seguente:

public function sampleFunction():String {}

Oppure è possibile utilizzare una variabile alla quale viene assegnata un'espressione della funzione, come nell'esempio seguente:

public var sampleFunction:Function = function () {}

Nella maggior parte dei casi, è consigliabile utilizzare una funzione con istruzione anziché un'espressione della funzione per le ragioni seguenti:

Un caso in cui è consigliabile l'uso di un'espressione della funzione è quando si decide di associare una funzione all'oggetto prototype. Per ulteriori informazioni, vedere Oggetto prototype.

Sezioni

Metodi delle funzioni di costruzione

I metodi delle funzioni di costruzione, talvolta semplicemente dette funzioni di costruzione, sono funzioni che condividono lo stesso nome della classe nella quale vengono definite. Qualsiasi codice incluso in un metodo di funzione di costruzione viene eseguito ogni volta che viene creata un'istanza della classe con la parola chiave new. Ad esempio, il seguente codice definisce una semplice classe chiamata Example, contenente un'unica proprietà denominata status. Il valore iniziale della variabile status viene definito all'interno della funzione di costruzione.

class Example
{
    public var status:String;
    public function Example()
    {
        status = "initialized";
    }
}

var myExample:Example = new Example();
trace(myExample.status); // output: inizializzato

I metodi delle funzioni di costruzione possono essere solo pubblici, tuttavia, l'impiego dell'attributo public è facoltativo. Nelle funzioni di costruzione non è possibile usare nessuno degli altri specificatori del controllo di accesso, incluso private, protected o internal. Con i metodi delle funzioni di costruzione non è inoltre possibile utilizzare spazi dei nomi definiti dall'utente.

Una funzione di costruzione può effettuare una chiamata esplicita alla funzione di costruzione della sua superclasse diretta mediante l'istruzione super(). Se la funzione di costruzione della superclasse non viene esplicitamente chiamata, il compilatore inserisce automaticamente una chiamata prima della prima istruzione nel corpo della funzione di costruzione. Per chiamare i metodi della superclasse, è inoltre possibile utilizzare il prefisso super come riferimento alla superclasse. Se si decide di utilizzare sia super() che super nello stesso corpo della funzione di costruzione, assicurarsi di chiamare prima super(). In caso contrario, il riferimento super non funzionerà correttamente. La funzione di costruzione super() deve inoltre essere chiamata prima di eventuali istruzioni throw o return.

Nell'esempio che segue è illustrato cosa accade se si tenta di utilizzare il riferimento super prima di chiamare la funzione di costruzione super(). Una nuova classe, ExampleEx, estende la classe Example. La funzione di costruzione ExampleEx tenta di accedere alla variabile status definita all'interno della sua superclasse, ma lo fa prima di chiamare super(). L'istruzione trace() che si trova all'interno della funzione di costruzione ExampleEx genera il valore null, in quanto la variabile status non risulta disponibile fino all'esecuzione della funzione di costruzione super().

class ExampleEx extends Example
{
    public function ExampleEx()
    {
        trace(super.status);
        super();
    }
}

var mySample:ExampleEx = new ExampleEx(); // output: null

Nonostante sia possibile utilizzare l'istruzione return all'interno di una funzione di costruzione, non è consentito che venga restituito un valore. In altre parole, le istruzioni return non devono avere espressioni o valori associati. Di conseguenza, i metodi delle funzioni di costruzione non possono restituire valori, ovvero non è possibile specificare tipi restituiti.

Se non si definisce un metodo di funzione di costruzione nella classe, il compilatore crea automaticamente una funzione di costruzione vuota. Se la classe viene estesa a un'altra classe, il compilatore includerà una chiamata super() nella funzione di costruzione generata.

Metodi statici

I metodi statici, chiamati anche metodi di classe, sono metodi che vengono dichiarati con la parola chiave static. I metodi statici, generalmente associati a una classe anziché all'istanza di una classe, sono utili per incorporare funzionalità relative a qualcosa di diverso dallo stato di singole istanze. Poiché i metodi statici vengono associati a un'intera classe, è possibile accedervi solo attraverso la classe stessa e non attraverso un'istanza della classe.

I metodi statici sono utili per incorporare funzioni che non si limitano a modificare lo stato delle istanze di classe. In altre parole, un metodo si definisce statico se fornisce funzionalità che non intervengono direttamente sul valore di un'istanza di classe. Ad esempio, la classe Date presenta un metodo statico denominato parse() che converte una stringa in un numero. Tale metodo è statico in quanto non modifica una singola istanza della classe. Il metodo parse() prende invece una stringa che rappresenta un valore data, l'analizza e restituisce un numero in un formato compatibile con la rappresentazione interna dell'oggetto Date. Questo metodo non è un metodo di istanza, in quanto non avrebbe senso applicarlo a un'istanza della classe Date.

Il metodo statico parse() è in contrasto con i metodi di istanza della classe Date, quale getMonth(). Il metodo getMonth() è un metodo di istanza, in quanto opera direttamente sul valore recuperando un componente specifico, il mese, di un'istanza Date.

Poiché i metodi statici non sono associati a singole istanze, non è possibile utilizzare le parole chiave this o super all'interno del corpo di un metodo statico. Sia il riferimento this che super hanno significato solo nel contesto di un metodo di istanza.

Diversamente da quanto accade in altri linguaggi di programmazione basati su classi, i metodi statici in ActionScript 3.0 non vengono ereditati. Per ulteriori informazioni, vedere Proprietà statiche non ereditate.

Metodi di istanza

I metodi di istanza sono metodi dichiarati senza la parola chiave static. Questi metodi, che vengono associati alle istanze di una classe anziché all'intera classe, sono utili per implementare funzionalità che riguardano singole istanze di una classe. Ad esempio, la classe Array contiene un metodo di istanza denominato sort() che opera direttamente sulle istanze Array.

Nel corpo di un metodo di istanza, sono valide sia le variabili statiche che di istanza, il che significa che è possibile fare riferimento alle variabili definite all'interno della stessa classe mediante un semplice identificatore. Ad esempio, la classe CustomArray seguente estende la classe Array. La classe CustomArray definisce una variabile statica denominata arrayCountTotal che registra il numero totale di istanze della classe, una variabile di istanza denominata arrayNumber che registra l'ordine in cui le istanze sono state create e un metodo di istanza denominato getPosition() che restituisce i valori di tali variabili.

public class CustomArray extends Array
{
    public static var arrayCountTotal:int = 0;
    public var arrayNumber:int;

    public function CustomArray()
    {
        arrayNumber = ++arrayCountTotal;
    }
    
    public function getArrayPosition():String
    {
         return ("Array " + arrayNumber + " of " + arrayCountTotal);
    }
}

Se il codice esterno alla classe deve fare riferimento alla variabile statica arrayCountTotal mediante l'oggetto di classe, utilizzando CustomArray.arrayCountTotal, il codice che risiede nel corpo del metodo getPosition() può fare riferimento direttamente alla variabile statica arrayCountTotal. Ciò vale anche per le variabili statiche contenute nelle superclassi. Anche se le proprietà statiche non vengono ereditate in ActionScript 3.0, quelle presenti nelle superclassi sono nell'area di validità. Ad esempio, la classe Array presenta poche variabili statiche, una delle quali è una costante denominata DESCENDING. Il codice residente in una delle sottoclassi di Array può fare riferimento alla costante statica DESCENDING mediante un semplice identificatore.

public class CustomArray extends Array
{
    public function testStatic():void
    {
        trace(DESCENDING); // output: 2
    }
}

Il valore del riferimento this nel corpo di un metodo di istanza è un riferimento all'istanza alla quale il metodo è associato. Il codice seguente illustra come il riferimento this punti all'istanza contenente il metodo:

class ThisTest
{
    function thisValue():ThisTest
    {
        return this;
    }
}

var myTest:ThisTest = new ThisTest();
trace(myTest.thisValue() == myTest); // output: true

L'ereditarietà dei metodi di istanza può essere controllata con le parole chiave override e final. Utilizzare l'attributo override per ridefinire un metodo ereditato e l'attributo final per impedire alle sottoclassi di sostituire un metodo. Per ulteriori informazioni, vedere Sostituzione di metodi.

Metodi supplementari get e set

Le funzioni get e set, chiamate anche getter e setter, consentono di rispettare i principi di programmazione dell'information hiding e dell'incapsulamento, fornendo un'interfaccia di programmazione facile da usare per le classi create. Le funzioni get e set permettono di mantenere le proprietà della classe private all'interno della classe stessa, pur consentendo agli utenti della classe di accedere a tali proprietà come se stessero accedendo a una variabile di classe anziché chiamare un metodo di classe.

Il vantaggio di questo tipo di approccio è che consente di non utilizzare le funzioni accessor tradizionali con nomi poco pratici, quali getPropertyName() e setPropertyName(). Un altro vantaggio delle funzioni getter e setter è che evitano di gestire due funzioni pubbliche per ciascuna proprietà che consente l'accesso sia di lettura che di scrittura.

Nell'esempio seguente, la classe GetSet include le funzioni accessor get e set denominate publicAccess() che consentono l'accesso alla variabile privata denominata privateProperty:

class GetSet
{
    private var privateProperty:String;
    
    public function get publicAccess():String
    {
        return privateProperty;
    }
    
    public function set publicAccess(setValue:String):void
    {
        privateProperty = setValue;
    }
}

Se si tenta di accedere alla proprietà privateProperty direttamente, si verifica l'errore seguente:

var myGetSet:GetSet = new GetSet();
trace(myGetSet.privateProperty); // errore

Gli utenti della classe GetSet utilizzeranno invece qualcosa che appare come una proprietà denominata publicAccess, ma che in realtà è una coppia di funzioni get e set che operano sulla proprietà privata chiamata privateProperty. Nell'esempio seguente viene creata un'istanza della classe GetSet, quindi viene impostato il valore di privateProperty mediante l'accessor pubblico denominato publicAccess:

var myGetSet:GetSet = new GetSet();
trace(myGetSet.publicAccess); // output: null
myGetSet.publicAccess = "hello";
trace(myGetSet.publicAccess); // output: hello

Le funzioni getter e setter consentono inoltre di sostituire le proprietà ereditate da una superclasse, cosa non possibile se si utilizzano normali variabili membro di classe. Le variabili membro di classe dichiarate con la parola chiave var non possono essere sostituite in una sottoclasse. Le proprietà create con le funzioni getter e setter invece non presentano questo limite. È possibile utilizzare l'attributo override sulle funzioni getter e setter ereditate da una superclasse.

Metodi vincolati

Un metodo vincolato, o chiusura di un metodo, è semplicemente un metodo estratto dalla propria istanza. Tra gli esempi di metodi vincolati vi sono metodi passati come argomenti a una funzione o restituiti come valori da una funzione. Tra le novità di ActionScript 3.0 vi è un metodo vincolato simile a una chiusura di funzione, in quanto in grado di conservare il proprio ambiente lessicale anche se estratto dall'istanza a cui è associato. Tuttavia, la principale differenza tra un metodo vincolato e una chiusura di funzione è che il riferimento this del metodo vincolato resta collegato, o vincolato, all'istanza che implementa il metodo. In altre parole, il riferimento this in un metodo vincolato punta sempre all'oggetto originale cha ha implementato il metodo. Nelle funzioni di chiusura, il riferimento this è generico, vale a dire che punta a qualsiasi oggetto associato alla funzione nel momento in cui viene chiamato.

Una corretta comprensione dei metodi vincolati è importante se si utilizza la parola chiave this. Il richiamo della parola chiave this fornisce un riferimento a un oggetto principale del metodo. Per la maggior parte dei programmatori ActionScript la parola chiave this fa sempre riferimento all'oggetto o alla classe che contiene la definizione di un metodo. Senza i metodi vincolati, tuttavia, ciò non sarebbe sempre possibile. Nelle versioni precedenti di ActionScript, ad esempio, il riferimento this non era sempre riferito all'istanza che aveva implementato il metodo. Se in ActionScript 2.0 i metodi vengono estratti da un'istanza, non solo il riferimento this resta vincolato all'istanza originale, ma le variabili di membro e i metodi della classe dell'istanza non risultano disponibili. Il problema non esiste in ActionScript 3.0, in quanto i metodi vincolati vengono automaticamente creati quando un metodo viene passato come parametro. I metodi vincolati garantiscono che la parola chiave this faccia sempre riferimento all'oggetto o alla classe nella quale il metodo viene definito.

Il codice seguente definisce una classe denominata ThisTest, contenente un metodo chiamato foo() che definisce a sua volta il metodo vincolato e un metodo bar() che restituisce il metodo vincolato. Il codice esterno alla classe crea un'istanza della classe ThisTest, chiama il metodo bar() e memorizza il valore restituito in una variabile denominata myFunc.

class ThisTest
{
    private var num:Number = 3;
    function foo():void // metodo vincolato definito
    {
        trace("foo's this: " + this);
        trace("num: " + num);
    }
    function bar():Function
    {
        return foo; // metodo vincolato restituito
    }
}

var myTest:ThisTest = new ThisTest();
var myFunc:Function = myTest.bar();
trace(this); // output: [oggetto global]
myFunc();    
/* output: 
this di foo: [oggetto ThisTest]
output: num: 3 */

Le ultime due righe del codice mostrano che il riferimento this del metodo vincolato foo() continua a puntare a un'istanza della classe ThisTest, anche se il riferimento this che si trova nella linea precedente punta all'oggetto global. Inoltre, il metodo vincolato memorizzato nella variabile myFunc può ancora accedere alle variabili di membro della classe ThisTest. Se lo stesso codice viene eseguito in ActionScript 2.0, il riferimento this corrisponderebbe e la variabile num risulterebbe undefined.

Un'area in cui l'inserimento dei metodi vincolati è più evidente è quella dei gestori di eventi, in quanto il metodo addEventListener() richiede il passaggio di una funzione o di un metodo come argomento. Per ulteriori informazioni, vedere Funzione listener definita come metodo di classe.