Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte.
Traduction
Source

Héritage (Guide de programmation C#)

L'héritage, avec l'encapsulation et le polymorphisme, est l'une des trois caractéristiques principales (ou piliers) de la programmation orientée objet. Il vous permet de créer de nouvelles classes qui réutilisent, étendent et modifient le comportement défini dans d'autres classes. La classe dont les membres sont hérités porte le nom de classe de base et la classe qui hérite de ces membres porte le nom de classe dérivée. Une classe dérivée ne peut avoir qu'une seule classe de base directe. Toutefois, l'héritage est transitif. Si ClassC est dérivé de ClassB et ClassB est dérivé de ClassA, ClassC hérite des membres déclarés dans ClassB et ClassA.

RemarqueRemarque

Les structs ne prennent pas en charge l'héritage, mais ils peuvent implémenter des interfaces. Pour plus d'informations, consultez Interfaces (Guide de programmation C#).

Conceptuellement, une classe dérivée est une spécialisation de la classe de base. Par exemple, si vous avez une classe de base Animal, vous pouvez avoir une classe dérivée nommée Mammal et une autre classe dérivée nommée Reptile. Un Mammal est un Animal et un Reptile est un Animal, mais chaque classe dérivée représente des spécialisations différentes de la classe de base.

Lorsque vous définissez une classe à dériver d'une autre classe, la classe dérivée obtient implicitement tous les membres de la classe de base, à l'exception de ses constructeurs et destructeurs. La classe dérivée peut ainsi réutiliser le code dans la classe de base sans avoir à le réimplémenter. Dans la classe dérivée, vous pouvez ajouter davantage de membres. De cette manière, la classe dérivée étend la fonctionnalité de la classe de base.

L'illustration suivante montre une classe WorkItem qui représente un élément de travail dans un processus métier. Comme toutes les classes, elle dérive de System.Object et hérite de toutes ses méthodes. WorkItem ajoute cinq de ses membres. Cela inclut un constructeur, parce que les constructeurs ne sont pas hérités. La classe ChangeRequest hérite de WorkItem et représente un type particulier d'élément de travail. ChangeRequest ajoute deux membres supplémentaires aux membres qu'il hérite de WorkItem et Object. Elle doit ajouter son propre constructeur et ajoute également originalItemID. La propriété originalItemID permet à l'instance de ChangeRequest d'être associée à WorkItem d'origine auquel la demande de modification s'applique.

Héritage de classe

Héritage de classe

L'exemple suivant illustre la manière dont les relations de classe démontrées dans l'illustration précédente sont exprimées en C#. Il indique également comment WorkItem substitue la méthode virtuelle Object.ToString et comment la classe ChangeRequest hérite de l'implémentation WorkItem de la méthode.


// WorkItem implicitly inherits from the Object class.
public class WorkItem
{
    // Static field currentID stores the job ID of the last WorkItem that
    // has been created.
    private static int currentID;

    //Properties.
    protected int ID { get; set; }
    protected string Title { get; set; }
    protected string Description { get; set; }
    protected TimeSpan jobLength { get; set; }

    // Default constructor. If a derived class does not invoke a base-
    // class constructor explicitly, the default constructor is called
    // implicitly. 
    public WorkItem()
    {
        ID = 0;
        Title = "Default title";
        Description = "Default description.";
        jobLength = new TimeSpan();
    }

    // Instance constructor that has three parameters.
    public WorkItem(string title, string desc, TimeSpan joblen)
    {
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = joblen;
    }

    // Static constructor to initialize the static member, currentID. This
    // constructor is called one time, automatically, before any instance
    // of WorkItem or ChangeRequest is created, or currentID is referenced.
    static WorkItem()
    {
        currentID = 0;
    }


    protected int GetNextID()
    {
        // currentID is a static field. It is incremented each time a new
        // instance of WorkItem is created.
        return ++currentID;
    }

    // Method Update enables you to update the title and job length of an
    // existing WorkItem object.
    public void Update(string title, TimeSpan joblen)
    {
        this.Title = title;
        this.jobLength = joblen;
    }

    // Virtual method override of the ToString method that is inherited
    // from System.Object.
    public override string ToString()
    {
        return String.Format("{0} - {1}", this.ID, this.Title);
    }
}

// ChangeRequest derives from WorkItem and adds a property (originalItemID) 
// and two constructors.
public class ChangeRequest : WorkItem
{
    protected int originalItemID { get; set; }

    // Constructors. Because neither constructor calls a base-class 
    // constructor explicitly, the default constructor in the base class
    // is called implicitly. The base class must contain a default 
    // constructor.

    // Default constructor for the derived class.
    public ChangeRequest() { }

    // Instance constructor that has four parameters.
    public ChangeRequest(string title, string desc, TimeSpan jobLen,
                         int originalID)
    {
        // The following properties and the GetNexID method are inherited 
        // from WorkItem.
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = jobLen;

        // Property originalItemId is a member of ChangeRequest, but not 
        // of WorkItem.
        this.originalItemID = originalID;
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of WorkItem by using the constructor in the 
        // base class that takes three arguments.
        WorkItem item = new WorkItem("Fix Bugs",
                                     "Fix all bugs in my code branch",
                                     new TimeSpan(3, 4, 0, 0));

        // Create an instance of ChangeRequest by using the constructor in
        // the derived class that takes four arguments.
        ChangeRequest change = new ChangeRequest("Change Base Class Design",
                                                 "Add members to the class",
                                                 new TimeSpan(4, 0, 0),
                                                 1);

        // Use the ToString method defined in WorkItem.
        Console.WriteLine(item.ToString());

        // Use the inherited Update method to change the title of the 
        // ChangeRequest object.
        change.Update("Change the Design of the Base Class",
            new TimeSpan(4, 0, 0));

        // ChangeRequest inherits WorkItem's override of ToString.
        Console.WriteLine(change.ToString());

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    1 - Fix Bugs
    2 - Change the Design of the Base Class
*/


Lorsqu'une classe de base déclare une méthode comme virtuelle, une classe dérivée peut substituer la méthode avec sa propre implémentation. Si une classe de base déclare un membre comme abstrait, cette méthode doit être substituée dans toute classe non abstraite qui hérite directement de cette classe. Si une classe dérivée est elle-même abstraite, elle hérite des membres abstraits sans les implémenter. Les membres virtuels et abstraits sont la base du polymorphisme, qui est la deuxième caractéristique principale de la programmation orientée objet. Pour plus d'informations, consultez Polymorphisme (Guide de programmation C#).

Vous pouvez déclarer une classe comme abstraite si vous souhaitez empêcher l'instanciation directe au moyen du mot clé new . Dans ce cas, la classe peut être utilisée uniquement si une classe nouvelle est dérivée d'elle. Une classe abstraite peut contenir une ou plusieurs signatures de méthode qui elles-mêmes sont déclarées comme abstraites. Ces signatures spécifient les paramètres et valeurs de retour, mais n'ont aucune implémentation (corps de méthode). Il n'est pas obligatoire qu'une classe abstraite contienne des membres abstraits ; toutefois, si une classe contient un membre abstrait, la classe elle-même doit être déclarée comme abstraite. Les classes dérivées qui ne sont pas elles-mêmes abstraites doivent fournir l'implémentation pour toute méthode abstraite à partir d'une classe de base abstraite. Pour plus d'informations, consultez Classes abstract et sealed et membres de classe (Guide de programmation C#) et Conception de classes abstraites.

Une interface est un type référence quelque peu semblable à une classe de base abstraite qui se compose uniquement de membres abstraits. Lorsqu'une classe implémente une interface, elle doit fournir une implémentation pour tous les membres de l'interface. Une classe peut implémenter plusieurs interfaces, bien qu'elle puisse dériver d'une classe de base directe unique.

Les interfaces sont utilisées pour définir des fonctions spécifiques pour les classes qui n'ont pas nécessairement de relation « est un ». Par exemple, l'interface System.IEquatable<T> peut être implémentée par toute classe ou tout struct qui doit permettre au code client de déterminer si deux objets du type sont équivalents (quelle que soit la façon dont le type définit l'équivalence). IEquatable<T> n'implique pas le même type de relation « est un » que celle qui existe entre une classe de base et une classe dérivée (par exemple, un Mammal est un Animal). Pour plus d'informations, consultez Interfaces (Guide de programmation C#).

Une classe dérivée a accès aux membres publics, protégés, internes et internes protégés d'une classe de base. Bien qu'une classe dérivée hérite des membres privés d'une classe de base, elle ne peut pas accéder à ces membres. Toutefois, tous ces membres privés sont quand même présents dans la classe dérivée et peuvent effectuer le même travail que dans la classe de base elle-même. Par exemple, supposez qu'une méthode de classe de base protégée accède à un champ privé. Ce champ doit être présent dans la classe dérivée pour que la méthode de classe de base héritée fonctionne correctement.

Une classe peut empêcher d'autres classes d'hériter d'elle, ou de l'un de ses membres, en se déclarant elle-même ou le membre comme sealed. Pour plus d'informations, consultez Classes abstract et sealed et membres de classe (Guide de programmation C#).

Une classe dérivée peut masquer des membres de la classe de base en déclarant ces membres avec les mêmes nom et signature. Le modificateur new peut être utilisé pour indiquer explicitement que le membre n'est pas censé être une substitution du membre de base. L'utilisation de new n'est pas obligatoire, mais un avertissement du compilateur est généré si new n'est pas utilisé. Pour plus d'informations, consultez Versioning avec les mots clés override et new (Guide de programmation C#) et Savoir quand utiliser les mots clés override et new (Guide de programmation C#).

Date

Historique

Motif

Août 2010

A simplifié l'exemple et a ajouté des commentaires pour améliorer la clarté.

Commentaires client.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft