Herencia de X++

En este artículo se describe la herencia en X++, incluido cómo crear una subclase e invalidar un método.

Creación de una subclase

Las subclases son clases que extienden o heredan de otras clases. Una clase solo puede extender una otra clase. No se admite la herencia múltiple. Si extiende una clase, la subclase hereda todos los métodos y variables de la clase primaria (la superclase). Las subclases permiten reutilizar el código existente para un propósito más específico. Por lo tanto, ayudan a ahorrar tiempo durante el diseño, el desarrollo y las pruebas. Para personalizar el comportamiento de una superclase, invalide los métodos de una subclase. A menudo, una superclase se conoce como una clase base y una subclase se conoce a menudo como una clase derivada.

Ejemplo de subclase

En el ejemplo siguiente se crea primero una clase denominada Point. A continuación, extiende la clase Point para crear una nueva clase denominada 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;
    }
}

Impedir la herencia de clases

Puede impedir que las clases se hereden mediante el modificador final .

public final class Attribute
{
    int objectField;
}

Invalidación de un método

Cualquier clase que extienda la clase hereda los métodos de una clase. Para cambiar la funcionalidad de un método heredado, cree un método en la subclase y, a continuación, asigne a ese método el mismo nombre y parámetros que el método en la superclase. Este proceso se conoce como invalidar el método .

Al crear una instancia de la subclase, puede asignar la referencia a una variable del tipo de superclase o al tipo de subclase. Independientemente del tipo de la variable, se llama al método invalidado.

En el ejemplo de código siguiente, la subclase invalida el método de escritura . Se crean dos variables de tipo Point . A uno se le asigna un objeto Point , al otro se le asigna un objeto ThreePoint . Cuando se llama al método de escritura en el objeto ThreePoint , se llama a la versión ThreePoint del método .

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

Prevención de invalidaciones de método

Los métodos estáticos no se pueden invalidar porque existen por clase. Para proteger otros métodos confidenciales, o métodos principales, de reemplazarse, use el modificador final . En el ejemplo siguiente, dado que methodAtt se declara como final, no se puede invalidar en ninguna clase que extienda Attribute. No debe especificar métodos nuevos ni finalizados como finales.

En el ejemplo siguiente se muestra cómo usar la palabra clave final .

public class Attribute
{
    int objectVariable;

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

Invalidación frente a sobrecargas

La invalidación se produce cuando la implementación de la superclase de un método cambia mediante la implementación de la subclase de ese método, pero las firmas de ambos métodos son las mismas.

Por el contrario, la sobrecarga se produce cuando más de un método tiene el mismo nombre, pero los métodos tienen firmas diferentes (tipos de valor devuelto, listas de parámetros o ambos). X++ admite la invalidación, pero no admite sobrecargas.