Méthode (Method)

Une méthode est une fonction qui attribue des comportements à un objet ; elle se divise en quatre catégories : méthodes d’instance, surcharge des opérateurs, Getters/Setters et méthodes abstraites.

1. Instance methods Méthodes d’instance

1. Méthodes appartenant aux instances d’une classe ;
2. Accès direct aux variables d’instance et utilisation du mot-clé this autorisée ;
3. Corps de fonction complet pour réaliser des calculs métier et des traitements logiques.

import 'dart:math';

class Point {
  final double x;
  final double y;

  // Constructeur initialisant les variables d'instance
  Point(this.x, this.y);

  // Méthode d'instance : calculer la distance entre deux points
  double distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }
}

void main() {
  Point p1 = Point(0, 0);
  Point p2 = Point(3, 4);
  print(p1.distanceTo(p2)); // Affiche 5.0
}Langage du code : JavaScript (javascript)

2. Operators Surcharge des opérateurs

1. La plupart des opérateurs sont en réalité des méthodes d’instance à nom spécial ;
2. Syntaxe de déclaration : operator opérateur(paramètre) TypeRetour { ... } ;
3. Liste des opérateurs surchargeables :
   < > <= >= == ~
- + / ~/ * %
| ˆ & << >>> >>
[]= []
4. Certains opérateurs natifs ne peuvent pas être surchargés (ex: !=, implémenté automatiquement par Dart sans définition manuelle) ;
5. La surcharge de == impose de redéfinir simultanément hashCode, sinon les comparaisons d’égalité présenteront des anomalies.

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  // Surcharge de l'opérateur + pour l'addition vectorielle
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  // Surcharge de l'opérateur - pour la soustraction vectorielle
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // Surcharge de == pour la comparaison d'égalité
  @override
  bool operator ==(Object other) =>
      other is Vector && x == other.x && y == other.y;

  // Redéfinition associée de hashCode
  @override
  int get hashCode => Object.hash(x, y);
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
  print(v + w);
}Langage du code : JavaScript (javascript)

Après surcharge des opérateurs, nous pouvons appliquer des opérateurs numériques comme +, -, == sur deux objets Vector exactement comme sur des nombres.

3. Getters and setters Accesseurs

1. get : méthode en lecture seule, récupère une propriété calculée, sans paramètres ;
2. set : méthode en écriture, modifie une variable liée, un seul paramètre autorisé ;
3. Toutes les variables d’instance disposent d’un getter implicite ; les variables mutables possèdent également un setter implicite ;
4. Avantage : transformer ultérieurement une variable simple en logique de calcul sans modifier le code appelant externe ;
5. Les opérateurs d’incrément/décrément ++/-- n’appellent le getter qu’une seule fois et mettent en cache la valeur pour éviter les effets secondaires.

/// Rectangle du système de coordonnées écran, origine (0,0) en haut à gauche
class Rectangle {
  double left, top, width, height;

  Rectangle(this.left, this.top, this.width, this.height);

  // Getter : calculer la limite droite
  double get right => left + width;

  // Setter : affecter la limite droite et mettre à jour left en sens inverse
  set right(double value) => left = value - width;

  // Getter : calculer la limite basse
  double get bottom => top + height;

  // Setter : affecter la limite basse et mettre à jour top en sens inverse
  set bottom(double value) => top = value - height;
}

void main() {
  var rect = Rectangle(3, 4, 20, 15);
  assert(rect.left == 3);

  // Appel du setter
  rect.right = 12;
  assert(rect.left == -8);
  print(rect.left); // -8
}Langage du code : JavaScript (javascript)

4. Abstract methods Méthodes abstraites

1. Définit uniquement une interface sans corps de fonction ; un point-virgule ; remplace l’implémentation ;
2. Ne peut exister que dans une abstract class classe abstraite ou un mixin ;
3. Les sous-classes doivent redéfinir et implémenter l’intégralité des méthodes abstraites, sinon la sous-classe doit aussi être marquée abstract.

// Classe abstraite contenant une méthode abstraite
abstract class Doer {
  // Méthode abstraite : déclaration seule, pas d'implémentation
  void doSomething();
}

// Sous-classe concrète, doit implémenter toutes les méthodes abstraites parentes
class EffectiveDoer extends Doer {
  @override
  void doSomething() {
    print("Exécuter la logique métier concrète");
  }
}

void main() {
  Doer worker = EffectiveDoer();
  worker.doSomething(); // Affiche : Exécuter la logique métier concrète
}Langage du code : JavaScript (javascript)

Comparatif