ActionScript 3
Programmation orientée objet

Constructeur "surchargé" par méthode statique

La surcharge du constructeur n'est pas disponible dans As3.

Afin de fournir une manière différente de récupérer une instance d'une classe, une méthode public static peut être fournie pour servir de "constructeur" alternatif.

flash.geom.Point , qui représente un objet ponctuel 2D, en est un exemple. Les coordonnées pour définir le point peuvent être

• cartésien dans le constructeur régulier

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

  exemple d'utilisation:

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

• polaire dans une méthode statique

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

  exemple d'utilisation:

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

  Comme il ne s'agit pas d'un constructeur réel, il n'y a pas de new mot clé.

définir et obtenir des fonctions

Pour garantir l'encapsulation, les variables membres d'une classe doivent être private et ne doivent être accessibles au public par le biais de méthodes d'accès get / set publiques. Il est courant de préfixer des champs privés avec _

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

Parfois, vous n'avez même pas besoin de créer un champ private pour une paire get / set .
Par exemple, dans un contrôle tel qu'un groupe de radio personnalisé, vous devez savoir quel bouton radio est sélectionné. Cependant, en dehors de la classe, vous avez juste besoin d'un moyen d' get / de set uniquement la valeur sélectionnée:

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

Paquets

Les packages sont des lots de classes. Chaque classe doit être déclarée dans un package à l'aide de l'instruction package . L'instruction de package est suivie du nom de votre package ou suivie de rien dans le cas de l'ajout de classes au package de niveau supérieur. Les sous-packages sont créés à l'aide de la délimitation par points ( . ). L'instruction package est suivie d'un bloc qui contiendra une définition de class unique . Exemples:

package {
    // The top level package.
}

package world {
    // A package named world.
}

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

Les packages doivent correspondre à la structure de fichier des classes par rapport à la racine source. En supposant que vous avez un dossier racine source nommé src , ce qui précède pourrait être correctement représenté dans le système de fichiers comme:

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

Méthode à écraser

Lorsque vous extend une classe, vous pouvez override méthodes override par la classe héritée à l'aide du mot clé 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!');
    }
}

Exemple:

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

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

Vous pouvez utiliser le mot super clé super pour référencer la méthode d'origine de la classe héritée. Par exemple, nous pourrions changer le corps de AnotherExample.test() pour:

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

Résultant en:

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

La substitution des constructeurs de classes est un peu différente. Le mot-clé override est omis et l'accès au constructeur hérité se fait simplement avec super() :

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

Vous pouvez également remplacer les méthodes get et set .

getter et setter

Les getters et les setters sont des méthodes qui se comportent comme des propriétés. cela signifie qu'ils ont une structure de fonction mais lorsqu'ils sont utilisés, ils sont utilisés comme des propriétés:

Structure des fonctions getter :

ils doivent avoir le mot-clé get après la function et avant le nom de la fonction, sans argument, un type de retour spécifié et doit renvoyer une valeur:

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

Syntaxe :

pour obtenir la valeur d'un getter, la syntaxe est identique à celle d'une propriété (no parens () est utilisé).

trace(myValue);

Structure des fonctions de réglage :

Ils doivent avoir set mot-clé après la function et avant le nom de la fonction, avec un argument et aucun retour de valeur.

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

Syntaxe :

Pour définir la valeur d'un dispositif de réglage, la syntaxe est identique à la définition d'une valeur pour une propriété (en utilisant le signe égal = alors valeur).

myValue=desiredValue;

définir un getter et un setter pour une valeur :

Remarque: si vous ne créez que getter ou uniquement setter avec un nom, cette propriété serait en lecture seule ou définie uniquement.

pour rendre une propriété à la fois lisible et configurable, il faut créer un getter et un setter avec:

1. même nom.
2. le même type (type de valeur de retour pour le getter et type de valeur d'entrée (argument) pour le setter,

Remarque: les getters et les setters ne doivent pas avoir un nom identique à celui d'autres propriétés ou méthodes.

Utilisation des getters et des setters:

Utiliser des getters et des setters plutôt que des propriétés normales a de nombreux avantages:

1. créer des propriétés en lecture seule ou uniquement en set:
par exemple nombre d'enfants dans un objet d'affichage. ça ne peut pas être réglé.

2. accès aux propriétés privées:
un exemple:

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. quand un changement est nécessaire après avoir défini une valeur:
dans cet exemple, la modification de cette propriété doit être notifiée:

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

et bien d'autres usages