Dart - Le nouveau langage du Web
Les classes
Dart est un langage orienté objet, il intègre donc la notion de classe. La syntaxe est similaire à celle de Java mais Dart propose quelques fonctionnalités en plus comme les constructeurs nommés ou encore la surcharge d'opérateur. Toutes les classes héritent de la classe Object.
Les constructeurs
L'instanciation d'un objet se fait par l'appel à un constructeur.La syntaxe est la même qu'en Java. Cependant, il existe une syntaxe allégée pour les constructeurs qui ne font que recopier une valeur dans les attributs, elle s'étend sur une ligne. Il suffit juste de mettre dans les paramètres pour les attributs que l'on veut renseigner. Par exemple, si on a un attribut "nom" dans notre classe, le paramètre devra être "this.nom". Il n'y a alors pas besoin d' écrire le corps de la méthode.
Les constructeurs nommés
Plusieurs constructeurs par classes sont autorisés, Dart permet de les nommer, ce qui facilite leur appel et donne du sens à l'opération qu'il va effectuer. Ainsi un développeur pourra choisir un constructeur plus facilement. Un constructeur nommé à la forme suivante : NomClasse.nomConstructeur(param1); Cela permet plusieurs constructeurs avec la même signature. Nous allons utiliser l'exemple d'une classe simple, la classe Point qui possède deux attributs, x et y.
/**
* Représentation d'un point
*/
class Point {
int x, y;
/**
* Le constructeur qui ne fait que donner un valeur aux attributs
*/
Point(this.x, this.y);
/**
* Constructeur nommé
*/
Point.fromArray(List array) {
this.x = array[0];
this.y = array[1];
}
}
main() {
Point p = new Point(12,3);
Point p1 = new Point.fromArray([1,2]);
}
Il est à noter que les deux constructeurs suivants sont rigoureusement équivalents :
Point(this.x, this.y);
Point(x, y) {
this.x = x;
this.y = y;
}
L'héritage
Le langage supporte l'héritage, il n'y a pas d'héritage multiple. Pour qu'une classe hérite d'une autre, on utilise le mot clé extends. Reprenon l'exemple de notre classe Point, nous allons créer une classe Point3D pour ajouter "z" aux coordonnées du point.
/**
* Représentation d'un point en 3D
* avec héritage de la classe Point
*/
class Point3D extends Point {
int z;
Point3D(int x, int y, int this.z) : super(x,y);
}
main() {
Point3D p3 = new Point3D(4, 5, 6);
print("x=${p3.x} y=${p3.y} z=${p3.z}");
}
// Ce code affiche :
// x=4 y=5 z=6
Cette exemple met en évidence la simplicité de l'héritage avec Dart. L'appel au constructeur de la classe mère se fait directement dans la signature du constructeur, avec ": super()", il est donc forcément appelé en premier, ce qui évite l'erreur que l'on peut trouver en Java lorsque le développeur n'appelle pas super au début constructeur.
Interface
Il n'existe pas d'interface en tant que tel comme en Java. Pour utiliser ce concept, il faut passer par une classe abstraite. Chaque classe déclare une interface implicite du même nom, il est donc possible d'écrire : "class A implements Point { ... }".
La surchage d'opérateur
Tout comme le langage C++, Dart offre la possibilité de surcharger les opérateurs pour les instances d'une classe. Par exemple si l'on souhaite pouvoir additionner deux instances de notre classe point, nous ajoutons la méthode suivante :
Point operator +(Point p) {
return new Point(x+p.x, y+p.y);
}
L'addition de l'objet Point(2,3) et de Point(6,4) donne un nouveau point : Point(8,7). Voici les 19 opérateurs qui peuvent être surchargés :
| < | + | | | [] |
| > | / | ^ | []= |
| <= | ~/ | & | ~ |
| >= | * | << | == |
| - | % | >> |