Condividi tramite


override (Riferimenti per C#)

Aggiornamento: novembre 2007

Il modificatore override è necessario per estendere o modificare l'implementazione astratta o virtuale di un metodo, una proprietà, un indicizzatore o un evento ereditato.

Esempio

In questo esempio, la classe Square deve fornire un'implementazione sottoposta a override dell'oggetto Area poiché quest'ultimo viene ereditato dall'oggetto ShapesClass astratto.

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

Un metodo override fornisce una nuova implementazione di un membro ereditato da una classe base. Il metodo che viene sottoposto a override mediante una dichiarazione override viene definito metodo di base sottoposto a override. Il metodo di base sottoposto a override deve avere la stessa firma del metodo di override. Per informazioni sull'eredità, vedere Ereditarietà (Guida per programmatori C#).

Non è possibile eseguire l'override di un metodo non virtuale o static. Il metodo di base sottoposto a override deve essere virtual, abstract o override.

Le dichiarazioni override non possono modificare l'accessibilità del metodo virtual. Il metodo di override e il metodo virtual devono avere lo stesso modificatore del livello di accesso.

Non è possibile utilizzare i modificatori new, static, virtual o abstract per modificare un metodo override.

Una dichiarazione di proprietà di override deve indicare esattamente lo stesso modificatore di accesso, lo stesso tipo e lo stesso nome della proprietà ereditata. Inoltre, la proprietà sottoposta a override deve essere virtual, abstract o override.

Per ulteriori informazioni su come utilizzare la parola chiave override, vedere Controllo delle versioni con le parole chiave Override e New (Guida per programmatori C#) e Sapere quando utilizzare le parole chiave Override e New.

Nell'esempio seguente vengono definite una classe base denominata Employee e una classe derivata denominata SalesEmployee. La classe SalesEmployee comprende una proprietà aggiuntiva, salesbonus, ed esegue l'override del metodo CalculatePay per prenderla in considerazione.

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
*/

Specifiche del linguaggio C#

Per ulteriori informazioni, vedere le sezioni riportate di seguito in Specifiche del linguaggio C#:

  • 1.6.6.4 Metodi virtuali, di override e astratti

  • 10.6.4 Metodi di override

Vedere anche

Concetti

Guida per programmatori C#

Riferimenti

Ereditarietà (Guida per programmatori C#)

Parole chiave di C#

Modificatori (Riferimenti per C#)

abstract (Riferimenti per C#)

virtual (Riferimenti per C#)

new (Riferimenti per C#)

Polimorfismo (Guida per programmatori C#)

Altre risorse

Riferimenti per C#