Examiner les membres de classe

Terminée

La programmation orientée objet (OOP) est un paradigme de programmation qui utilise des objets pour modéliser des entités réelles. Dans OOP, les classes sont le blueprint de création d’objets et définissent les données et le comportement de ces objets.

Les classes utilisent des champs pour définir les données d’un objet, les propriétés pour contrôler l’accès aux champs et les méthodes pour définir le comportement d’un objet.

Bien que les propriétés et les méthodes soient souvent les plus attentifs, les classes incluent d’autres membres qui aident à définir leur structure et leur comportement. Le tableau suivant répertorie les membres d’une classe :

Membre	Descriptif
Champs	Les champs sont des variables déclarées au niveau de l’étendue de la classe. Un champ peut être un type numérique intégré ou une instance d’une autre classe. Par exemple, une classe de calendrier peut avoir un champ qui contient la date actuelle.
Constantes	Les constantes sont des champs dont la valeur est définie au moment de la compilation et qui ne peuvent pas être modifiées.
Propriétés	Les propriétés sont des méthodes sur une classe accessible comme s’il s’agissait de champs sur cette classe. Une propriété peut fournir une protection pour qu’un champ de classe ne puisse pas être modifié sans connaître l’objet.
Méthode	Les méthodes définissent les actions qu’une classe peut effectuer. Les méthodes peuvent prendre des paramètres qui fournissent des données d’entrée et peuvent retourner des données de sortie via des paramètres. Les méthodes peuvent également retourner une valeur directement, sans utiliser de paramètre.
Épreuves	Les événements fournissent des notifications sur les occurrences, telles que les clics de bouton ou l’achèvement réussi d’une méthode, à d’autres objets. Les événements sont définis et déclenchés à l’aide de délégués.
Opérateurs	Les opérateurs surchargés sont considérés comme membres de type. Lorsque vous surchargez un opérateur, vous le définissez comme une méthode statique publique dans un type.
Indexeurs	Les indexeurs permettent à un objet d’être indexé de manière similaire aux tableaux.
Constructeurs	Les constructeurs sont des méthodes appelées lors de la création de l’objet. Ils sont souvent utilisés pour initialiser les données d’un objet.
Finaliseurs	Les finaliseurs sont rarement utilisés en C#. Il s’agit de méthodes appelées par le moteur d’exécution du runtime lorsque l’objet est sur le point d’être supprimé de la mémoire. Ils sont utilisés pour s’assurer que toutes les ressources qui doivent être libérées sont gérées de manière appropriée.
Types imbriqués	Les types imbriqués sont des types déclarés dans un autre type. Les types imbriqués sont souvent utilisés pour décrire les objets utilisés uniquement par les types qui les contiennent.

Champs, propriétés, méthodes et constructeurs dans une définition de classe

Bien qu’une définition de classe puisse inclure tous les membres répertoriés dans la table, les champs, les propriétés, les méthodes et les constructeurs sont les plus courants. Ces membres forment la structure principale de la plupart des classes en C#, fournissant le stockage de données, les mécanismes d’accès, les définitions de comportement et la logique d’initialisation nécessaires.

L’extrait de code suivant illustre la façon dont les membres de classe courants peuvent être utilisés pour définir et implémenter une classe en C# :

public class Person
{
    // Fields
    private string name;
    private int age;

    // Properties
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int Age
    {
        get { return age; }
        set { age = value; }
    }

    // Constructors
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    // Methods
    public void Display()
    {
        Console.WriteLine($"Name: {Name}, Age: {Age}");
    }
}

class Program
{
    static void Main()
    {
        Person person = new Person("PersonName", 30);
        person.Display();
    }
}

Cet exemple utilise les types de membres suivants :

• Champs : la classe Person a deux champs, name et age, qui sont privés.
• Propriétés : la classe Person a deux propriétés, Name et Age, qui fournissent l’accès aux champs privés. Les propriétés utilisent les accesseurs get et set pour lire et écrire les valeurs des champs.
• Constructeurs : la classe Person a un constructeur qui initialise les champs name et age lorsqu’un nouvel objet Person est créé.
• Méthodes : la classe Person a une méthode Display qui écrit le nom et l’âge de la personne dans la console.

La classe Program contient la méthode Main, qui sert de point d’entrée de l’application. La méthode Main crée un objet Person, l’initialise avec le nom « John » et l’âge 30, puis appelle la méthode person.Display pour écrire les informations de la personne dans la console.