Condividi tramite

override (riferimenti per C#)

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

Nell'esempio seguente la Square classe deve fornire un'implementazione sottoposta a override di GetArea perché GetArea viene ereditata dalla classe astratta Shape :

abstract class Shape
{
    public abstract int GetArea();
}

class Square : Shape
{
    private int _side;

    public Square(int n) => _side = n;

    // GetArea method is required to avoid a compile-time error.
    public override int GetArea() => _side * _side;

    static void Main()
    {
        var sq = new Square(12);
        Console.WriteLine($"Area of the square = {sq.GetArea()}");
    }
}
// Output: Area of the square = 144

Un override metodo fornisce una nuova implementazione del metodo ereditato da una classe base. Il metodo sottoposto a override da una override dichiarazione è noto come metodo di base sottoposto a override. Un override metodo deve avere la stessa firma del metodo di base sottoposto a override. override i metodi supportano i tipi restituiti covarianti. In particolare, il tipo restituito di un override metodo può derivare dal tipo restituito del metodo di base corrispondente.

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

Una override dichiarazione non può modificare l'accessibilità del virtual metodo. Sia il override metodo che il virtual metodo devono avere lo stesso modificatore del livello di accesso.

Non è possibile utilizzare i newmodificatori , statico virtual per modificare un override metodo.

Una dichiarazione di proprietà di override deve specificare esattamente lo stesso modificatore di accesso, tipo e nome della proprietà ereditata. Le proprietà di override di sola lettura supportano i tipi restituiti covarianti. La proprietà sottoposta a override deve essere virtual, abstracto override.

Per altre informazioni su come usare la override parola chiave , vedere Controllo delle versioni con le parole chiave Override e New e Sapere quando usare Override e Nuove parole chiave. Per informazioni sull'ereditarietà, vedere Ereditarietà.

Esempio

In questo esempio viene definita una classe base denominata Employeee una classe derivata denominata SalesEmployee. La SalesEmployee classe include un campo aggiuntivo, salesbonuse esegue l'override del metodo CalculatePay per prenderlo in considerazione.

class TestOverride
{
    public class Employee
    {
        public string Name { get; }

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

        // Constructor to set the name and basepay values.
        public Employee(string name, decimal basepay)
        {
            Name = name;
            _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)
        {
            _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.
        var employee1 = new SalesEmployee("Alice", 1000, 500);
        var employee2 = new Employee("Bob", 1200);

        Console.WriteLine($"Employee1 {employee1.Name} earned: {employee1.CalculatePay()}");
        Console.WriteLine($"Employee2 {employee2.Name} earned: {employee2.CalculatePay()}");
    }
}
/*
    Output:
    Employee1 Alice earned: 1500
    Employee2 Bob earned: 1200
*/

Specificazione del linguaggio C#

Per altre informazioni, vedere la sezione Metodi di override della specifica del linguaggio C#.

Per altre informazioni sui tipi restituiti covarianti, vedere la nota sulla proposta di funzionalità.

Vedere anche

  • Last updated on