Herança X++

Este artigo descreve a herança em X++, incluindo como criar uma subclasse e substituir um método.

Criando uma subclasse

Subclasses são classes que se estendem ou herdam de outras classes. Uma classe pode estender apenas uma outra classe. Não há suporte para várias heranças. Se você estender uma classe, a subclasse herdará todos os métodos e variáveis na classe pai (a superclasse). As subclasses permitem reutilizar o código existente para uma finalidade mais específica. Portanto, eles ajudam a economizar tempo durante o design, o desenvolvimento e o teste. Para personalizar o comportamento de uma superclasse, substitua os métodos em uma subclasse. Uma superclasse é frequentemente conhecida como uma classe base, e uma subclasse é frequentemente conhecida como uma classe derivada.

Exemplo de subclasse

O exemplo a seguir primeiro cria uma classe chamada Point. Em seguida, estende a classe Point para criar uma nova classe chamada 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;
    }
}

Impedindo a herança de classe

Você pode impedir que as classes sejam herdadas usando o modificador final .

public final class Attribute
{
    int objectField;
}

Substituindo um método

Os métodos em uma classe são herdados por qualquer classe que estenda a classe. Para alterar a funcionalidade de um método herdado, crie um método na subclasse e dê a esse método o mesmo nome e parâmetros que o método na superclasse. Esse processo é conhecido como substituição do método.

Ao instanciar a subclasse, você pode atribuir a referência a uma variável do tipo superclasse ou ao tipo de subclasse. Independentemente do tipo da variável, o método substituído é chamado.

No exemplo de código a seguir, a subclasse substitui o método de gravação . Duas variáveis, ambas do tipo Point são criadas. Um é atribuído a um objeto Point , o outro recebe um objeto ThreePoint . Quando o método de gravação é chamado no objeto ThreePoint , a versão do ThreePoint do método é chamada.

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

Impedindo substituições de método

Métodos estáticos não podem ser substituídos, pois existem por classe. Para proteger outros métodos confidenciais, ou métodos principais, de serem substituídos, use o modificador final . No exemplo a seguir, como methodAtt é declarado como final, ele não pode ser substituído em nenhuma classe que estenda o Atributo. Você não deve especificar métodos novos ou finalizados como finais.

O exemplo a seguir mostra como usar a palavra-chave final .

public class Attribute
{
    int objectVariable;

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

Substituição versus sobrecarga

A substituição ocorre quando a implementação de um método pela superclasse é alterada pela implementação desse método pela subclasse, mas as assinaturas de ambos os métodos são as mesmas.

Por outro lado, a sobrecarga ocorre quando mais de um método tem o mesmo nome, mas os métodos têm assinaturas diferentes (tipos de retorno, listas de parâmetros ou ambos). O X++ dá suporte à substituição, mas não dá suporte à sobrecarga.