Herança X++

Este artigo descreve a herança no 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 herança múltipla. 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 projeto, desenvolvimento e testes. Para personalizar o comportamento de uma superclasse, substitua os métodos em uma subclasse. Uma superclasse é muitas vezes conhecida como uma classe base, e uma subclasse é muitas vezes conhecida como uma classe derivada.

Exemplo de subclasse

O exemplo a seguir primeiro cria uma classe chamada Point. Em seguida, ele 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 estende a classe. Para alterar a funcionalidade de um método herdado, crie um método na subclasse e, em seguida, dê a esse método o mesmo nome e parâmetros que o método na superclasse. Este processo é conhecido como substituição do método.

Ao instanciar a subclasse, você pode atribuir a referência a uma variável do tipo de superclasse ou do 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 write . Duas variáveis, ambas do tipo Point são criadas. Um é atribuído um objeto Point , o outro é atribuído um objeto ThreePoint . Quando o método write é chamado no objeto ThreePoint , a versão 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)".

Prevenção de substituições de método

Os métodos estáticos não podem ser substituídos, porque existem por classe. Para proteger outros métodos sensíveis, 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 Attribute. Você não deve especificar métodos novos ou finalizar 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 vs. 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++ suporta substituição, mas não suporta sobrecarga.