X++ inheritance

In dit artikel wordt overerving in X++ beschreven, inclusief hoe u een subklasse maakt en een methode overschrijft.

Een subklasse maken

Subklassen zijn klassen die zich uitbreiden of overnemen van andere klassen. Een klasse kan slechts één andere klasse uitbreiden. Meervoudige overname wordt niet ondersteund. Als u een klasse uitbreidt, neemt de subklasse alle methoden en variabelen in de bovenliggende klasse (de superklasse) over. Met subklassen kun je bestaande code hergebruiken voor een specifieker doel. Daarom helpen ze u tijd te besparen tijdens het ontwerp, de ontwikkeling en het testen. Als u het gedrag van een superklasse wilt aanpassen, overschrijft u de methoden in een subklasse. Een superklasse staat vaak bekend als een basisklasse en een subklasse staat vaak bekend als een afgeleide klasse.

Subclass example

In het volgende voorbeeld wordt eerst een klasse gemaakt met de naam Point. Vervolgens wordt de klasse Point uitgebreid om een nieuwe klasse te maken met de naam ThreePoint.

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;
    }
}

Klasse-overerving voorkomen

U kunt voorkomen dat klassen worden overgenomen door de uiteindelijke modifier te gebruiken.

public final class Attribute
{
    int objectField;
}

Een methode overschrijven

De methoden in een klasse worden overgeërfd door elke klasse die de klasse uitbreidt. Als u de functionaliteit van een overgenomen methode wilt wijzigen, maakt u een methode in de subklasse en geeft u die methode vervolgens dezelfde naam en parameters als de methode in de superklasse. Dit proces staat bekend als het overschrijven van de methode.

Wanneer u de subklasse instantiëert, kunt u de verwijzing toewijzen aan een variabele van het type superklasse of het type subklasse. Ongeacht het type variabele wordt de overschreven methode aangeroepen.

In het volgende codevoorbeeld overschrijft de subklasse de schrijfmethode . Er worden twee variabelen gemaakt, beide van het type Punt . Aan de ene wordt een Point-object toegewezen, aan de andere wordt een ThreePoint-object toegewezen. Wanneer de schrijfmethode wordt aangeroepen op het ThreePoint-object , wordt de ThreePoint-versie van de methode aangeroepen.

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)".

Voorkomen dat de methode wordt overschreven

Je kunt statische methoden niet overschrijven omdat ze per klasse bestaan. Om andere gevoelige methoden of kernmethoden te beschermen tegen overruling, gebruik je de laatste modifier. In het volgende voorbeeld, omdat methodAtt als final is verklaard, kun je het niet overschrijven in een klasse die Attribute uitbreidt. Specificeer nieuwe of definitieve methoden niet als definitief.

In het volgende voorbeeld ziet u hoe u het uiteindelijke trefwoord gebruikt.

public class Attribute
{
    int objectVariable;

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

Overschrijven versus overbelasten

Overschrijven vindt plaats wanneer een subklasse de superclass-implementatie van een methode verandert, maar beide methoden dezelfde signatuur hebben.

Overbelasting treedt daarentegen op wanneer meer dan één methode dezelfde naam heeft, maar de methoden verschillende handtekeningen hebben (retourtypen, parameterlijsten of beide). X++ ondersteunt overschrijven, maar geen overbelasting.