Fondamentaux et Pratiques des Méthodes en Dart

1. Les fonctions

• Une fonction est un bloc de code qui peut être appelé à partir d’autres parties du programme. Elle est utilisée pour regrouper des tâches ou des opérations liées, et pour rendre le code plus facile à lire et à maintenir.
• Exemple

void maFonction() {
  // Code de la fonction
}

• Application
• Les fonctions peuvent être utilisées dans une variété d’applications, telles que :
• La modularisation du code : les fonctions permettent de regrouper des tâches ou des opérations liées, ce qui facilite la compréhension et la maintenance du code.
• La réutilisation du code : les fonctions peuvent être réutilisées dans différents endroits du programme, ce qui permet de gagner du temps et des efforts.
• La simplification du code : les fonctions peuvent être utilisées pour simplifier le code en regroupant des tâches complexes.

2. Les méthodes

• Une méthode est une fonction qui est déclarée dans une classe. Elle est utilisée pour définir le comportement d’une classe.
• Exemple

class MaClasse {
  void maMethode() {
    // Code de la méthode
  }
}

• Application
• Les méthodes sont essentielles à la programmation orientée objet. Elles permettent de définir le comportement des classes, et elles sont utilisées pour interagir avec les objets.

La principale différence entre les fonctions et les méthodes est que les méthodes sont déclarées dans des classes. Cela signifie que les méthodes ont accès aux propriétés et aux méthodes de la classe dans laquelle elles sont déclarées.

void maFonction() {...}

class MaClasse { void maMethode() {...}/pre><

• Les méthodes sont essentielles à la programmation orientée objet. Elles permettent de définir le comportement des classes, et elles sont utilisées pour interagir avec les objets.
• Les méthodes offrent plusieurs avantages dans la programmation orientée objet :
• Modularisation du code : les méthodes permettent de regrouper des tâches ou des opérations liées, ce qui facilite la compréhension et la maintenance du code.
• Réutilisation du code : les méthodes peuvent être réutilisées dans différents endroits du programme, ce qui permet de gagner du temps et des efforts.
• Simplicité du code : les méthodes peuvent être utilisées pour simplifier le code en regroupant des tâches complexes.
• Les méthodes permettent également de rendre le code plus flexible et adaptable. Par exemple, les méthodes peuvent être utilisées pour ajouter de nouvelles fonctionnalités aux classes sans modifier le code existant.
• En conclusion, les méthodes sont un outil puissant qui permet de structurer le code et de le rendre plus facile à lire, à maintenir et à adapter.

• En Dart, la déclaration d'une méthode suit la syntaxe suivante :

returnType methodName(parameter1, parameter2, ...) {
  // Code de la méthode
}

• returnType : Type de la valeur renvoyée par la méthode. Utilisez void si la méthode ne renvoie rien.
• methodName : Nom de la méthode.
• parameter1, parameter2, ... : Paramètres que la méthode peut prendre.
• Exemple :

class MaClasse {
  void afficherMessage(String message) {
    print(message);
  }
}

• Les méthodes peuvent être appelées soit depuis la classe elle-même (méthodes statiques), soit depuis une instance de la classe (méthodes d'instance).

1. Appel depuis la Classe (Méthodes Statiques) :

class MaClasse {
  static void methodeStatique() {
    print("Méthode statique");
  }
}

void main() {
  MaClasse.methodeStatique(); // Appel depuis la classe
}

2. Appel depuis une Instance (Méthodes d'Instance) :

class MaClasse {
  void methodeInstance() {
    print("Méthode d'instance");
  }
}

void main() {
  MaClasse instance = MaClasse();
  instance.methodeInstance(); // Appel depuis une instance
}

• Notez que pour appeler une méthode d'instance, vous devez d'abord créer une instance de la classe.

3. Différenciation entre Méthodes Statiques et d'Instance :

• Les méthodes statiques sont appelées directement à partir de la classe.
• Les méthodes d'instance sont appelées à partir d'une instance de la classe.

4. Utilisation des Paramètres dans les Méthodes :

class Calculatrice {
  int additionner(int a, int b) {
    return a + b;
  }
}

void main() {
  Calculatrice calc = Calculatrice();
  int resultat = calc.additionner(2, 3);
  print(resultat); // Affiche : 5
}

• Les paramètres de la méthode (a et b dans cet exemple) sont utilisés à l'intérieur du corps de la méthode.

1. Définition et utilisation des méthodes d'instance

• Les méthodes d'instance sont liées à une instance spécifique de la classe.
• Elles peuvent accéder et manipuler les propriétés de l'objet auquel elles appartiennent.
• Elles sont déclarées sans le mot-clé static.
• Exemple :

class Person {
  String name;

  // Méthode d'instance
  void introduceYourself() {
    print('Bonjour, je m\'appelle $name.');
  }
}

void main() {
  var person = Person();
  person.name = 'Alice';
  person.introduceYourself(); // Affiche "Bonjour, je m'appelle Alice."
}

2. Accès aux propriétés de l'objet à l'intérieur de la méthode

• Les méthodes d'instance peuvent accéder aux propriétés de l'objet en utilisant le mot-clé this.

class Rectangle {
  double width, height;

  double calculateArea() {
    return this.width * this.height;
  }
}

void main() {
  var rect = Rectangle();
  rect.width = 5;
  rect.height = 10;
  print('L\'aire du rectangle est : ${rect.calculateArea()}'); // Affiche "L'aire du rectangle est : 50.0"
}

1. Définition et utilisation des méthodes statiques

• Les méthodes statiques sont liées à la classe plutôt qu'à une instance particulière.
• Elles sont déclarées avec le mot-clé static.
• Elles ne peuvent pas accéder aux propriétés non statiques de la classe directement.

class MathOperations {
  // Méthode statique
  static int add(int a, int b) {
    return a + b;
  }
}

void main() {
  var result = MathOperations.add(3, 5);
  print('La somme est : $result'); // Affiche "La somme est : 8"
}

2. Comparaison avec les méthodes d'instance

• Les méthodes statiques sont appelées sur la classe elle-même, tandis que les méthodes d'instance sont appelées sur une instance particulière de la classe.
• Les méthodes statiques n'ont pas accès aux propriétés non statiques de la classe sans passer par des paramètres.

class Calculator {
  // Méthode d'instance
  int add(int a, int b) {
    return a + b;
  }

  // Méthode statique
  static int multiply(int a, int b) {
    // Impossible d'accéder à des propriétés non statiques ici
    return a * b;
  }
}

void main() {
  var calc = Calculator();
  print(calc.add(2, 3)); // Appel d'une méthode d'instance
  print(Calculator.multiply(2, 3)); // Appel d'une méthode statique
}