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

Não podes sobrepor métodos estáticos porque existem por classe. Para proteger outros métodos sensíveis ou métodos centrais de serem sobrepostos, use o modificador final . No exemplo seguinte, como o methodAtt é declarado como final, não pode sobrepê-lo em nenhuma classe que estenda o Attribute. Não especifiquem métodos novos nem finalizem 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 sobreposição ocorre quando uma subclasse altera a implementação da superclasse de um método, mas ambos os métodos têm a mesma assinatura.

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.