Héritage X++

Cet article décrit l’héritage dans X++, notamment comment créer une sous-classe et remplacer une méthode.

Création d’une sous-classe

Les sous-classes sont des classes qui étendent ou héritent d’autres classes. Une classe ne peut étendre qu’une autre classe. L’héritage multiple n’est pas pris en charge. Si vous étendez une classe, la sous-classe hérite de toutes les méthodes et variables de la classe parente (la superclasse). Les sous-classes vous permettent de réutiliser le code existant à des fins plus spécifiques. Par conséquent, ils vous permettent de gagner du temps pendant la conception, le développement et les tests. Pour personnaliser le comportement d’une superclasse, remplacez les méthodes d’une sous-classe. Une superclasse est souvent appelée classe de base, et une sous-classe est souvent appelée classe dérivée.

Exemple de sous-classe

L’exemple suivant crée d’abord une classe nommée Point. Il étend ensuite la classe Point pour créer une classe nommée 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;
    }
}

Prévention de l’héritage des classes

Vous pouvez empêcher les classes d’être héritées à l’aide du modificateur final .

public final class Attribute
{
    int objectField;
}

Substitution d’une méthode

Les méthodes d’une classe sont héritées par n’importe quelle classe qui étend la classe. Pour modifier les fonctionnalités d’une méthode héritée, vous créez une méthode dans la sous-classe, puis donnez à cette méthode le même nom et les mêmes paramètres que la méthode dans la superclasse. Ce processus est appelé substitution de la méthode.

Lorsque vous instanciez la sous-classe, vous pouvez affecter la référence à une variable du type de superclasse ou au type de sous-classe. Quel que soit le type de la variable, la méthode substituée est appelée.

Dans l’exemple de code suivant, la sous-classe remplace la méthode d’écriture . Deux variables, de type Point , sont créées. L’un est affecté à un objet Point , l’autre est affecté à un objet ThreePoint . Lorsque la méthode d’écriture est appelée sur l’objet ThreePoint , la version ThreePoint de la méthode est appelée.

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

Prévention des remplacements de méthode

Les méthodes statiques ne peuvent pas être substituées, car elles existent par classe. Pour protéger d’autres méthodes sensibles, ou méthodes principales, d’être remplacées, utilisez le modificateur final . Dans l’exemple suivant, étant donné que methodAtt est déclaré comme final, il ne peut pas être substitué dans une classe qui étend Attribute. Vous ne devez pas spécifier de nouvelles méthodes ou finaliser comme étant finales.

L’exemple suivant montre comment utiliser le mot clé final .

public class Attribute
{
    int objectVariable;

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

Substitution et surcharge

La substitution se produit lorsque l’implémentation de la superclasse d’une méthode est modifiée par l’implémentation de cette méthode par la sous-classe, mais que les signatures des deux méthodes sont identiques.

En revanche, la surcharge se produit lorsque plusieurs méthodes ont le même nom, mais que les méthodes ont des signatures différentes (types de retour, listes de paramètres ou les deux). X++ prend en charge la substitution, mais elle ne prend pas en charge la surcharge.