ActionScript 3
Objekt orientierte Programmierung

"Überladener" Konstruktor über statische Methode

Konstruktorüberladung steht in As3 nicht zur Verfügung.

Um eine andere Möglichkeit zum Abrufen einer Instanz einer Klasse bereitzustellen, kann eine public static Methode bereitgestellt werden, die als alternativer "Konstruktor" dient.

Ein Beispiel dafür ist flash.geom.Point , das ein 2D- flash.geom.Point darstellt. Die Koordinaten zum Definieren des Punkts können sein

• kartesisch im regulären Konstruktor

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

  Verwendungsbeispiel:

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

• polar in einer statischen Methode

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

  Verwendungsbeispiel:

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

  Da es sich nicht um einen tatsächlichen Konstruktor handelt, gibt es kein new Schlüsselwort.

Funktionen einstellen und abrufen

Um die Kapselung zu gewährleisten, sollten Membervariablen einer Klasse private und nur über öffentliche get / set Zugriffsmethoden für die public zugänglich sein. Es ist üblich, private Felder vor _

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

Manchmal müssen Sie nicht einmal ein private Feld für ein get / set Paar erstellen.
Zum Beispiel in einer Steuerung wie eine benutzerdefinierte Radiogruppe müssen Sie wissen , welches Optionsfeld ausgewählt ist, jedoch außerhalb der Klasse , die Sie gerade brauchen eine Möglichkeit , get / set nur den ausgewählten Wert:

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

Pakete

Pakete sind Bündel von Klassen. Jede Klasse muss in einem Paket mit der package deklariert werden. Auf die package folgt der Name Ihres Pakets oder nichts, wenn Sie dem Paket der obersten Ebene Klassen hinzufügen. Unterpakete werden mit Punkt ( . ) Erstellt. Auf die Paketanweisung folgt ein Block, der eine einzelne class . Beispiele:

package {
    // The top level package.
}

package world {
    // A package named world.
}

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

Pakete sollten mit der Dateistruktur der Klassen relativ zum Quellstammverzeichnis korrelieren. Vorausgesetzt, Sie haben einen Quellstammordner namens src , könnte das Obige im Dateisystem korrekt dargestellt werden als:

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

Überschreibende Methode

Wenn Sie extend eine Klasse, können Sie override Methoden , die die geerbte Klasse definiert den mit override Stichwort:

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

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

Beispiel:

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

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

Mit dem Schlüsselwort super auf die Originalmethode der vererbten Klasse verweisen. Zum Beispiel könnten wir den Körper von AnotherExample.test() ändern:

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

Ergebend:

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

Klassenkonstruktoren überschreiben ist ein bisschen anders. Das override wird weggelassen und der Zugriff auf den geerbten Konstruktor erfolgt einfach mit super() :

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

Sie können auch außer Kraft gesetzt get und set Methoden.

Getter und Setter

Getter und Setter sind Methoden, die sich wie Eigenschaften verhalten. es bedeutet, dass sie eine Funktionsstruktur haben, aber wenn sie verwendet werden, werden sie genauso wie Eigenschaften verwendet:

Struktur der Getterfunktionen :

sie sollten get Stichwort nach function Schlüsselwort und vor Funktionsnamen, ohne Argument, ein Rückgabetyp angegeben und muss einen Wert zurückgeben:

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

Syntax :

Um den Wert von einem Getter zu erhalten, entspricht die Syntax dem Abrufen eines Werts aus einer Eigenschaft (es werden keine Parens () verwendet).

trace(myValue);

Struktur der Setterfunktionen :

Sie sollten set Schlüsselwort hinter dem function und vor dem Funktionsnamen mit einem Argument und ohne Rückgabewert setzen.

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

Syntax :

Um den Wert eines Setters festzulegen, entspricht die Syntax dem Festlegen eines Werts für eine Eigenschaft (mit Gleichheitszeichen = dann Wert).

myValue=desiredValue;

Einen Getter und Setter für einen Wert setzen :

Anmerkung: Wenn Sie nur Getter oder nur Setter mit einem Namen erstellen, ist diese Eigenschaft schreibgeschützt oder schreibgeschützt.

Um eine Eigenschaft sowohl lesbar als auch einstellbar zu machen, sollten Sie einen Getter und einen Setter erstellen mit:

1. den gleichen Namen
2.derselbe Typ (Typ des Rückgabewerts für den Getter und Typ des Eingabewerts (Argument) für den Setter,

Hinweis: Getter und Setter sollten nicht denselben Namen haben wie andere Eigenschaften oder Methoden.

Verwendung von Getter und Setter:

Die Verwendung von Gettern und Setters anstelle von normalen Eigenschaften hat viele Vorteile:

1. schreibgeschützte oder gesetzte Eigenschaften festlegen:
Beispiel: Anzahl der Kinder in einem Anzeigeobjekt. es kann nicht einstellbar sein.

2. Zugriff auf private Immobilien:
ein Beispiel:

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. Wenn nach dem Einstellen eines Werts etwas geändert werden muss:
In diesem Beispiel muss die Änderung dieser Eigenschaft mitgeteilt werden:

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

und viele andere Verwendungen