Héritage X++

Remarque

Les groupes d’intérêt communautaire sont désormais passés de Yammer à Microsoft Viva Engage. Pour rejoindre une communauté Viva Engage et participer aux dernières discussions, remplissez le formulaire Demande d’accès à la Finance et Opérations Viva Engage Communauté et choisissez la communauté que vous souhaitez rejoindre.

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

Création d’une sous-classe

Les sous-classes sont des classes qui s’étendent ou héritent d’autres classes. Une classe ne peut étendre qu’une seule 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 lors de la conception, du développement et des 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 nouvelle 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;
    }
}

Empêcher l’héritage de classe

Vous pouvez empêcher l’héritage de classes à l’aide du modificateur final .

public final class Attribute
{
    int objectField;
}

Remplacement d’une méthode

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

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

Dans l’exemple de code suivant, la sous-classe remplace la méthode write . Deux variables, toutes deux de type Point , sont créées. L’un se voit attribuer un objet Point , l’autre un objet ThreePoint . Lorsque la méthode write 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

Vous ne pouvez pas écraser les méthodes statiques car elles existent par classe. Pour protéger d’autres méthodes sensibles ou de base contre le dépassement, utilisez le modificateur final . Dans l’exemple suivant, comme methodAtt est déclaré final, vous ne pouvez pas le surpasser dans une classe qui étend Attribut. Ne spécifiez pas les méthodes nouvelles ou les méthodes finales comme définitives.

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

public class Attribute
{
    int objectVariable;

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

Remplacement ou surcharge

Le sursaut se produit lorsqu’une sous-classe modifie l’implémentation de la superclasse d’une méthode, mais que les deux méthodes ont la même signature.

En revanche, la surcharge se produit lorsque plusieurs méthodes portent 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 le remplacement, mais il ne prend pas en charge la surcharge.

  • Last updated on