Understanding Inheritance in X++ for Developers

Understanding Inheritance in X++

This guide explores the concept of inheritance in X++, focusing on how to create derived classes and override existing methods.

What is a Subclass?

In X++, a subclass is a new class that inherits the features—such as variables and methods—of another class, known as the superclass or base class. A class in X++ can only extend one other class, as multiple inheritance is not supported.

Using subclasses allows developers to reuse existing functionality while tailoring the behavior for more specific scenarios. This approach simplifies development and saves time during implementation and testing. If needed, the subclass can override methods from the base class to modify their behavior.

Subclass Example in X++

Here’s a simple demonstration. The first class is called Point, and it stores X and Y coordinates. A second class, ThreePoint, extends Point and adds a Z coordinate.

				
					class Point
{
    real x;
    real y;

    void new(real _x, real _y)
    {
        x = _x;
        y = _y;
    }
}

class ThreePoint extends Point
{
    real z;

    void new(real _x, real _y, real _z)
    {
        super(_x, _y);
        z = _z;
    }
}

Restricting Class Inheritance

To stop a class from being inherited, use the final keyword when defining the class:

				
					public final class Attribute
{
    int objectField;
}

This makes Attribute non-inheritable, ensuring its structure and behavior stay protected.

Method Overriding

When a class inherits from another, it also inherits its methods. To change how an inherited method behaves, define a method with the same name and parameters in the subclass. This process is known as overriding.

The version of the method that gets executed depends on the actual type of the object, not the variable type.

Example:

				
					class Point
{
    real x;
    real y;

    void new(real _x, real _y)
    {
        x = _x;
        y = _y;
    }

    void write()
    {
        info("(" + any2Str(x) + ", " + any2Str(y) + ")");
    }
}

class ThreePoint extends Point
{
    real z;

    void new(real _x, real _y, real _z)
    {
        super(_x, _y);
        z = _z;
    }

    void write()
    {
        info("(" + any2Str(x) + ", " + any2Str(y) + ", " + any2Str(z) + ")");
    }
}

// Usage
Point point2 = new Point(1.0, 2.0);
Point point3 = new ThreePoint(3.0, 4.0, 5.0);

point2.write(); // Output: (1.0, 2.0)
point3.write(); // Output: (3.0, 4.0, 5.0)

Preventing Method Overriding

Static methods are bound to a class and cannot be overridden. If you want to prevent other methods from being overridden, declare them with the final keyword.

However, avoid making the new or finalize methods final, as that may restrict essential object behavior.

Example:

				
					public class Attribute
{
    int objectVariable;

    final void methodAtt()
    {
        // Some logic here
    }
}

Overriding vs. Overloading in X++

Overriding happens when a subclass changes the implementation of a method inherited from a superclass, using the same method name and signature.
Overloading means having multiple methods with the same name but different parameters or return types.

X++ supports method overriding, but does not support method overloading.

Let me know if you’d like this turned into a web-optimized blog post or need a graphic or summary included!

Inheritance in X++