Constructeurs d'instances (Guide de programmation C#)
Les constructeurs d'instances permettent de créer et initialiser des instances. Le constructeur de classe est appelé lorsque vous créez un nouvel objet. Exemple :
class CoOrds
{
public int x, y;
// constructor
public CoOrds()
{
x = 0;
y = 0;
}
}
Notes
Dans un souci de clarté, cette classe contient des données membres publiques. Cette pratique de programmation n'est pas recommandée, car elle octroie à n'importe quelle méthode n'importe où dans un programme un accès sans restriction ni vérification aux mécanismes internes d'un objet. Les membres Data doivent généralement être privés et doivent être accessibles uniquement par le biais de méthodes de classe et de propriétés.
Ce constructeur est appelé à chaque fois qu'un objet basé sur la classe CoOrds
est créé. Un constructeur comme celui-ci, qui ne prend pas d'arguments, est appelé un constructeur par défaut. Toutefois, il est souvent utile de fournir des constructeurs supplémentaires. Par exemple, nous pouvons ajouter un constructeur à la classe CoOrds
qui nous permet de spécifier des valeurs initiales pour les données membre :
// A constructor with two arguments:
public CoOrds(int x, int y)
{
this.x = x;
this.y = y;
}
Cela autorise la création d'objets CoOrd
avec des valeurs par défaut ou initiales spécifiques, comme suit :
CoOrds p1 = new CoOrds();
CoOrds p2 = new CoOrds(5, 3);
Si une classe n'a pas de constructeur par défaut, il en est généré un automatiquement et les valeurs par défaut sont utilisées pour initialiser les champs d'objet, par exemple, int est initialisé à 0. Pour plus d'informations sur les valeurs par défaut, consultez Tableau des valeurs par défaut (Référence C#). Par conséquent, parce que le constructeur par défaut de classe CoOrds
initialise toutes les données membre à zéro, il peut être supprimé entièrement sans modification du comportement de la classe. Un exemple complet d'utilisation de plusieurs constructeurs est fourni ultérieurement dans l'exemple 1 de cette rubrique, et un exemple d'un constructeur généré automatiquement est fourni dans l'exemple 2.
Les constructeurs d'instance peuvent servir à appeler les constructeurs d'instance des classes de base. Le constructeur de classe peut appeler le constructeur de la classe de base par l'intermédiaire de l'initialiseur, comme suit :
class Circle : Shape
{
public Circle(double radius)
: base(radius, 0)
{
}
}
Dans cet exemple, la classe Circle
passe des valeurs représentant le rayon et la hauteur au constructeur fourni par Shape
, duquel Circle
est dérivé. Un exemple complet d'utilisation de Shape
et Circle
apparaît dans cette rubrique en tant qu'exemple 3.
Exemple 1
L'exemple suivant illustre une classe possédant deux constructeurs de classe, l'un sans argument et l'autre doté de deux arguments.
class CoOrds
{
public int x, y;
// Default constructor:
public CoOrds()
{
x = 0;
y = 0;
}
// A constructor with two arguments:
public CoOrds(int x, int y)
{
this.x = x;
this.y = y;
}
// Override the ToString method:
public override string ToString()
{
return (System.String.Format("({0},{1})", x, y));
}
}
class MainClass
{
static void Main()
{
CoOrds p1 = new CoOrds();
CoOrds p2 = new CoOrds(5, 3);
// Display the results using the overriden ToString method:
System.Console.WriteLine("CoOrds #1 at {0}", p1);
System.Console.WriteLine("CoOrds #2 at {0}", p2);
}
}
Sortie
CoOrds #1 at (0,0)
CoOrds #2 at (5,3)
Exemple 2
Dans cet exemple, la classe Person
ne possède aucun constructeur, auquel cas un constructeur par défaut est fourni automatiquement, dont les champs sont initialisés sur leurs valeurs par défaut.
public class Person
{
public int age;
public string name;
}
class TestPerson
{
static void Main()
{
Person p = new Person();
System.Console.Write("Name: {0}, Age: {1}", p.name, p.age);
}
}
Sortie
Name: , Age: 0
Notez que la valeur par défaut de age
est 0
et que celle de name
est null. Pour plus d'informations sur les valeurs par défaut, consultez Tableau des valeurs par défaut (Référence C#).
Exemple 3
L'exemple suivant illustre l'utilisation de l'initialiseur de classe de base. La classe Circle
est dérivée de la classe générale Shape
, et la classe Cylinder
est dérivée de la classe Circle
. Le constructeur de chaque classe dérivée utilise son initialiseur de classe de base.
abstract class Shape
{
public const double pi = System.Math.PI;
protected double x, y;
public Shape(double x, double y)
{
this.x = x;
this.y = y;
}
public abstract double Area();
}
class Circle : Shape
{
public Circle(double radius)
: base(radius, 0)
{
}
public override double Area()
{
return pi * x * x;
}
}
class Cylinder : Circle
{
public Cylinder(double radius, double height)
: base(radius)
{
y = height;
}
public override double Area()
{
return (2 * base.Area()) + (2 * pi * x * y);
}
}
class TestShapes
{
static void Main()
{
double radius = 2.5;
double height = 3.0;
Circle ring = new Circle(radius);
Cylinder tube = new Cylinder(radius, height);
System.Console.WriteLine("Area of the circle = {0:F2}", ring.Area());
System.Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area());
}
}
Sortie
Area of the circle = 19.63
Area of the cylinder = 86.39
Pour obtenir d'autres exemples sur l'appel des constructeurs de classe de base, consultez virtual (Référence C#), override (Référence C#) et base (Référence C#).
Voir aussi
Référence
Objets, classes et structs (Guide de programmation C#)
Destructeurs (Guide de programmation C#)
static (Référence C#)