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
}

• Objectif : Manipuler les méthodes (avec/sans retour, avec/sans paramètres) en Dart.
• Contexte
  Tu es en train de développer une application console pour gérer une petite bibliothèque. Tu dois créer une classe Livre avec des méthodes associées à la gestion des livres.

Instructions

• 1. Crée une classe Livre avec les attributs suivants :
• String titre
• String auteur
• int annee
• bool estDisponible
• 2. Ajoute un constructeur pour initialiser un livre.
• 3. Implémente les méthodes suivantes :
• void afficherInfos() : affiche les informations du livre.
• bool estRecent() : retourne true si le livre a été publié après 2015.
• void emprunter() : modifie l’état de disponibilité à false.
• void retourner() : modifie l’état de disponibilité à true.
• 4. Crée une fonction main() :
• Crée 3 objets Livre.
• Affiche leurs informations.
• Emprunte un livre, puis vérifie et affiche sa disponibilité.
• Retourne le livre, puis vérifie et affiche à nouveau sa disponibilité.
• Affiche si les livres sont récents ou non en utilisant estRecent().
• Exemple de sortie attendue :
Titre: Dart pour les débutants
Auteur: Jean Dupont
Année: 2021
Disponible: Oui

Emprunt du livre...
Disponible: Non

Retour du livre...
Disponible: Oui

Le livre est récent : Oui

Solution

class Livre {
  String titre;
  String auteur;
  int annee;
  bool estDisponible;

  Livre(this.titre, this.auteur, this.annee, this.estDisponible);

  void afficherInfos() {
    print('Titre: $titre');
    print('Auteur: $auteur');
    print('Année: $annee');
    print('Disponible: ${estDisponible ? "Oui" : "Non"}\n');
  }

  bool estRecent() {
    return annee > 2015;
  }

  void emprunter() {
    estDisponible = false;
    print('Emprunt du livre...');
  }

  void retourner() {
    estDisponible = true;
    print('Retour du livre...');
  }
}

void main() {
  // Création de 3 livres
  Livre livre1 = Livre('Dart pour les débutants', 'Jean Dupont', 2021, true);
  Livre livre2 = Livre('Flutter avancé', 'Sophie Martin', 2018, true);
  Livre livre3 = Livre('Programmation C', 'Luc Durand', 2010, true);

  // Affichage des infos
  livre1.afficherInfos();
  livre2.afficherInfos();
  livre3.afficherInfos();

  // Emprunter livre1
  livre1.emprunter();
  print('Disponible: ${livre1.estDisponible ? "Oui" : "Non"}\n');

  // Retourner livre1
  livre1.retourner();
  print('Disponible: ${livre1.estDisponible ? "Oui" : "Non"}\n');

  // Vérifier si les livres sont récents
  print('Le livre "${livre1.titre}" est récent : ${livre1.estRecent() ? "Oui" : "Non"}');
  print('Le livre "${livre2.titre}" est récent : ${livre2.estRecent() ? "Oui" : "Non"}');
  print('Le livre "${livre3.titre}" est récent : ${livre3.estRecent() ? "Oui" : "Non"}');
}

• Créez une classe Rectangle avec deux propriétés longueur et largeur.
• Ajoutez une méthode d'instance calculerAire() qui retourne l'aire du rectangle.

Exercice 3 : Méthode Statique

• Dans la classe Rectangle, ajoutez une méthode statique calculerPerimetre(int longueur, int largeur) qui calcule le périmètre.
• Dans main(), créez une instance de Rectangle avec longueur = 5 et largeur = 3, puis :
• Appelez calculerAire() depuis l'instance.
• Appelez calculerPerimetre(5, 3) directement depuis la classe.

• Modifiez la classe Rectangle pour que longueur et largeur soient des paramètres optionnels avec des valeurs par défaut 1.
• Ajoutez une méthode estCarre() qui vérifie si le rectangle est un carré, en utilisant des paramètres nommés.

• Créez une classe MathUtils avec :
• Une méthode statique moyenne() acceptant deux paramètres positionnels obligatoires (a et b).
• Une méthode d'instance puissance() prenant un paramètre obligatoire base et un paramètre nommé exposant (valeur par défaut 2).
• Testez les deux méthodes dans main().

• Trouvez et corrigez les erreurs dans le code suivant :

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

  void afficherResultat() {
    print("Résultat : ${additionner(2, 3)}");
  }
}

void main() {
  Calculatrice.additionner(5, 4); // OK
  Calculatrice.afficherResultat(); // Erreur
}