In questo capitolo costruiremo una classe PhpService per inviare e ricevere dati con PHP in codifica URL, derivando la classe da EventDispatcher.
Questo ci consentirà di gestire gli eventi che ci interessano nel nostro script, aggiungendo eventuali listener direttamente alle istanze di PhpService, come mostrato nel capitolo Gestire gli Eventi.

La nostra classe conterrà quattro attributi :

• private var vars:Array; (Array che conterrà tutte le variabili che saranno inviate allo script PHP in codifica URL)
• private var script:String; (Stringa che indica il nome della pagina PHP che conterrà lo script di nostro interesse)
• public var response:URLVariables; (Conterrà i dati restituiti dallo script PHP in seguito alla richiesta HTTP)
• public static var scriptPath:String; (Variabile statica utilizzata per impostare l'URL di base dove risiedono gli script PHP)

Il costruttore di classe prenderà in input un solo valore che indicherà il nome del file PHP che conterrà lo script di nostro interessa (attributo script).

Prima di dare un'occhiata al codice vediamo quali metodi costituiscono il corpo di classe :

• public function reset():void
  Azzera l'array di variabili che contiene i dati da inviare allo script PHP.
• public function addVar(name:String, content:String):void
  Ogni chiamata al metodo aggiunge una variabile all'array di dati che verrà inviato allo script PHP in codifica URL.
  Il metodo prende due parametri : il primo rappresenta il nome della variabile come verrà letta in PHP attraverso l'array globale $_POST[], mentre il secondo rappresenta il valore contenuto nella variabile.
• public function request():void
  Effettua la richiesta HTTP contattando lo script, inviando e ricevendo i dati con quest'ultimo.
• public function completeHandler(event:Event):void
  Memorizza la risposta dello script PHP nell'attributo pubblico response e solleva l'evento Event.COMPLETE.

Di seguito riporto il codice del costruttore e dei primi due metodi, molto semplici :

// Costruttore della classe
public function PhpService(PhpScript:String = "default.php"):void
{
	// Memorizza il nome del file PHP che contiene lo script di interesse
	this.script = PhpScript;
	// Inizialliza un array vuoto di variabili per l'invio dei dati allo script PHP
	this.vars = new Array();
}

public function reset():void
{ this.vars = new Array(); }

public function addVar(name:String, content:String):void
{
	/*
	La sintassi che segue permette di inserire nell'elemento di un array
	direttamente un oggetto dinamico con due proprietà "name" e "content"
	*/
	this.vars.push({name: name, content: content});
}

public function request():void
{
	var urlencoded:String = new String();

	/* Il ciclo "for" che segue, legge gli elementi dell'array vars e li
	trasforma in una stringa con la codifica URL per l'invio allo script PHP */

	for (var i:uint = 0; i < this.vars.length; i++)
	{
		urlencoded += this.vars[i].name + "=" + this.vars[i].content;
		if ((i + 1) < this.vars.length) urlencoded += "&";
	}

	try
	{
		var variables:URLVariables = new URLVariables(urlencoded);

		var loader:URLLoader = new URLLoader();
		loader.dataFormat = URLLoaderDataFormat.VARIABLES;
		loader.addEventListener(Event.COMPLETE, completeHandler);

		var request:URLRequest = new URLRequest(PhpService.scriptPath + this.script);
		request.method = URLRequestMethod.POST;
		request.data = variables;

		loader.load(request);
	}
	catch (error:Error)
	{ trace("Errore di connessione."); }
}

Per ultimo vediamo il metodo completeHandler, il quale memorizzerà la risposta dello script nell'attributo response e solleverà l'evento Event.COMPLETE in modo da poterlo ricatturare e gestire nella classe documento.

private function completeHandler(event:Event):void
{
	var loader:URLLoader = URLLoader(event.target);
	this.response = new URLVariables(loader.data);

	super.dispatchEvent(new Event(Event.COMPLETE));
}

Di seguito un esempio di classe documento dove viene utilizzata un'istanza di PhpService.

HelloWorld.as

package
{
	import PhpService;
	import flash.events.Event;
	import flash.display.MovieClip;

	public class HelloWorld extends MovieClip
	{
		private var phpserv:PhpService;

		public function HelloWorld():void
		{
			PhpService.scriptPath = "http://localhost/realizzazionesito/";

			this.phpserv = new PhpService("servizio.php");
			this.phpserv.addVar("utente", "mario");
			// this.phpserv.addVar("utente2", "luca");
			// this.phpserv.addVar("utente3", "giovanni");
			this.phpserv.addEventListener(Event.COMPLETE, completeHandler);
			this.phpserv.request();
		}

		private function completeHandler(evt:Event):void
		{
			trace("Return : " + this.phpserv.response);
		}
	}
}

Per la costruzione di una classe più robusta che possa soddisfare i bisogni di un'applicazione reale, vi consiglio di completare il codice di PhpService, aggiungendo la gestione degli eventi che seguono :

addEventListener(Event.COMPLETE, completeHandler); // Questo è già implementato
addEventListener(Event.OPEN, openHandler);
addEventListener(ProgressEvent.PROGRESS, progressHandler);
addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);

L'ereditarietà è uno dei concetti base su cui poggia uno dei paradigmi di programmazione più usati dalle applicazioni moderne, la programmazione orientata agli oggetti, che abbiamo già avuto modo di conoscere nel precedente capitolo sulle classi : Classi

Questo metodo di programmazione ci consente di sfruttare appieno le potenzialità di questo paradigma per i seguenti motivi :

• Specializzazione
• Ridefinizione
• Estensione
• Riutilizzo del codice

ActionScript 3 ci consente di creare una sottoclasse derivata da un'altra mediante la direttiva extends, come mostrato nell'esempio seguente.

Unita.as - Classe Base

package
{
	public class Unita
	{
		protected var attacco:uint;
		protected var difesa:uint;
		protected var distanza:uint;
		protected var velocita:uint;

		public function Unita():void
		{ /* ... Costruttore ... */ }
	}
}

Fante.as - Classe Derivata

package
{
	import Unita;

	public class Fante extends Unita // "Fante" eredita da "Unita"

	{
		protected var puntiferita:uint;

		public function Fante():void
		{
			this.attacco = 10;
			this.difesa = 20;
			this.distanza = 1;
			this.velocita = 5;

			this.puntiferita = 100;
		}
	}
}

Come possiamo notare dall'esempio soprastante, la classe "Fante" eredita i quattro attributi protected dichiarati nella classe "Unita".
Nota : protected è un modificatore di accesso che restringe la visibilità dei membri alla sola classe base ed alle sue derivate.

Ridefinizione dei Metodi

Per ridefinire un metodo in ActionScript 3, si usa la direttiva override seguita dalla dichiarazione del metodo, che dovrà rispecchiare esattamente la struttura del metodo base o il compilatore restituirà il messaggio "Override incompatibile".

Questo significa che se il metodo base prende un determinato numero di parametri di un tipo stabilito, il metodo che andrà a ridefinirlo dovrà prendere gli stessi parametri dello stesso tipo.

Un metodo sarà ridefinibile solo se dichiarato pubblico, protetto o interno.
Se dichiarato privato sarà comunque possibile definire un metodo con lo stesso nome nella classe derivata, in quanto il metodo della classe base non sarà visibile all'esterno (private), e procederemo quindi senza la direttiva override.

Di seguito un semplice esempio dove ridefiniremo il metodo "muovi()" :

Unita.as - Classe Base

package
{
	public class Unita
	{
		protected var attacco:int;
		protected var difesa:int;
		protected var distanza:int;
		protected var velocita:int;

		public function Unita():void
		{ /* ... Costruttore ... */ }

		public function muovi(passi:uint):void
		{
			/* Sposta l'unita di N passi */
			trace("Chiamata a 'Unita.muovi()'");
		}
	}
}

Fante.as - Classe Derivata

package
{
	import Unita;
	
	public class Fante extends Unita
	{
		public function Fante():void
		{
			this.attacco = 10;
			this.difesa = 20;
			this.distanza = 1;
			this.velocita = 5;
		}

		override public function muovi(passi:uint):void
		{
			trace("Chiamata a 'Fante.muovi()'");
		}
	}
}

HelloWorld.as - Classe documento

package
{
	import Fante;
	import flash.display.MovieClip;

	public class HelloWorld extends MovieClip
	{
		public function HelloWorld():void
		{
			var soldato:Fante = new Fante();
			soldato.muovi(10); // Output : Chiamata a 'Fante.muovi()'
		}
	}
}

Se non avessimo effettuato un override nella classe Fante, la chiamata al metodo "muovi()" avrebbe provocato il seguente output :
Chiamata a 'Unita.muovi()'

Fante.as - Classe Derivata

package
{
	import Unita;
	
	public class Fante extends Unita
	{
		public function Fante():void
		{
			this.attacco = 10;
			this.difesa = 20;
			this.distanza = 1;
			this.velocita = 5;
		}

		override public function muovi(passi:uint):void
		{
			super.muovi(passi * this.velocita);
			trace("Chiamata a 'Fante.muovi()'");
		}
	}
}

Richiamando la classe documento HelloWorld si ottiene il seguente output :
Chiamata a 'Unita.muovi()'
Chiamata a 'Fante.muovi()'

Nota : vengono ereditati tutti i membri che non sono private e statici.

Teoria sulle classi

Questo è senzaltro uno dei capitoli essenziali della presente guida, dal momento che ActionScript 3 si è evoluto, rispetto ai suoi predecessori, basandosi fortemente sulla programmazione orientata agli oggetti (OOP).

La programmazione orientata agli oggetti è un metodo di sviluppo ormai molto diffuso, poichè consente di risparmiare molto tempo rendendo la scrittura del codice più intuitiva e l\'applicazione più robusta, accorciando le distanze fra la cruda programmazione e il mondo reale.

In linea di massima e limitando molto il concetto, possiamo pensare ad un oggetto semplicemente come ad un nuovo tipo di dato creato da noi, con particolari attributi e metodi per gestirlo.

Immaginiamo ora di dover scrivere un\'applicazione che disegna sullo stage un triangolo.
Per disegnare il triangolo innanzitutto ci saranno necessarie le coordinate dei suoi punti, ed essendo un triangolo ne avrà tre.

Con le nozioni apprese fino ad ora potremmo memorizzare questi dati all'interno di varibili o ancora meglio all'interno di un array.
Avendo ogni punto due coordinate (x e y) sarà quindi necessario un array di 6 elementi come mostrato di seguito :

function disegnaTriangolo(triangolo:Array):void
{ /* Codice per disegnare il triangolo */ }

var triangolo:Array = new Array();

triangolo["x1"] = 5;
triangolo["y1"] = 10;
triangolo["x2"] = 30;
triangolo["y2"] = 40;
triangolo["x3"] = 70;
triangolo["y3"] = 90;

disegnaTriangolo(triangolo);

L'esempio soprastante non è certo il migliore dei modi per gestire il problema proposto, soprattutto se supponiamo di dover disegnare molti triangoli, il codice diventerebbe allora una lunga e pesante matassa di assegnazioni.

Iniziamo a dare una sfoltita al codice immaginando di poter creare il nuovo tipo di dato Punto.
Assieme a questa nuova classe potremmo, ad esempio, creare ancora un nuovo tipo che chiameremo Triangolo, che avrà al suo interno tre variabili del tipo Punto.

Il codice si presenterebbe così :

var triangolo1:Triangolo = new Triangolo(new Punto(5, 10), new Punto(30, 40), new Punto(70, 90));
triangolo.disegna();

Il sorgente non è solo più pulito e intuitivo, ma il codice per definire le classi Punto e Triangolo, sarà universale e potrete utilizzarlo per tutte le vostre applicazioni senza alcuna necessità di riscriverlo.

I vantaggi che potrete trarre da questo metodo di programmazione sono innumerevoli, e vi saranno tutti molto più chiari man mano che andrete avanti con la lettura, imparando a pensare alle vostre applicazioni direttamente come ad una serie di oggetti in relazione fra loro.

Le classi in ActionScript 3

Le classi in ActionScript 3 devono avere obbligatoriamente un package di appartenenza, concetto che illustrerò più avanti, intendendo per ora i package come dei semplici contenitori di classi.

Le classi dovranno essere scritte in file esterni con estensione .as.
Per farlo è sufficiente aprire il Blocco note e salvare i file con l'estensione specificata pocanzi, oppure tramite Flash CS3 creando un nuovo File ActionScript (CTRL + N).

Per dichiarare una classe abbiamo a disposizione l'istruzione class :

package
{
	public class MiaClasse
	{
		// Corpo della classe
	}
}

var contenitore:MiaClasse = new MiaClasse();

Nell'esempio soprastante, "contenitore" è un'istanza della classe "MiaClasse".

Una classe può definire degli attributi e dei metodi, che sarà possibile richiamare attraverso un'istanza seguita dall'operatore di selezione ".".

Potete pensare agli attributi (detti anche proprietà) come a delle variabili proprie dell'oggetto, e potete pensare ai metodi come a delle funzioni proprie dell'oggetto.

Vediamo un esempio in cui dichiaro una classe Punto con due attributi x e y e un metodo output :

package
{
	public class Punto
	{
		var x:Number; // Attributo
		var y:Number; // Attributo

		function output():void // Metodo
		{
			trace("x = " + this.x);
			trace("y = " + this.y);
		}
	}
}

In questo frammento di codice possiamo osservare una nuova istruzione : this.
this è una sorta di puntatore che ci consente di accedere agli attributi e ai metodi della classe, dall'interno di quest'ultima.

Vediamo ora il codice che ci permetterà di utilizzare la classe inizializzandone un'istanza, e accedendo agli attributi mediante essa.

var p1:Punto = new Punto();

// Usiamo l'operatore di selezione "." per accedere agli attributi
p1.x = 10;
p1.y = 12;

// Chiamiamo il metodo dell'oggetto
p1.output();

L'output prodotto dal metodo output dell'istanza "p1" è il seguente :

x = 10
y = 12

In questo capitolo continueremo il discorso sulle classi, introducendo nozioni che ci consentiranno un controllo maggiore e più efficace con questi strumenti.

Abbiamo visto come un metodo può gestire e manipolare gli attributi della classe a cui appartiene, agendo come una vera e propria funzione, ma interna alla classe.

Costruttori

Esiste un metodo molto importante chiamato costruttore della classe.
Il costruttore verrà richiamato automaticamente ad ogni creazione di un'istanza, ed è possibile definirne uno personalizzato.

Per dichiarare un costruttore è sufficiente dichiarare un normale metodo ma con lo stesso nome della classe :

Punto.as

package
{
	public class Punto
	{
		/* Attributi */
		var x:Number;
		var y:Number;

		/* Costruttore */
		function Punto(nuova_x:Number, nuova_y:Number)
		{
			this.x = nuova_x;
			this.y = nuova_y;
		}

		/* Metodo */
		function output():void
		{
			trace("x = " + this.x);
			trace("y = " + this.y);
		}
	}
}

Il costruttore, essendo un metodo, può prendere dei parametri alla stessa maniera di una funzione tradizionale.
Questi parametri saranno utilizzati in sostanza per inizializzare correttamente gli attributi della classe.

HelloWorld.as

package
{
	import Punto;
	import flash.display.MovieClip;

	public class HelloWorld extends MovieClip
	{
		public function HelloWorld():void
		{
			var p1:Punto = new Punto(14, 65);
			p1.output();
		}
	}
}

L'output prodotto dall'esempio soprastante (HelloWorld) è il seguente :

x = 14
y = 65

Modificatori di accesso

In ActionScript 3 è possibile assegnare dei particolari modificatori agli attributi di una classe, per assegnare ad essi un determinato livello di accessibilità e visibilità.

I modificatori di accesso si specificano subito prima il nome dell'attributo o del metodo e ne esistono quattro :

• internal - Restringe la visibilità al pacchetto (package) di appartenenza
• public - I membri (attributi o metodi) dichiarati come public, saranno accessibili a tutte le classi e da tutti i pacchetti visibili
• private - Questi membri possono essere utilizzati solo all'interno della classe madre
• protected - Restringe l'accesso solo all'interno della classe madre e alle classi derivate

Punto.as

package
{
	public class Punto
	{
		private var x:Number;
		private var y:Number;

		public function Punto(nuova_x:*, nuova_y:*)
		{
			this.x = new Number(nuova_x);
			this.y = new Number(nuova_y);
		}

		public function output():void
		{
			trace("x = " + this.x);
			trace("y = " + this.y);
		}
	}
}

Questo metodo ci consente di evitare assegnazioni di tipo non desiderato, ricevendo un errore 1178 nel caso in cui questo avvenga :
Tentativo di accesso alla proprietà non accessibile x mediante un riferimento con tipo statico Punto.

HelloWorld.as

package
{
	import Punto;
	import flash.display.MovieClip;

	public class HelloWorld extends MovieClip
	{
		public function HelloWorld():void
		{
			var p1:Punto = new Punto("28.7", "68.4");
			p1.output();
		}
	}
}

L'esempio soprastante produce il seguente output :

x = 28.7
y = 68.4