ActionScript 3
Programowanie obiektowe

Konstruktor „przeciążony” metodą statyczną

Przeciążenie konstruktora nie jest dostępne w As3.

Aby zapewnić inny sposób pobierania instancji klasy, można podać public static metodę public static która będzie służyć jako alternatywny „konstruktor”.

Przykładem tego jest flash.geom.Point , który reprezentuje obiekt punktowy 2D. Współrzędne określające punkt mogą być

• kartezjański w zwykłym konstruktorze

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

  przykładowe użycie:

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

• biegunowy w metodzie statycznej

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

  przykładowe użycie:

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

  Ponieważ nie jest to prawdziwy konstruktor, nie ma new słowa kluczowego.

ustaw i uzyskaj funkcje

Aby zapewnić hermetyzację, zmienne członek grupy powinien być private i być dostępne tylko public poprzez publiczne get / set metod dostępu. Powszechną praktyką jest poprzedzanie pól prywatnych znakiem _

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

Czasami nawet nie trzeba tworzyć private pola dla pary get / set .
Na przykład w kontrolce, takiej jak niestandardowa grupa radiowa, musisz wiedzieć, który przycisk radiowy jest wybrany, jednak poza klasą potrzebujesz tylko sposobu, aby get / set tylko wybraną wartość:

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

Pakiety

Pakiety to pakiety klas. Każda klasa musi być zadeklarowana w pakiecie za pomocą instrukcji package . Po instrukcji package znajduje się nazwa pakietu lub po niej nie ma nic w przypadku dodawania klas do pakietu najwyższego poziomu. Pakiety częściowe są tworzone przy użyciu separatora kropkowego ( . ). Po instrukcji pakiet następuje blok, który będzie zawierał definicję jednej class . Przykłady:

package {
    // The top level package.
}

package world {
    // A package named world.
}

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

Pakiety powinny korelować ze strukturą plików klas względem źródłowego katalogu głównego. Zakładając, że masz źródłowy folder główny o nazwie src , powyższe może być poprawnie reprezentowane w systemie plików jako:

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

Przesłanianie metody

Po extend klasy można override metody zdefiniowane przez klasę dziedziczoną za pomocą słowa kluczowego 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!');
    }
}

Przykład:

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

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

Możesz użyć super słowa kluczowego, aby odwołać się do oryginalnej metody z dziedziczonej klasy. Na przykład moglibyśmy zmienić AnotherExample.test() na:

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

Wynikające z:

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

Przesłanianie konstruktorów klas jest nieco inne. override kluczowe override jest pomijane, a dostęp do odziedziczonego konstruktora odbywa się po prostu za pomocą super() :

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

Możesz także zastąpić metody get i set .

getter i seter

Metody pobierające i ustawiające są metodami, które zachowują się jak właściwości. oznacza to, że mają strukturę funkcji, ale gdy są używane, są używane tak samo jak właściwości:

Struktura funkcji gettera :

powinny one mieć get kluczowe po function hasła i przed nazwą funkcji, bez argumentu, rodzaj powrotu określony i musi zwrócić wartość:

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

Składnia :

aby uzyskać wartość z gettera, składnia jest taka sama jak uzyskanie wartości z właściwości (nie są używane parens () ).

trace(myValue);

Struktura funkcji setera :

powinni set słowo kluczowe po słowie kluczowym function i przed nazwą funkcji, z jednym argumentem i bez zwracania wartości.

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

Składnia :

aby ustawić wartość settera, składnia jest taka sama jak ustawienie wartości dla właściwości (używając znaku równości = wartość).

myValue=desiredValue;

ustawienie gettera i settera dla jednej wartości :

Uwaga: jeśli utworzysz tylko getter lub setter tylko z nazwą, ta właściwość będzie tylko do odczytu lub tylko do zestawu.

aby właściwość była czytelna i możliwa do ustawienia, należy utworzyć moduł pobierający i ustawiający za pomocą:

1. to samo imię
2. ten sam typ (typ wartości zwracanej dla gettera i typ wartości wejściowej (argument) dla settera,

Uwaga: metody pobierające i ustawiające nie powinny mieć takich samych nazw jak inne właściwości lub metody.

Zastosowanie pobierających i ustawiających:

Używanie metod pobierających i ustawiających zamiast normalnych właściwości ma wiele zalet:

1. tworzenie właściwości tylko do odczytu lub tylko do zestawu:
na przykład liczba dzieci w obiekcie wyświetlanym. nie można tego ustawić.

2. dostęp do nieruchomości prywatnych:
przykład:

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. gdy wymagana jest pewna zmiana po ustawieniu wartości:
w tym przykładzie należy zmienić tę właściwość:

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

i wiele innych zastosowań