ActionScript 3
Programowanie obiektowe
Szukaj…
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ń