ActionScript 3
Programmation orientée objet
Recherche…
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