class (référence C#)
Les classes sont déclarées à l'aide du mot clé class, comme illustré dans l'exemple suivant :
class TestClass
{
// Methods, properties, fields, events, delegates
// and nested classes go here.
}
Notes
Contrairement au langage C++, seul le modèle d'héritage unique est autorisé dans le langage C#. Cela signifie qu'une classe ne peut hériter de l'implémentation que d'une seule classe de base. En revanche, une classe peut implémenter plusieurs interfaces. Le tableau suivant comporte des exemples d'héritage de classe et d'implémentation d'interface.
Héritage |
Exemple |
|---|---|
Aucun |
class ClassA { } |
Single |
class DerivedClass: BaseClass { } |
Aucun, implémente deux interfaces |
class ImplClass: IFace1, IFace2 { } |
Unique, implémente une seule interface |
class ImplDerivedClass: BaseClass, IFace1 { } |
Les niveaux d'accès protected et private ne sont autorisés que pour des classes imbriquées.
Vous pouvez également déclarer des classes génériques qui ont des paramètres de type ; consultez Classes génériques pour plus d'informations.
Une classe peut contenir les déclarations des membres suivants :
Exemple
L'exemple suivant explique comment déclarer des champs, constructeurs et méthodes de classe. Il illustre aussi 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 classe, Child, contient deux champs privés (name et age) et deux méthodes publiques. La deuxième classe, StringTest, est utilisé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 qui précède, les champs privés (name et age) ne sont accessibles que par le biais des méthodes publiques 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 de ce type :
Console.Write(child1.name); // Error
L'accès aux membres privés de Child à partir de Main serait possible uniquement si Main était un membre de la classe.
Les types déclarés à l'intérieur d'une classe sans modificateur d'accès prennent par défaut la valeur private. Par conséquent, les données membre de cet exemple seraient toujours private si le mot clé était supprimé.
Notez enfin que pour l'objet créé à l'aide du constructeur par défaut (child3), le champ a été initialisé par défaut à la valeur zéro.
Spécification du langage C#
Pour plus d'informations, consultez 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
Référence
Types référence (référence C#)