ActionScript 3
Objektorienterad programmering

"Överbelastad" konstruktör via statisk metod

Konstruktörens överbelastning är inte tillgänglig i As3.

För att tillhandahålla ett annat sätt att hämta en instans av en klass, kan en public static metod tillhandahållas för att fungera som en alternativ "konstruktör".

Ett exempel för detta är flash.geom.Point , som representerar ett 2D-punktobjekt. Koordinaterna för att definiera punkten kan vara

• kartsisk i den vanliga konstruktören

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

  exempel användning:

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

• polar i en statisk metod

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

  exempel användning:

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

  Eftersom det inte är en verklig konstruktör finns det inget new nyckelord.

inställ & få funktioner

För att säkerställa inkapsling bör medlemmvariabler i en klass vara private och endast vara tillgängliga för public via offentliga get / set access-metoder. Det är vanligt att prefixa privata fält med _

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

Ibland behöver du inte ens skapa ett private fält för ett get / set par.
Till exempel i en kontroll som en anpassad radiogrupp behöver du veta vilken alternativknapp som är vald, men utanför klassen behöver du bara ett sätt att get / set endast det valda värdet:

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

paket

Paket är paket med klasser. Varje klass måste deklareras i ett paket med hjälp av package . package följs av namnet på ditt paket, eller följs av ingenting om du lägger till klasser i toppnivåpaketet. Underpaket skapas med punkt ( . ) Avgränsning. Paketmeddelandet följs av ett block som kommer att innehålla en definition av en class . Exempel:

package {
    // The top level package.
}

package world {
    // A package named world.
}

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

Paket bör korrelera med filstrukturen för klasserna relativt källroten. Förutsatt att du har en källrotmapp med namnet src , kan ovanstående representeras korrekt i filsystemet som:

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

Överträffande metod

När du extend en klass kan du override metoder som den ärvda klassen definierar med hjälp av override nyckelord:

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

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

Exempel:

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

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

Du kan använda super nyckelordet för att referera till den ursprungliga metoden från klassen som ärvs. Vi kan till exempel ändra kroppen till AnotherExample.test() till:

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

Resulterar i:

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

Att åsidosätta klasskonstruktörer är lite annorlunda. override nyckelord utelämnas och åtkomst till den ärvda konstruktören görs helt enkelt med super() :

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

Du kan också åsidosätta metoder för att get och set .

getter och setter

Getters and seters är metoder som uppförs som egenskaper. det betyder att de har funktionsstruktur men när de används används de samma som egenskaper:

Strukturen för getterfunktioner :

de borde ha get nyckelord efter function och före funktionsnamn, utan argument, en returtyp anges och måste returnera ett värde:

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

Syntax :

För att få värdet från en getter är syntaxen densamma som att få ett värde från en egenskap (inga parens () används).

trace(myValue);

Strukturen för setterfunktioner :

de borde ha set nyckelord efter function och före funktionsnamn, med ett argument och inget värde avkastning.

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

Syntax :

för att ställa in värdet på en setter är syntaxen densamma som att ställa in ett värde på en egenskap (med lika tecken = sedan värde).

myValue=desiredValue;

ställa in en getter och setter för ett värde :

Obs: om du bara skapar getter eller bara setter med ett namn, skulle den egenskapen vara skrivskyddad eller endast inställd.

att göra en egenskap både läsbar och inställbar bör man skapa en getter och en setter med:

1. samma namn.
2. samma typ (typ av returvärde för getter och typ av ingångsvärde (argument) för setteraren,

Obs! Getters och seters ska inte ha samma namn som andra egenskaper eller metoder.

Användning av getters och setters:

Att använda getters och setters snarare än normala egenskaper har många fördelar:

1. att skapa skrivskyddade eller inställda egenskaper:
till exempel antal barn i ett visningsobjekt. det kan inte ställas in.

2. åtkomst till privata fastigheter:
ett exempel:

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. när någon förändring krävs efter inställning av ett värde:
i det här exemplet måste du ändra den här egenskapen:

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

och många andra användningar