ActionScript 3
Object georiënteerd programmeren
Zoeken…
"Overbelaste" Constructor via statische methode
Constructor overbelasting is niet beschikbaar in As3.
Om een andere manier te bieden om een instantie van een klasse op te halen, kan een public static
methode worden gebruikt om als een alternatieve "constructor" te dienen.
Een voorbeeld hiervan is flash.geom.Point
, dat een 2D- flash.geom.Point
vertegenwoordigt. De coördinaten om het punt te definiëren kunnen zijn
cartesiaans in de reguliere constructor
public function Point(x:Number = 0, y:Number = 0)
voorbeeld gebruik:
var point:Point = new Point(2, -.5);
polair in een statische methode
public static function polar(len:Number, angle:Number):Point
voorbeeld gebruik:
var point:Point = Point.polar(12, .7 * Math.PI);
Omdat het geen echte constructor is, is er geen
new
trefwoord.
functies instellen en ophalen
Om inkapseling te garanderen, moeten lidvariabelen van een klasse private
en alleen toegankelijk zijn voor het public
via openbare get
/ set
toegangsmethoden. Het is gebruikelijk om privévelden voor te voegen met _
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;
}
Soms heb je niet eens nodig om het creëren van een private
veld voor een get
/ set
paar.
In een besturingselement zoals een aangepaste radiogroep moet u bijvoorbeeld weten welk keuzerondje is geselecteerd, maar buiten de klas heeft u alleen een manier nodig get
alleen de geselecteerde waarde te get
/ in te set
:
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;
}
}
}
Pakketjes
Pakketten zijn bundels van klassen. Elke klasse moet binnen een pakket worden gedeclareerd met behulp van de package
. De package
wordt gevolgd door de naam van uw pakket, of niets gevolgd in het geval van het toevoegen van klassen aan het pakket op het hoogste niveau. Subpakketten worden gemaakt met behulp van punt ( .
) Afbakening. Het pakket verklaring wordt gevolgd door een blok dat een enkele zal bevatten class
definitie. Voorbeelden:
package {
// The top level package.
}
package world {
// A package named world.
}
package world.monsters {
// A package named monsters within a package named world.
}
Pakketten moeten correleren met de bestandsstructuur van de klassen ten opzichte van de bronwortel. Ervan uitgaande dat u een bronhoofdmap met de naam src
, kan het bovenstaande correct in het bestandssysteem worden weergegeven als:
src
TopLevelClass.as
world
ClassInWorldPackage.as
AnotherClassInWorldPackage.as
monsters
Zombie.as
Methode overschrijven
Wanneer u een klasse extend
, kunt u methoden override
die de overgenomen klasse definieert met behulp van het trefwoord 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!');
}
}
Voorbeeld:
var example:Example = new Example();
var another:AnotherExample = new AnotherExample();
example.test(); // Output: It works!
another.test(); // Output: It still works!
U kunt het super
trefwoord gebruiken om te verwijzen naar de oorspronkelijke methode van de klasse die wordt overgenomen. We kunnen bijvoorbeeld de hoofdtekst van AnotherExample.test()
in:
public override function test():void {
super.test();
trace('Extra content.');
}
Met als resultaat:
another.test(); // Output: It works!
// Extra content.
Het vervangen van klassenbouwers is een beetje anders. Het override
sleutelwoord wordt weggelaten en toegang tot de overgeërfde constructor wordt eenvoudig gedaan met super()
:
public class AnotherClass extends Example {
public function AnotherClass() {
super(); // Call the constructor in the inherited class.
}
}
U kunt ook overschrijven get
en set
methoden.
getter en setter
Getters en setters zijn methoden die zich gedragen als eigenschappen. het betekent dat ze een functiestructuur hebben, maar wanneer ze worden gebruikt, worden ze hetzelfde gebruikt als eigenschappen:
Structuur van getter-functies :
ze moeten sleutelwoord get
na function
en vóór functienaam, zonder argument, een opgegeven retourtype en moeten een waarde retourneren:
public function get myValue():Type{
//anything here
return _desiredValue;
}
Syntaxis :
om de waarde van een getter te krijgen, is de syntaxis hetzelfde als het verkrijgen van een waarde van een eigenschap (er worden geen parens ()
gebruikt).
trace(myValue);
Structuur van setter-functies :
ze hadden set
sleutelwoord na het function
en vóór de functienaam moeten set
, met één argument en geen waarde-rendement.
public function set myValue(value:Type):void{
//anything here
_desiredProperty=value;
}
Syntaxis :
om de waarde van een setter in te stellen, is de syntaxis hetzelfde als het instellen van een waarde op een eigenschap (met gelijkteken =
dan waarde).
myValue=desiredValue;
een getter en setter instellen voor één waarde :
Opmerking: als u alleen getter of alleen setter met een naam maakt, is die eigenschap alleen-lezen of alleen-instellen.
om een eigenschap leesbaar en instelbaar te maken, moet een getter en een setter worden gemaakt met:
1. dezelfde naam.
2. hetzelfde type (type retourwaarde voor de getter en type invoerwaarde (argument) voor de setter,
Opmerking: getters en setters mogen niet dezelfde naam hebben als andere eigenschappen of methoden.
Gebruik van getters en setters:
Het gebruik van getters en setters in plaats van normale eigenschappen heeft veel voordelen:
1. het maken van alleen-lezen of alleen-set eigenschappen:
bijvoorbeeld aantal kinderen in een weergaveobject. het kan niet worden ingesteld.
2. toegang tot privé-eigendommen:
Een voorbeeld:
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. wanneer een wijziging nodig is na het instellen van een waarde:
in dit voorbeeld moet een wijziging van deze eigenschap worden gemeld:
public static function set val:(input:Type):void{
_desiredProperty=input;
notifyValueChanged();
}
en vele andere gebruiken