X++-Vererbung

Hinweis

Community-Interessensgruppen sind jetzt von Yammer zu Microsoft Viva Engage gewechselt. Um an einer Viva Engage-Community teilzunehmen und an den neuesten Diskussionen teilzunehmen, füllen Sie das Formular "Anfordern des Zugriffs auf Finance and Operations Viva Engage Community" aus , und wählen Sie die Community aus, der Sie beitreten möchten.

In diesem Artikel wird die Vererbung in X++ beschrieben, einschließlich der Erstellung einer Unterklasse und Überschreiben einer Methode.

Erstellen einer Unterklasse

Unterklassen sind Klassen, die von anderen Klassen erweitern oder erben. Eine Klasse kann nur einen anderen Kurs erweitern. Mehrfachvererbung wird nicht unterstützt. Wenn Sie eine Klasse erweitern, erbt die Unterklasse alle Methoden und Variablen in der übergeordneten Klasse (die Superklasse). Mithilfe von Unterklassen können Sie vorhandenen Code für einen spezifischeren Zweck wiederverwenden. Daher helfen sie Ihnen, Zeit während des Entwurfs, der Entwicklung und des Tests zu sparen. Um das Verhalten einer Superklasse anzupassen, überschreiben Sie die Methoden in einer Unterklasse. Eine Superklasse wird häufig als Basisklasse bezeichnet, und eine Unterklasse wird häufig als abgeleitete Klasse bezeichnet.

Beispiel für Unterklassen

Im folgenden Beispiel wird zuerst eine Klasse mit dem Namen Point erstellt. Anschließend wird die Point-Klasse erweitert, um eine neue Klasse mit dem Namen ThreePoint zu erstellen.

class Point
{
    // Instance fields.
    real x; 
    real y; 

    // Constructor to initialize fields x and y.
    void new(real _x, real _y)
    { 
        x = _x;
        y = _y;
    }
}

class ThreePoint extends Point
{
    // Additional instance fields z. Fields x and y are inherited.
    real z; 

    // Constructor is overridden to initialize z.
    void new(real _x, real _y, real _z)
    {
        // Initialize the fields.
        super(_x, _y); 
        z = _z;
    }
}

Verhindern der Klassenvererbung

Sie können verhindern, dass Klassen mit dem endgültigen Modifizierer geerbt werden.

public final class Attribute
{
    int objectField;
}

Überschreiben einer Methode

Die Methoden in einer Klasse werden von jeder Klasse geerbt, die die Klasse erweitert. Um die Funktionalität einer geerbten Methode zu ändern, erstellen Sie eine Methode in der Unterklasse, und geben Sie dieser Methode dann denselben Namen und Parameter wie die Methode in der Superklasse. Dieser Prozess wird als Außerkraftsetzung der Methode bezeichnet.

Wenn Sie die Unterklasse instanziieren, können Sie den Verweis entweder einer Variablen des Superklassentyps oder des Unterklassentyps zuweisen. Unabhängig vom Typ der Variablen wird die überschriebene Methode aufgerufen.

Im folgenden Codebeispiel überschreibt die Unterklasse die Schreibmethode . Zwei Variablen, beide vom Typ "Point " werden erstellt. Einem objekt wird ein Point-Objekt zugewiesen, dem anderen wird ein ThreePoint-Objekt zugewiesen. Wenn die Schreibmethode für das ThreePoint-Objekt aufgerufen wird, wird die ThreePoint-Version der Methode aufgerufen.

class Point
{
    // Instance fields.
    real x;
    real y;

    // Constructor to initialize fields x and y.
    void new(real _x, real _y)
    {
        x = _x;
        y = _y;
    }

    void write()
    {
        info("(" + any2Str(x) + ", " + any2Str(y) + ")");
    }
}

class ThreePoint extends Point
{
    // Additional instance fields z. Fields x and y are inherited.
    real z;

    // Constructor is overridden to initialize z.
    void new(real _x, real _y, real _z)
    {
        // Initialize the fields.
        super(_x, _y);
        z = _z;
    }

    void write()
    {
        info("(" + any2Str(x) + ", " + any2Str(y) + ", " + any2Str(z) + ")");
    }

}

// Code that creates Point objects and calls the write method.
Point point2 = new Point(1.0, 2.0);
Point point3 = new ThreePoint(3.0, 4.0, 5.0);

point2.write();
// Output is "(1.0, 2.0)".

point3.write();
// Output is "(3.0, 4.0, 5.0)".

Verhindern von Methodenüberschreibungen

Statische Methoden können nicht überschrieben werden, da sie pro Klasse vorhanden sind. Um andere sensible Methoden oder Kernmethoden vor außer Kraft zu setzen, verwenden Sie den endgültigen Modifizierer. Im folgenden Beispiel kann "methodAtt" nicht in einer Klasse außer Kraft gesetzt werden, die das Attribut erweitert. Sie sollten keine neuen oder endgültigen Methoden angeben.

Das folgende Beispiel zeigt, wie das endgültige Schlüsselwort verwendet wird.

public class Attribute
{
    int objectVariable;

    final void methodAtt()
    {
        //Some statements
    }
}

Überschreiben im Vergleich zur Überladung

Überschreiben tritt auf, wenn die Implementierung einer Methode der Superklasse durch die Implementierung dieser Methode geändert wird, aber die Signaturen beider Methoden sind identisch.

Im Gegensatz dazu tritt überladen auf, wenn mehrere Methoden denselben Namen haben, aber die Methoden weisen unterschiedliche Signaturen auf (Rückgabetypen, Parameterlisten oder beides). X++ unterstützt das Überschreiben, unterstützt jedoch keine Überladung.