ActionScript 3
Programmazione orientata agli oggetti

Costruttore "sovraccaricato" tramite metodo statico

L'overloading del costruttore non è disponibile in As3.

Per fornire un modo diverso per recuperare un'istanza di una classe, è possibile fornire un metodo public static per fungere da "costruttore" alternativo.

Un esempio è flash.geom.Point , che rappresenta un oggetto punto 2D. Le coordinate per definire il punto possono essere

• cartesiano nel costruttore regolare

  public function Point(x:Number = 0, y:Number = 0) 
  

  esempio di utilizzo:

  var point:Point = new Point(2, -.5);
  

• polare in un metodo statico

  public static function polar(len:Number, angle:Number):Point
  

  esempio di utilizzo:

  var point:Point = Point.polar(12, .7 * Math.PI);
  

  Perché non è un vero costruttore, non c'è una new parola chiave.

imposta e ottieni funzioni

Per garantire l'incapsulamento, le variabili membro di una classe dovrebbero essere private e essere accessibili al public tramite metodi pubblici di accesso get / set . È una pratica comune anteporre i campi privati ​​a _

public class Person
{
    private var _name:String = "";

    public function get name():String{
        return _name;
        //or return some other value depending on the inner logic of the class
    }


    public function set name(value:String):void{
        //here you may check if the new value is valid
        //or maybe dispatch some update events or whatever else
        _name = value;
    }

A volte non è nemmeno necessario creare un campo private per una coppia get / set .
Ad esempio in un controllo come un gruppo radio personalizzato è necessario sapere quale pulsante di opzione è selezionato, tuttavia al di fuori della classe è necessario solo un modo per get / set solo il valore selezionato:

public function get selectedValue():String {
    //just the data from the element
    return _selected ? _selected.data : null;
}
public function set selectedValue(value:String):void {
    //find the element with that data
    for (var i:int = 0; i < _elems.length; i++) {
        if (_elems[i].data == value) {
            _selected = _elems[i];//set it 
            processRadio();//redraw
            return;
        }
    }
}

Pacchi

I pacchetti sono pacchetti di classi. Ogni classe deve essere dichiarata all'interno di un pacchetto utilizzando la dichiarazione del package . L'istruzione del package è seguita dal nome del pacchetto o seguita da nulla in caso di aggiunta di classi al pacchetto principale. I sotto-pacchetti sono creati usando la delimitazione punto ( . ). L'istruzione del pacchetto è seguita da un blocco che conterrà una singola definizione di class . Esempi:

package {
    // The top level package.
}

package world {
    // A package named world.
}

package world.monsters {
    // A package named monsters within a package named world.
}

I pacchetti devono essere correlati alla struttura dei file delle classi relative alla radice di origine. Supponendo di avere una cartella radice di origine chiamata src , quanto sopra potrebbe essere correttamente rappresentato nel filesystem come:

src
    TopLevelClass.as
    
    world
        ClassInWorldPackage.as
        AnotherClassInWorldPackage.as
        
        monsters
            Zombie.as

Metodo prioritario

Quando extend una classe, puoi eseguire l' override metodi che la classe ereditata definisce utilizzando la parola chiave override :

public class Example {
    public function test():void {
        trace('It works!');
    }
}

public class AnotherExample extends Example {
    public override function test():void {
        trace('It still works!');
    }
}

Esempio:

var example:Example = new Example();
var another:AnotherExample = new AnotherExample();

example.test(); // Output: It works!
another.test(); // Output: It still works!

È possibile utilizzare la parola chiave super per fare riferimento al metodo originale dalla classe che viene ereditata. Ad esempio, potremmo cambiare il corpo di AnotherExample.test() in:

public override function test():void {
    super.test();
    trace('Extra content.');
}

Con il risultato di:

another.test(); // Output: It works!
                //         Extra content.

Sostituire i costruttori di classi è un po 'diverso. La parola chiave override viene omessa e l'accesso al costruttore ereditato avviene semplicemente con super() :

public class AnotherClass extends Example {
    public function AnotherClass() {
        super(); // Call the constructor in the inherited class.
    }
}

Puoi anche sostituire i metodi get e set .

getter e setter

Getter e setter sono metodi che si comportano come proprietà. significa che hanno una struttura funzionale ma quando vengono utilizzati, vengono utilizzati come proprietà:

Struttura delle funzioni getter :

essi dovrebbero avere get parola chiave dopo la function parola chiave e prima il nome della funzione, senza argomenti, un tipo di ritorno specificato e deve restituire un valore:

public function get myValue():Type{
    //anything here
    return _desiredValue;
}

Sintassi :

per ottenere il valore da un getter, la sintassi è la stessa di ottenere un valore da una proprietà (non vengono utilizzati parens () ).

trace(myValue);

Struttura delle funzioni di setter :

dovrebbero avere set parola chiave parola chiave dopo function e prima del nome funzione, con un argomento e nessun valore restituito.

public function set myValue(value:Type):void{
    //anything here
    _desiredProperty=value;
}

Sintassi :

per impostare il valore di un setter, la sintassi è uguale all'impostazione di un valore su una proprietà (utilizzando il segno di uguale = quindi il valore).

myValue=desiredValue;

impostare un getter e setter per un valore :

Nota: se crei solo getter o solo setter con un nome, quella proprietà sarà di sola lettura o solo set.

per rendere una proprietà leggibile e impostabile, è necessario creare un getter e un setter con:

1. lo stesso nome
2. lo stesso tipo (tipo di valore di ritorno per il getter e tipo di valore di input (argomento) per il setter,

Nota: getter e setter non dovrebbero avere un nome uguale ad altre proprietà o metodi.

Utilizzo di getter e setter:

L'utilizzo di getter e setter invece delle normali proprietà ha molti vantaggi:

1. creazione di proprietà di sola lettura o di sola impostazione:
ad esempio il numero di bambini in un oggetto di visualizzazione. non può essere impostato.

2. accesso alle proprietà private:
un esempio:

private var _private:Type=new Type();
//note that function name "private" is not same as variable name "_private"  
public function get private():Type{
    return _private;
}

3. quando è necessario apportare alcune modifiche dopo aver impostato un valore:
in questo esempio, la modifica di questa proprietà deve essere notificata:

public static function set val:(input:Type):void{
    _desiredProperty=input;
    notifyValueChanged();
}

e molti altri usi