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

override (référence C#)

Le modificateur override est nécessaire pour étendre ou modifier l'implémentation abstraite ou virtuelle d'une méthode, d'une propriété, d'un indexeur ou d'un événement hérité(e).

Dans cet exemple, la classe Square doit fournir une implémentation substituée de Area car Area est héritée de la classe abstraite ShapesClass :



abstract class ShapesClass
{
    abstract public int Area();
}
class Square : ShapesClass
{
    int side = 0;

    public Square(int n)
    {
        side = n;
    }
    // Area method is required to avoid
    // a compile-time error.
    public override int Area()
    {
        return side * side;
    }

    static void Main() 
    {
        Square sq = new Square(12);
        Console.WriteLine("Area of the square = {0}", sq.Area());
    }

    interface I
    {
        void M();
    }
    abstract class C : I
    {
        public abstract void M();
    }

}
// Output: Area of the square = 144


Une méthode override fournit une nouvelle implémentation d'un membre hérité d'une classe de base. La méthode substituée par une déclaration override est appelée méthode de base substituée. La méthode de base substituée doit avoir la même signature que la méthode override. Pour plus d'informations sur l'héritage, consultez Héritage (Guide de programmation C#).

Vous pouvez substituer une méthode statique ou non virtuelle. La méthode de base substituée doit être virtual, abstract ou override.

Une déclaration override ne peut pas changer l'accessibilité de la méthode virtual. Les méthodes override et virtual doivent avoir le même modificateur de niveau d'accès.

Vous ne pouvez pas utiliser les modificateurs new, static ou virtual pour modifier une méthode override.

Une déclaration de propriété de substitution doit spécifier exactement les mêmes modificateur d'accès, type et nom que la propriété héritée, et la propriété substituée doit être virtual, abstract ou override.

Pour plus d'informations sur l'utilisation du mot clé override, 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.

Cet exemple définit une classe de base nommée Employee, et une classe dérivée nommée SalesEmployee. La classe SalesEmployee inclut une propriété supplémentaire, salesbonus, et substitue la méthode CalculatePay afin de prendre en compte cette dernière.


class TestOverride
{
    public class Employee
    {
        public string name;

        // Basepay is defined as protected, so that it may be 
        // accessed only by this class and derrived classes.
        protected decimal basepay;

        // Constructor to set the name and basepay values.
        public Employee(string name, decimal basepay)
        {
            this.name = name;
            this.basepay = basepay;
        }

        // Declared virtual so it can be overridden.
        public virtual decimal CalculatePay()
        {
            return basepay;
        }
    }

    // Derive a new class from Employee.
    public class SalesEmployee : Employee
    {
        // New field that will affect the base pay.
        private decimal salesbonus;

        // The constructor calls the base-class version, and
        // initializes the salesbonus field.
        public SalesEmployee(string name, decimal basepay, 
                  decimal salesbonus) : base(name, basepay)
        {
            this.salesbonus = salesbonus;
        }

        // Override the CalculatePay method 
        // to take bonus into account.
        public override decimal CalculatePay()
        {
            return basepay + salesbonus;
        }
    }

    static void Main()
    {
        // Create some new employees.
        SalesEmployee employee1 = new SalesEmployee("Alice", 
                      1000, 500);
        Employee employee2 = new Employee("Bob", 1200);

        Console.WriteLine("Employee4 " + employee1.name + 
                  " earned: " + employee1.CalculatePay());
        Console.WriteLine("Employee4 " + employee2.name + 
                  " earned: " + employee2.CalculatePay());
    }
}
/*
    Output:
    Employee4 Alice earned: 1500
    Employee4 Bob earned: 1200
*/


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.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft