X++ inheritance

Ez a cikk az X++-beli öröklést ismerteti, beleértve az alosztályok létrehozását és a metódus felülbírálását.

Alosztály létrehozása

Az alosztályok olyan osztályok, amelyek más osztályoktól terjednek ki vagy örökölnek. Egy osztály csak egy másik osztályt terjeszthet ki. A többszörös öröklés nem támogatott. Ha kiterjeszt egy osztályt, az alosztály örökli a szülőosztály (a szuperosztály) összes metódusát és változóját. Az alosztályok lehetővé teszik a meglévő kód egy konkrétabb célú újrafelhasználását. Ezért segítenek időt megtakarítani a tervezés, a fejlesztés és a tesztelés során. A szuperosztály viselkedésének testreszabásához felülbírálja az alosztály metódusait. A szuperosztályt gyakran alaposztálynak, az alosztályt pedig származtatott osztálynak nevezik.

Subclass example

Az alábbi példa először létrehoz egy Pont nevű osztályt. Ezután kibővíti a Pont osztályt egy új, ThreePoint nevű osztály létrehozásához.

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

Osztályöröklés megakadályozása

A végleges módosító használatával megakadályozhatja, hogy az osztályok öröklődnek.

public final class Attribute
{
    int objectField;
}

Metódus felülírása

Az osztály metódusait minden olyan osztály örökli, amely kiterjeszti az osztályt. Az örökölt metódusok funkciójának módosításához hozzon létre egy metódust az alosztályban, majd adja meg a metódusnak ugyanazt a nevet és paramétereket, mint a szuperosztály metódusa. Ezt a folyamatot a metódus felülírásának nevezzük.

Az alosztály példányosításakor hozzárendelheti a hivatkozást egy szuperosztálytípusú vagy alosztálytípusú változóhoz. A változó típusától függetlenül a felülírt metódus meghívása történik.

Az alábbi kód példában az alosztály felülírja az írási módszert. Két változó jön létre, mindkettő pont típusú. Az egyik pontobjektumhoz , a másikhoz egy ThreePoint-objektumot rendel. Amikor a rendszer meghívja az írási metódust a ThreePoint-objektumon , a metódus ThreePoint-verziójának meghívása történik.

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

Metódus felülbírálásának megakadályozása

Nem bírálhatja felül a statikus metódusokat, mert osztályonként léteznek. Ha meg szeretné védeni más bizalmas módszereket vagy alapvető metódusokat a felülírástól, használja a végső módosítót. Az alábbi példában, mivel a methodAttvéglegesként van deklarálva, az attribútumot kiterjesztő osztályban nem bírálhatja felül. Ne adjon meg új vagy véglegesítési metódusokat véglegesítésként.

Az alábbi példa bemutatja, hogyan használhatja a végső kulcsszót.

public class Attribute
{
    int objectVariable;

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

Felülbírálás és túlterhelés

Felülírás akkor fordul elő, ha egy alosztály módosítja egy metódus szuperosztály-implementációját, de mindkét metódus ugyanazzal az aláírással rendelkezik.

Ezzel szemben a túlterhelés akkor fordul elő, ha egynél több metódus neve azonos, de a metódusok eltérő aláírással rendelkeznek (visszatérési típusok, paraméterlisták vagy mindkettő). Az X++ támogatja a felülbírálást, de nem támogatja a túlterhelést.