Partager via

class (référence C#)

  • Article

Les classes sont déclarées à l’aide du mot clé class, comme l’illustre l’exemple suivant :

class TestClass
{
    // Methods, properties, fields, events, delegates
    // and nested classes go here.
}

Notes

Le langage C# ne permet qu'un seul héritage. Cela signifie qu’une classe peut uniquement hériter de l’implémentation d’une seule classe de base. Toutefois, une classe peut implémenter plusieurs interfaces. Le tableau suivant répertorie des exemples d’héritage de classe et d’implémentation d’interface :

Héritage Exemple
Aucun class ClassA { }
Unique class DerivedClass : BaseClass { }
Aucun, implémente deux interfaces class ImplClass : IFace1, IFace2 { }
Unique, implémente une seule interface class ImplDerivedClass : BaseClass, IFace1 { }

Les classes que vous déclarez directement dans un espace de noms, non imbriquées dans d’autres classes, peuvent être public ou internal. Par défaut, les classes sont internal.

Les membres de classe, notamment les classes imbriquées, peuvent être public, protected internal, protected, internal, private ou private protected. Par défaut, ils sont private.

Pour plus d’informations, consultez Modificateurs d’accès.

Vous pouvez déclarer des classes génériques qui ont des paramètres de type. Pour plus d’informations, consultez Classes génériques.

Une classe peut contenir les déclarations des membres suivants :

Exemple

L’exemple suivant explique comment déclarer des champs, des constructeurs et des méthodes de classe. Il illustre également l’instanciation d’un objet et l’impression des données d’une instance. Dans cet exemple, deux classes sont déclarées. La première, Child, contient deux champs privés (name et age), deux constructeurs publics et une méthode publique. La deuxième, StringTest, contient Main.

class Child
{
    private int age;
    private string name;

    // Default constructor:
    public Child()
    {
        name = "N/A";
    }

    // Constructor:
    public Child(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // Printing method:
    public void PrintChild()
    {
        Console.WriteLine("{0}, {1} years old.", name, age);
    }
}

class StringTest
{
    static void Main()
    {
        // Create objects by using the new operator:
        Child child1 = new Child("Craig", 11);
        Child child2 = new Child("Sally", 10);

        // Create an object using the default constructor:
        Child child3 = new Child();

        // Display results:
        Console.Write("Child #1: ");
        child1.PrintChild();
        Console.Write("Child #2: ");
        child2.PrintChild();
        Console.Write("Child #3: ");
        child3.PrintChild();
    }
}
/* Output:
    Child #1: Craig, 11 years old.
    Child #2: Sally, 10 years old.
    Child #3: N/A, 0 years old.
*/

Commentaires

Notez que, dans l’exemple précédant, les champs privés (name et age) ne sont accessibles que par le biais de la méthode publique de la classe Child. Par exemple, vous ne pouvez pas imprimer le nom de l’enfant à partir de la méthode Main en utilisant une instruction comme celle-ci :

Console.Write(child1.name);   // Error

L’accès aux membres privés de Child à partir de Main est uniquement possible si Main est un membre de la classe.

Du fait que les types déclarés dans une classe sans modificateur d’accès sont par défaut private, les données membres dans cet exemple sont toujours private si le mot clé est supprimé.

Notez enfin que pour l’objet créé à l’aide du constructeur sans paramètre (child3), le champ age est initialisé par défaut à la valeur zéro.

spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi