Partager via

class (référence C#)

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

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

Remarques

Seul l’héritage unique est autorisé en C#. En d’autres termes, une classe peut hériter de l’implémentation d’une seule classe de base. Toutefois, une classe peut implémenter plusieurs interfaces. Le tableau suivant présente des exemples d’héritage de classe et d’implémentation d’interface :

Héritage Exemple :
Aucun class ClassA { }
Célibataire class DerivedClass : BaseClass { }
Aucun, implémente deux interfaces class ImplClass : IFace1, IFace2 { }
Unique, implémente une 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 publiques ou internes. Les classes sont internal par défaut.

Les membres de classe, y compris les classes imbriquées, peuvent être publics, protégés internes, protégés, internes, privés ou privés. Les membres sont private par défaut.

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 des déclarations des membres suivants :

Exemple :

L’exemple suivant illustre la déclaration de champs de classe, de constructeurs et de méthodes. Il illustre également l’instanciation des objets et l’impression de données d’instance. Dans cet exemple, deux classes sont déclarées. La première classe, Childcontient deux champs privés (name et age), deux constructeurs publics et une méthode publique. La deuxième classe, est StringTestutilisée pour contenir 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édent, les champs privés (name et age) sont accessibles uniquement via la méthode publique de la Child classe. Par exemple, vous ne pouvez pas imprimer le nom de l’enfant, à partir de la méthode, à l’aide Main d’une instruction semblable à ceci :

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

L’accès aux membres privés de Child partir Main ne serait possible que s’il Main s’agissait d’un membre de la classe.

Les types déclarés à l’intérieur d’une classe sans modificateur d’accès par défaut private, les membres de données de cet exemple seraient toujours private si le mot clé a été supprimé.

Enfin, notez que pour l’objet créé à l’aide du constructeur sans paramètre (child3), le age champ a été initialisé à zéro par défaut.

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

  • Last updated on