Ereditarietà X++

Nota

I gruppi di interesse della community sono ora passati da Yammer a Microsoft Viva Engage. Per entrare a far parte di una community Viva Engage e partecipare alle discussioni più recenti, compila il modulo Richiedi l'accesso alla community Viva Engage per Finance and Operations e scegli la community a cui vuoi unirti.

In questo articolo viene descritta l'ereditarietà in X++, incluso come creare una sottoclasse ed eseguire l'override di un metodo.

Creazione di una sottoclasse

Le sottoclassi sono classi che si 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, ti aiutano a 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.

Esempio di sottoclasse

Nell'esempio seguente viene innanzitutto 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 l'ereditarietà delle classi utilizzando il modificatore finale .

public final class Attribute
{
    int objectField;
}

Override di un metodo

I metodi di una classe vengono ereditati da qualsiasi classe che estende la classe. Per modificare la funzionalità di un metodo ereditato, si crea un metodo nella sottoclasse e quindi si assegnano a tale metodo lo stesso nome e gli stessi 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 di superclasse o del tipo di sottoclasse. Indipendentemente dal tipo di variabile, viene chiamato il metodo sottoposto a override.

Nell'esempio di codice riportato di seguito, la sottoclasse esegue l'override del metodo write . Vengono create due variabili, entrambe di tipo Point . A uno viene assegnato un oggetto Point , all'altro 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 delle sostituzioni dei metodi

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

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

public class Attribute
{
    int objectVariable;

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

Override e sovraccarico

L'override si verifica quando l'implementazione di un metodo da parte della superclasse viene modificata dall'implementazione di tale metodo da parte della sottoclasse, ma le firme di entrambi i metodi sono le stesse.

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.