I veterani di ActionScript 2 avranno già familiarità con le interfacce, un metodo molto utile per fornire strumenti standard a classi non necessariamente in relazione fra loro.

Vediamo due interfacce di esempio ...

InterfacciaUno.as

package
{
	public interface InterfacciaUno
	{
		function MetodoInterfacciaUno(parametro:uint = 5):uint;
		function AltroMetodoInterfacciaUno(parametro:uint, altroparametro:Boolean = false):uint;
	}
}

InterfacciaDue.as

package
{
	public interface InterfacciaDue
	{
		function MetodoInterfacciaDue(parametro:String = null):uint;
		function AltroMetodoInterfacciaDue(parametro:uint = 10, altroparametro:Boolean = true):uint;
	}
}

Come avrete notato dal codice soprastante, non ho specificato alcun modificatore di accesso nella dichiarazione dei metodi d'interfaccia, poichè ActionScript 3 non lo consente.

A seguire la dichiarazione di una classe "Oggetto" che implementa entrambe le interfacce riportate sopra, attraverso la direttiva implements, che consente di implementare più interfacce separate da una virgola :

Oggetto.as

package
{
	import InterfacciaUno;
	import InterfacciaDue;

	public class Oggetto implements InterfacciaUno, InterfacciaDue
	{
		public function Oggetto():void
		{
			// Costruttore
		}

		public function MetodoInterfacciaUno(par:uint = 3):uint
		{
			return par + 2;
		}

		public function AltroMetodoInterfacciaUno(par:uint, altroparametro:Boolean = false):uint
		{
			if (altroparametro) return par + 2;
			else return par - 2;
		}

		public function MetodoInterfacciaDue(parametro:String = null):uint
		{
			return parametro.length + 1;
		}

		public function AltroMetodoInterfacciaDue(parametro:uint = 10, altroparametro:Boolean = true):uint
		{
			if (altroparametro) return parametro * 2;
			else return parametro / 2;
		}
	}
	
}

Note :

• Una classe può estendere solo un'altra classe (ereditarietà)
• Una classe può implementare più di una interfaccia
• Un'interfaccia può estendere più interfacce (ereditarietà multipla)
• Un'interfaccia non può implementare un'altra interfaccia

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.

Costanti

Possiamo definire le costanti come delle variabili di sola lettura, poichè una volta dichiarate e definite, non sarà possibile modificarne il valore in fase di run-time.

Nella dichiarazione di una costante è possibile omettere la parola chiave var, utilizzando solamente la direttiva const in questo modo :

const MAX_UTENTI:int = 10;

Nella stessa maniera è possibile dichiarare delle costanti come attributi di una classe :

package
{
	public class ChatRoom
	{
		public const MAX_UTENTI:int = 10;
		public var nome_stanza:String;

		// ...
	}
}

Le costanti possono essere anche statiche, in modo che siano appartenenti solo alla classe e quindi non utilizzabili tramite istanze.

package
{
	public final class Colori
	{
		public static const Rosso:String = "#FF0000";
		public static const Verde:String = "#00FF00";
		public static const Blu:String = "#0000FF";
		// ...
	}
}

Potete anche creare un'istanza della classe "Colori", ma questa sarà inutile in quanto non possiederà alcun metodo o attributo utilizzabile, semplicemente ActionScript 3 non esegue alcun controllo di questo tipo.

HelloWorld.as

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

	public class HelloWorld extends MovieClip
	{
		public function HelloWorld():void
		{
			trace("Il valore esadecimale del colore rosso è " + Colori.Rosso);
		}
	}
}

L'esempio produce il seguente output :
Il valore esadecimale del colore rosso è #FF0000