(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

override (C#-Referenz)

Der override-Modifizierer wird benötigt, um die abstrakte oder virtuelle Implementierung einer geerbten Methode oder Eigenschaft bzw. eines geerbten Indexers oder Ereignisses zu erweitern oder zu ändern.

In diesem Beispiel muss die Square-Klasse eine überschriebene Implementierung von Area bereitstellen, da Area von der abstrakten ShapesClass geerbt wird:



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


Eine override-Methode stellt eine neue Implementierung eines von einer Basisklasse geerbten Members bereit. Die durch eine override-Deklaration überschriebene Methode wird als überschriebene Basismethode bezeichnet. Diese muss dieselbe Signatur wie die override-Methode aufweisen. Weitere Informationen über die Vererbung finden Sie unter Vererbung (C#-Programmierhandbuch).

Eine nicht virtuelle oder statische Methode darf nicht überschrieben werden. Bei der überschriebenen Basismethode muss es sich um eine virtual-, abstract- oder override-Methode handeln.

Der Zugriff auf die virtual-Methode kann durch eine override-Deklaration nicht geändert werden. Die override-Methode und die virtual-Methode müssen denselben Zugriffsebenenmodifizierer aufweisen.

Zum Ändern einer override-Methode können Sie nicht die Modifizierer new, static oder virtual verwenden.

Eine überschreibende Eigenschaftendeklaration muss genau denselben Zugriffsmodifizierer, Typ und Namen wie die geerbte Eigenschaft verwenden, und bei der überschriebenen Eigenschaft muss es sich um eine der Eigenschaften virtual, abstract oder override handeln.

Weitere Informationen zum Verwenden des override-Schlüsselworts finden Sie unter Versionsverwaltung mit den Schlüsselwörtern "override" und "new" (C#-Programmierhandbuch) und Wann müssen die Schlüsselwörter "Override" und "New" verwendet werden?.

Im folgenden Beispiel werden die Basisklasse Employee und die abgeleitete Klasse SalesEmployee definiert. Die SalesEmployee-Klasse enthält die zusätzliche salesbonus-Eigenschaft. Um diese zu berücksichtigen, überschreibt sie die CalculatePay-Methode.


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


Weitere Informationen finden Sie in der C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft