Dart : Les classes 1/?


Les classes !

Dart est un langage orienté objet ce qui veut dire que nous pouvons utiliser les classes (comme avec java) mais c’est aussi un langage avec un héritage “mixin-based”. C’est extrêmement similaire, toutefois quelques particularités bien pratiques sont disponibles !

Chaque objet est une instance d’une classe et chaque classe descende d’Objet. Un héritage “mixin-based” veut dire que chaque classe (à l’exception de “Object”) ont une superclasse, un corps de classe peut être réutilisé dans plusieurs hiérarchies de classe.

Pour créer un objet, vous devez utiliser le mot clé “new” qui utilise le constructeur de la classe. Les noms des constructeurs sont généralement comme le nom de la classe : ClassName ouClassName.identifier. Par exemple :

var jsonData = JSON.decode('{"x":1, "y":2}');

// CRéation d'un point grâce à Point().
var p1 = new Point(2, 2);

// Création d'un point grâce à Point.fromJson().
var p2 = new Point.fromJson(jsonData);

Les objets ont des membres : soit des fonctions, soit des champs (fields en anglais). Lorsque vous appelez une méthode depuis un objet, celle-ci à accès aux spécificités de son objet.

Utilisez le ‘.’ pour accéder à une variable (un champ) ou une méthode (une fonction) :

var p = new Point(2, 2);

// La valeur du champ y sera de 3.
p.y = 3;

// Get la valeur de y.
assert(p.y == 3);

// Appelle la méthode distanceTo() de l'objet p.
num distance = p.distanceTo(new Point(4, 4));

Certains constructeurs peuvent être constant, ils sont généralement utilisés en cas d’immutabilité :

class Person
{
final String name;
final int age;
final String job;

const Person(this.name, this.job, this.age);
}
main()
{
var p = const new Person(...);
p.name = "hello"; //Erreur car chaque champs sont en final.
}

Avoir des objets imputable identiques permet de créer une seule instance :

var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b)); // C'est la même instance !

Pour obtenir le type d’un objet il faut utiliser la propriété runtimeType qui provient d’Object :

print('The type of a is ${a.runtimeType}');

Variables ou champs

Voici comment déclarer des variables à l’intérieur d’une classe :

class Point {
num x; // Variable x, initialement null.
num y; // Variable y, initialement null.
num z = 0; // Variable z, initialement 0.
}

Toutes les variables qui ne sont pas initialisées (comme x et y) sont par défaut null.

Chaque variables génèrent une méthode implicit : ‘getter’. Toutes les variables non-final possèdent aussi une méthode implicit : ‘setter’.

class Point {
num x;
num y;
}

main() {
var point = new Point();
point.x = 4; // Utilisation de la méthode setter pour x.
assert(point.x == 4); // Utilisation du getter pour x.
assert(point.y == null); // La valeur par défaut est null.
}

Si vous initialisez une variable, la valeur sera créé avant que le constructeur ne soit appelé.

Les constructeurs

Déclarer un constructeur est en gros déclarer une fonction qui a le même nom que la classe. Les constructeurs permettent d’assigner valeurs aux variables. Cela permet de générer une instance de la classe :

class Point {
num x;
num y;

Point(num x, num y) {
// Il y a un meilleur moyen de faire ceci.
this.x = x;
this.y = y;
}
}

Le mot cléthis fait référence aux variables dans l’instance (cela permet de différencier les paramètres des variables...

Vous pouvez aussi assigner les variables d’instance de cette manière :

class Point {
num x;
num y;

Point(this.x, this.y);
}

Ici nous faisons exactement la même chose que précédemment.

Si vous ne voulez pas préciser de constructeur, il y en a un par défaut qui ne prend aucun argument et qui retourne simplement la nouvelle instance.

Vous pouvez utiliser des constructeurs nommés ! Cela permet d’être plus claire dans certains cas :

class Point {
num x;
num y;

Point(this.x, this.y);

// Ceci est un constructeur nommé.
Point.fromJson(Map json) {
x = json['x'];
y = json['y'];
}
}

Rappelez vous que les constructeurs ne sont pas hérités. Ce qui veut dire que si votre super-classe contient un constructeur nommé il ne sera pas hérité par une sous-classe. Si vous souhaitez créer une sous-classe avec un constructeur nommé défini dans la super-classe, vous devez implémenter ce constructeur dans la sous-classe.

Exemple :

/*
class Person {
String firstName;

Person.fromJson(Map data) {
print('in Person');
}
}

class Employee extends Person {
// Person n'a pas de constructeur par défaut;
// Vous devez donc appeller super.fromJson(data).
Employee.fromJson(Map data) : super.fromJson(data) {
print('in Employee');
}
}

main() {
var emp = new Employee.fromJson({});


if (emp is Person) {
emp.firstName = 'Bob';
}
(emp as Person).firstName = 'Bob';
}

Output : in Person in Employee

Merci beaucoup d’avoir lu.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.