Dziedziczenie X++

W tym artykule opisano dziedziczenie w języku X++, w tym sposób tworzenia podklasy i zastępowania metody.

Tworzenie podklasy

Podklasy to klasy, które rozszerzają lub dziedziczą z innych klas. Klasa może rozszerzać tylko jedną inną klasę. Wiele dziedziczenia nie jest obsługiwane. Jeśli rozszerzysz klasę, podklasa dziedziczy wszystkie metody i zmienne w klasie nadrzędnej ( superklasa). Podklasy umożliwiają ponowne użycie istniejącego kodu w celu bardziej szczegółowego celu. W związku z tym pomagają zaoszczędzić czas podczas projektowania, programowania i testowania. Aby dostosować zachowanie superklasy, zastąpij metody w podklasie. Superklasa jest często nazywana klasą bazową, a podklasa jest często nazywana klasą pochodną.

Przykład podklasy

Poniższy przykład najpierw tworzy klasę o nazwie Point. Następnie rozszerza klasę Point , aby utworzyć nową klasę o nazwie 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;
    }
}

Zapobieganie dziedziczeniu klas

Można zapobiec dziedziczeniu klas przy użyciu modyfikatora końcowego .

public final class Attribute
{
    int objectField;
}

Zastępowanie metody

Metody w klasie są dziedziczone przez dowolną klasę, która rozszerza klasę. Aby zmienić funkcjonalność dziedziczonej metody, należy utworzyć metodę w podklasie, a następnie nadać tej samej nazwie i parametrom metodę w superklasie. Ten proces jest znany jako zastępowanie metody .

Podczas tworzenia wystąpienia podklasy można przypisać odwołanie do zmiennej typu superklasy lub typu podklasy. Niezależnie od typu zmiennej wywoływana jest metoda przesłonięta.

W poniższym przykładzie kodu podklasa zastępuje metodę write . Dwie zmienne, oba typy Punkt są tworzone. Jeden z nich jest przypisany obiekt Point , drugi jest przypisany obiekt ThreePoint . Gdy metoda zapisu jest wywoływana w obiekcie ThreePoint , wywoływana jest wersja ThreePoint metody .

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

Zapobieganie przesłonięć metodom

Nie można zastąpić metod statycznych, ponieważ istnieją one na klasę. Aby chronić inne metody poufne lub metody podstawowe, przed zastąpieniem należy użyć modyfikatora końcowego . W poniższym przykładzie, ponieważ metodaAtt jest zadeklarowana jako ostateczna, nie można jej zastąpić w żadnej klasie, która rozszerza atrybut. Nie należy określać nowych lub finalizowania metod jako końcowych.

W poniższym przykładzie pokazano, jak używać końcowego słowa kluczowego.

public class Attribute
{
    int objectVariable;

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

Zastępowanie a przeciążenie

Zastępowanie występuje, gdy implementacja metody przez superklasę jest zmieniana przez implementację tej metody podklasy, ale podpisy obu metod są takie same.

Natomiast przeciążenie występuje, gdy więcej niż jedna metoda ma taką samą nazwę, ale metody mają różne sygnatury (zwracane typy, listy parametrów lub oba te metody). Język X++ obsługuje zastępowanie, ale nie obsługuje przeciążenia.