ActionScript 3
Object georiënteerd programmeren

"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