X++ inheritance

Questo articolo descrive l'ereditarietà in X++, tra cui come creare una sottoclasse ed eseguire l'override di un metodo.

Creazione di una sottoclasse

Le sottoclassi sono classi che estendono o ereditano da altre classi. Una classe può estendere solo un'altra classe. L'ereditarietà multipla non è supportata. Se si estende una classe, la sottoclasse eredita tutti i metodi e le variabili nella classe padre (la superclasse). Le sottoclassi consentono di riutilizzare il codice esistente per uno scopo più specifico. Pertanto, consentono di risparmiare tempo durante la progettazione, lo sviluppo e il test. Per personalizzare il comportamento di una superclasse, eseguire l'override dei metodi in una sottoclasse. Una superclasse è spesso nota come classe base e una sottoclasse è spesso nota come classe derivata.

Subclass example

Nell'esempio seguente viene prima creata una classe denominata Point. Estende quindi la classe Point per creare una nuova classe denominata 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;
    }
}

Prevenzione dell'ereditarietà delle classi

È possibile impedire che le classi vengano ereditate usando il modificatore finale .

public final class Attribute
{
    int objectField;
}

Override di un metodo

I metodi in una classe vengono ereditati da qualsiasi classe che estende la classe . Per modificare la funzionalità di un metodo ereditato, creare un metodo nella sottoclasse e quindi assegnare a tale metodo lo stesso nome e parametri del metodo nella superclasse. Questo processo è noto come override del metodo .

Quando si crea un'istanza della sottoclasse, è possibile assegnare il riferimento a una variabile del tipo superclasse o al tipo di sottoclasse. Indipendentemente dal tipo della variabile, viene chiamato il metodo sottoposto a override.

Nell'esempio di codice seguente la sottoclasse esegue l'override del metodo di scrittura . Vengono create due variabili, entrambe di tipo Point . A un oggetto Point viene assegnato un oggetto Point , all'altro viene assegnato un oggetto ThreePoint . Quando il metodo di scrittura viene chiamato sull'oggetto ThreePoint , viene chiamata la versione ThreePoint del metodo .

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

Prevenzione degli override dei metodi

Non è possibile eseguire l'override dei metodi statici perché esistono per ogni classe. Per proteggere altri metodi sensibili o metodi principali dall'override, usare il modificatore finale . Nell'esempio seguente, poiché methodAtt è dichiarato come finale, non è possibile eseguirne l'override in alcuna classe che estende Attribute. Non specificare nuovi metodi o finalizzare i metodi come finali.

Nell'esempio seguente viene illustrato come usare la parola chiave finale .

public class Attribute
{
    int objectVariable;

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

Override e overload

L'override si verifica quando una sottoclasse modifica l'implementazione della superclasse di un metodo, ma entrambi i metodi hanno la stessa firma.

Al contrario, l'overload si verifica quando più metodi hanno lo stesso nome, ma i metodi hanno firme diverse (tipi restituiti, elenchi di parametri o entrambi). X++ supporta l'override, ma non supporta l'overload.