Qu'est-ce qu'une méthode ?
Comme dit précédemment, les fonctions sont des blocs de code désignés par un nom, que vous pouvez réutiliser. Ce bloc de code est un ensemble d'instructions qui peut être appelé par un programme.
Mais que sont les méthodes, au juste ?
Les méthodes sont aussi des fonctions définies à l'intérieur d'une classe. Puisque tout en C# est défini dans une classe, chaque fonction est également une méthode. Néanmoins, on distingue les méthodes d'instance qui sont exécutées dans le contexte d'un objet, et les méthodes de classe, qui opèrent directement sur la classe.
Trop abstrait, n'est-ce pas ? Alors, décortiquons tout cela.
Définissez des méthodes d'instance
Lorsque vous créez une classe, vous définissez ses champs sous forme de variables. Ensuite, vous pouvez écrire des méthodes pour utiliser ces champs.
Définissons par exemple une classe avec deux nombres entiers :
class MathMagiques
{
int a;
int b;
}Créons ensuite une méthode dans la classe qui peut modifier ces valeurs :
class MathMagiques
{
int a;
int b;
public void ModifierValeurs()
{
a = 2;
b = 7;
}
}Comme la méthode ModifierValeurs utilise les valeurs de champs qui existent uniquement après la création d'un objet MathMagiques, il s'agit d'une méthode d'instance.
Pour pouvoir utiliser cet objet, vous devez instancier la classe MathMagiques en créant une variable de cette classe :
MathMagiques mathMagiques = new MathMagiques();Après cela, vous pouvez appeler votre nouvelle méthode pour modifier les valeurs de la nouvelle instance de la classe :
mathMagiques.ModifierValeurs();Comme vous l'avez remarqué ci-dessus, on utilise une technique commune à de nombreux langages de programmation pour appeler une méthode : la notation par points. Cela signifie que vous devez écrire le nom d'une variable d'instance suivi du nom de la méthode, en les séparant par un point : nomVariableInstance.NomMethode(); .
Revenons à notre exemple en rassemblant tout le code :
using System;
namespace Methodes
{
public class Programme
{
public static void Main()
{
MathMagiques mathMagiques = new MathMagiques();
Console.WriteLine("a=" + mathMagiques.a + ", b=" + mathMagiques.b);
mathMagiques.ModifierValeurs();
Console.WriteLine("a=" + mathMagiques.a + ", b=" + mathMagiques.b);
}
class MathMagiques
{
public int a;
public int b;
public void ModifierValeurs()
{
this.a = 2;
this.b = 7;
}
}
}
}Exécutons ce code :
a=0, b=0 a=2, b=7
Avez-vous remarqué que nous avons pu afficher le contenu des attributs avant de leur attribuer une valeur ? Contrairement à ce qui se passe avec les variables locales, si aucune valeur n'est fournie, C# initialise automatiquement les champs avec la valeur par défaut pour le type du champ.
Si vous voulez que l'objet soit créé avec une valeur différente de celle par défaut pour chaque champ, vous devez écrire une méthode dite constructeur. Cette méthode est automatiquement appelée quand un nouvel objet est instancié, et permet de définir les valeurs des champs soit directement, soit par le biais d'une autre méthode.
En C#, le constructeur doit porter le même nom que la classe. Il n'a pas de type de retour, même pas void .
Dans l'exemple suivant, le constructeur utilise une méthode pour initialiser les champs :
public class MathMagiques {
public int a;
public int b;
// Créer l'objet grâce à la méthode ModifierValeurs()
public MathMagiques()
{
this.ModifierValeurs();
}
// Affecter la valeur 1 à a et 5 à b
public void ModifierValeurs()
{
this.a = 1;
this.b = 5;
}
}Tout objet instancié à partir de cette classe sera initialisé avec les valeurs définies dans la méthode ModifierValeurs .
Définissez des membres statiques
Comme nous l'avons dit précédemment, vous pouvez créer des méthodes qui utilisent les membres d'instance d'une classe. Il existe aussi des méthodes statiques. Pour les utiliser, il n’est pas nécessaire d’instancier un objet. Elles utilisent les membres statiques de la classe ou exécutent des instructions qui concernent la classe en général.
En C#, les membres statiques (champs et méthodes) sont marqués par le mot-clé static à la déclaration. L'exemple suivant montre une méthode de classe et un champ statique dans une définition de classe :
class NomClasse
{
double variableInstance;
static int variableDeClasse;
public void MethodeInstance()
{
// Peut accéder à la fois à variableInstance et à variableDeClasse
}
public static void MethodeClasse()
{
// Ne fonctionne qu'au niveau de la classe, ne peut accéder qu'à variableDeClasse
}
}Les méthodes de classe sont appelées avec la même notation par points que les méthodes d'instance. En revanche, l'appel se fait directement sur le nom de la classe.
NomClasse.MethodeClasse();Par exemple, vous pouvez déclarer une classe Voiture avec un champ statique qui sera incrémenté à chaque fois que vous créerez une instance de la classe. Vous pourrez ainsi connaître le nombre d'objets Voiture qui ont été créés.
class Voiture
{
private static int compteur = 0;
public static void Incrementer()
{
Voiture.compteur += 1;
}
}Chaque fois que vous créez un objet Voiture , vous pouvez incrémenter le compteur :
Voiture.Incrementer();Il est important de connaître la différence entre ces deux catégories de méthodes pour pouvoir déterminer ce qui convient le mieux à l'implémentation de vos classes.
Répétons-le :
Les méthodes d'instance s'utilisent dans le contexte d'une instance de classe. On doit instancier un objet pour les utiliser.
Les méthodes statiques s'utilisent dans le contexte d'une classe en général et ne nécessitent pas qu'on instancie un objet pour les utiliser.
Les méthodes statiques sont utilisées à l'intérieur des classes statiques. Elles fournissent des fonctionnalités qui peuvent être utilisées par d'autres classes. La classe Math en est un exemple.
D'autre part, les classes de plan sont les plus précieuses, car elles définissent à la fois un état (avec des champs) et un comportement (avec des méthodes d'instance). Vous avez déjà vu que vous pouvez créer une instance avec les valeurs appropriées grâce à un constructeur. Voyons maintenant comment nous pouvons nous assurer que les valeurs restent pertinentes par rapport à vos besoins.
Utilisez les propriétés pour vérifier vos champs
Lorsque vous travaillez avec des classes et des objets, il est important de s'assurer que les objets restent pertinents depuis leur création jusqu'à la fin de leur utilisation.
Pour cela, deux membres spéciaux de classe sont utilisés :
Les constructeurs, qui garantissent que les valeurs appropriées sont données aux champs de l'objet dès sa création
Les propriétés, dont le but est de contrôler l'accès aux champs
Pour définir une propriété, vous devez définir un accesseur (getter) ou un mutateur (setter), ou les deux.
La propriété getter retourne la valeur actuelle d'un champ. Cela signifie que vous pouvez marquer vos champs comme étant privés et ne fournir des accesseurs que pour ceux qui doivent être accessibles à d'autres classes.
La propriété setter permet non seulement de contrôler les champs qui peuvent être modifiés, mais aussi d'appliquer des règles métier sur les valeurs qui peuvent être définies.
Par exemple, déclarons une classe Carre disposant de deux champs, longueur et largeur. Voici à quoi cela ressemble en C# :
public class Carre
{
private int longueur;
private int largeur;
public Carre(int longueur, int largeur)
{
this.longueur = longueur;
this.largeur = largeur;
}
public int Longueur
{
get
{
return this.longueur;
}
set
{
this.longueur = value;
}
}
}Nous pouvons ensuite l'utiliser :
public static void Main(String[] args)
{
// Créer un carré d'une longueur de 10 et d'une largeur de 4.
Carre carre = new Carre(10, 4);
Console.WriteLine(carre.longueur); // Impossible, car le champ longueur est privé
Console.WriteLine(carre.Longueur); // -> 10
carre.Longueur = 16;
Console.WriteLine(carre.Longueur); // -> 16
}Si vous voulez une propriété supplémentaire que vous pouvez déduire à partir de champs existants (comme le périmètre), vous pouvez en définir une qui utilisera les champs.
Testez par vous-même !
Prêt à coder ? Pour accéder à l’exercice, suivez ce lien.
En résumé
Dans ce chapitre, vous avez découvert les points suivants :
Les méthodes d'une classe sont des fonctions qui s'utilisent dans le contexte de ladite classe.
Les méthodes d'instance utilisent les champs de l'instance de la classe en question. Elles sont appelées sur un objet après son instanciation.
Les méthodes statiques s'utilisent dans le contexte global d'une classe et ne nécessitent pas l'instanciation d'un objet.
Pour appeler des méthodes, on utilise couramment la notation par points :
nomVariableInstance.NomMethodeouNomClasse.NomMethode.Les constructeurs et les propriétés sont des membres spéciaux qui garantissent la validité des valeurs des champs d'un objet.
