Object Oriented Programming - lezione 4 - attributi delle proprietà

[Flep]

Ciao a tutti !

Prodeguono gli articoli/lezione riguardanti la Object Oriented Programming.

La volta scorsa abbiamo visto come creare un metodo di una classe Actionscript 3.0 .

Ora, dato che Flash CS3 ha implementato alcuni attributi per le proprietà di una classe, è il momento ideale per vedere insieme che differenza c'è tra un proprietà con attributo private da una con attributo public. Oppure tra protected e internal.

Vedremo a che pro assegnare un coretto attributo all nostre proprietà e come definirlo.

Imparare bene queste cose è fondamentale nella OOP.



Vediamo gli esempi...

private - public - protected e internal


Partiamo subito col dire che gli attributi disponibili per una proprietà Actionscript 3.0 sono quattro:

1. private: le proprietà sono accessibili solo dall' interno della classe
2. public: le proprietà sono accessibili dall' interno della classe, dalle istanze della classe stessa e direttamente se implementate dell' attributo static ( che vedremo )
3. protected: le proprietà sono accessibili solo dall' interno della classe o dalle sue sottoclassi ( le sottoclassi le vedremo quando toccheremo il tema Ereditarietà )
4. internal: le proprietà sono accessibili dall' interno del package

Gli attributi più sati sono private e public.

Creo una semplice classe Quarta.as che associo come Document Class di quarta.fla .

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        public function Quarta()
        {
            
        }
    }
}

Adesso gli definisco una proprietà:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        private var nome:String='Filippo';
        
        public function Quarta()
        {
            trace(nome);
        }
    }
}

Come abbiamo già visto nella lezione 2
, otteniamo questo output:

Filippo

Quindi questo ci fa capire che siamo riusciti a recuperare il valore della proprietà nome in quanto la proprietà è accessibile dall' interno della classe, infatti l' ho chiamata proprio dal suo interno, più precisamente dalla sua funzione costruttrice.

Ok, fin quì niente di nuovo.

Proviamo ora ad assegnare l' attributo public a Quarta:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        public var nome:String='Filippo';
        
        public function Quarta()
        {
            trace(nome);
        }
    }
}

otteniamo lo stesso output.

Proviamo ad assegnare l' attributo protected:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        protected var nome:String='Filippo';
        
        public function Quarta()
        {
            trace(nome);
        }
    }
}

anche in questo caso otteniamo lo stesso output

Proviamo ora ad assegnare l' attributo internal:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        internal var nome:String='Filippo';
        
        public function Quarta()
        {
            trace(nome);
        }
    }
}

anche con attributo internal abbiamo lo stesso output.



Conclusione:

qualsiasi attributo assegno alla proprietà, la proprietà stessa è sempre accessibile dall' interno della classe.

Per poter mostrare le differenze tra attributi dobbiamo capire come istanziare una classe.

Creo una nuova classe Miles.as :

package
{
    public class Miles
    {
        public var nome:String='Davis';
        
        public function Miles()
        {
            trace('la classe Miles è stata istanziata');
        }
    }
}

Questa classe non estende la classe MovieClip, cioè non eredita metodi e proprietà dalla classe movieClip.

E' una semplice classe con una proprietà pubblica: nome.

Nella funzione costruttrice c'è un trace che verrà esguito al momento che questa classe verrà istanziata.



Vediamo come istanziarla dalla Document Class, quindi da Quarta.as :

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        public function Quarta()
        {
            var miles:Miles=new Miles();
        }
    }    
}

var miles creo una variabile locale che chiamo miles

:Miles gli dico che dev' essere di tipo Miles ( in questo momento Flash va a cercare una classe che si chiama appunto Miles )

=new Miles(); quì istanzio la classe Miles ed otteniamo questo output:

la classe Miles è stata istanziata

Importante:

potrei dichiarare miles anche in questo modo:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        private var miles:Miles;
        
        public function Quarta()
        {
            miles=new Miles();
        }
    }    
}

in questo caso dichiaro una proprietà alla classe Quarta.as che chiamo miles di tipo Miles.

Poi nella funzione costruttrice istanzio Miles. In questo momento la proprietà miles è una istanza della classe Miles.



Oppure potrei dichiarare miles in questo modo:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        private var miles:Miles=new Miles();
        
        public function Quarta()
        {
            
        }
    }    
}

in questo caso dichiaro la proprietà miles di tipo Miles e la istanzio in contemporanea con la dichiarazione.

Perchè ho fatto questi esempi ?

Per essere sicuro che ognuno di voi capisca perfettamente cosa è una istanza di una classe.

La proprietà miles di Quarta.as è una istanza della classe Miles.

Ora attenzione perchè arriva il bello !

Torniamo agli attributi di una proprietà.

Se volessi recuperare la proprietà nome della classe miles ?

Proviamo a chiamarla dalla sua stessa istanza:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        private var miles:Miles=new Miles();
        
        public function Quarta()
        {
            trace(miles.nome);
        }
    }    
}

nella funzione costruttrice chiamo miles.nome e ottengo questo output:

la classe Miles è stata istanziata

Davis

Questo significa che posso recuperare una proprietà di Miles da una sua istanza se la stessa proprietà ha attributo public.

public: le proprietà sono accessibili dall' interno della classe, dalle istanze della classe stessa e direttamente se implementate dell' attributo static ( che vedremo )

Proviamo ora ad assegnare l' attributo private alla proprietà nome di Miles.as.

Otteniamo da Flash questo errore:

1178: Attempted access of inaccessible property nome through a reference with static type Miles.

In sostanza Flash ci sta dicendo che stiamo cercando di accedere ad una proprietà che di fatto è inaccessibile. Questo perchè:

private: le proprietà sono accessibili solo dall' interno della classe

Quindi nome di Miles se è private è accessibile solo da Miles stessa.

Se assegno a nome di miles l' attributo protected ottengo da Flash lo stesso errore perchè:

protected: le proprietà sono accessibili solo dall' interno della classe o dalle sue sottoclassi

Miles non estende Quarta e quindi nome di Miles rimane non accessibile da Quarta.

Se assegno a nome di Miles l' attributo internal ottengo questo output:

la classe Miles è stata istanziata

Davis

Come si nota in questo caso nome di Miles è accessibile da una istanza di Miles ( che si trova sempre in Quarta.as ), perchè:

internal: le proprietà sono accessibili dall' interno del package

Dato che Quarta.as e Miles.as si trovano nello stesso package, nella stessa directory, nome di Miles è accesibile dalle istanze di Miles.as.

In sostanza potremmo anche fare in questo modo:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        private var miles:Miles=new Miles();
        
        public function Quarta()
        {
            trace(miles.nome);
        }
    }    
}

class Miles
{
    internal var nome:String='Davis';
    
    public function Miles()
    {
        trace('la classe Miles è stata istanziata');
    }
}

Defiiamo Miles nel file Quarta.as ma fuori dalle graffe del package.

Inoltre l' attributo public che definisce la classe Miles ( public class Miles ) va omesso in quanto Flash accetta quell' attributo solo se inserito all' interno delle graffe del package.

Attributo static di una proprietà


Oltre ai quattro attributi che abbiamo appena visto, una proprietà di una classe Actionscript 3.0 può avere un altro attributo: static .

Questo attributo permette alla proprietà di essere statica, cioè che può essere richiamata direttamente, senza dover istanziare la classe di cui appunto è proprietà.

Per intenderci, abbiamo visto che dall' istanza della classe Miles ( miles ) potevamo accedere ad una sua proprietà: nome.

Se avessimo provato a chiamare Miles.nome Flash ci avrebbe detto che la proprietà non è accessibile in quanto non dispone di attributo static.

Vediamo un esempio, torniamo alle due classi originali come avevamo scritto all' inizio di questo tutorial, e cioè:

la classe Quarta.as

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        public function Quarta()
        {
            
        }
    }
}

la classe Miles.as

package
{
    public class Miles
    {
        public var nome:String='Davis';
        
        public function Miles()
        {
            trace('la classe Miles è stata istanziata');
        }
    }
}

Ora aggiungo l' attributo static alla proprietà nome di Miles.as, in questo modo:

package
{
    public class Miles
    {
        public static var nome:String='Davis';
        
        public function Miles()
        {
            trace('la classe Miles è stata istanziata');
        }
    }
}

e accedo da Quarta.as a nome di Miles in questo modo:

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        public function Quarta()
        {
            trace(Miles.nome);
        }
    }    
}

Da notare che non ho istanziato la classe Miles.

Ho chiamato direttamente nome in questo modo Miles.nome ottenendo questo output:

Davis

Infatti il trace nella funzione costruttrice di Miles non è stato eseguito appunto perchè non ho stanziato la classe Miles.

Chiaramente nome di Miles ha anche l' attributo public o altrimenti non sarebbe accessibile, perchè:

1. private: le proprietà sono accessibili solo dall' interno della classe
2. public: le proprietà sono accessibili dall' interno della classe, dalle istanze della classe stessa e direttamente se implementate dell' attributo static

Quindi, se volessi modificare il valore di nome

package
{
    import flash.display.MovieClip;
    
    public class Quarta extends MovieClip
    {
        public function Quarta()
        {
            Miles.nome='Porgy';
            trace(Miles.nome);
        }
    }    
}

otterrei il seguente output:

Porgy

Allego i files:

[Matt]

Quindi definire una variabile con static, è come definire una variabile esterna in C, no?