20. Interfacce

Posted Mer, 11/26/2008 - 12:50 by Francesco Casula

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.

Le interfacce non definiscono esattamente un tipo di dato come le classi, infatti non è possibile creare un'istanza di un interfaccia, è possibile implementare un'interfaccia solo attraverso la dichiarazione di una classe.

Le interfacce vengono usate per dichiarare metodi che dovranno essere obbligatoriamente definiti da tutte le classi che implementeranno l'interfaccia in questione, non potranno quindi contenere attributi di nessun tipo nè definizioni di metodi, ma solo dichiarazioni di metodi.

La classe che poi implementerà l'interfaccia, dovrà riportare la medesima dichiarazione del metodo così come si presenta nell'interfaccia, e fornire obbligatoriamente una definizione del metodo (corpo del metodo).

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;
		}
	}
	
}

Il codice soprastante viene compilato senza errori e funziona correttamente.
ActionScript 3 infatti ci consente delle modifiche minime alla dichiarazione dei metodi :

  • Possiamo applicare un modificatore di accesso al metodo (public, private ...)
  • E' possibile cambiare i nomi dei parametri a patto che rimangano dello stesso tipo e nello stesso ordine
  • Possiamo modificare i valori di default dei parametri

Non sono ammesse altre modifiche alla dichiarazione dei metodi, ActionScript 3 è molto rigoroso nei controlli e richiederà pertanto che il metodo restituisca un valore del tipo specificato o che non venga restituito alcun valore (void).

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