Super palavra -chave em java

A palavra -chave Super é usada na herança das classes Java. Em Java, a superclasse é a classe pai de uma classe atual. A classe atual é a classe infantil (subclasse) da superclasse. Existe a possibilidade de as aulas do neto e do bisneto descendo para baixo. A classe pai é a superclasse direta da classe atual. A classe avô não é a superclasse direta da classe atual. Este artigo explica o uso da palavra -chave, super em java. Começa com a apresentação de uma classe pai, um filho da classe pai e um neto da classe dos pais. Então mostra como a palavra, super, se encaixa na hierarquia. A hierarquia abaixo forma uma forma da calculadora.

Conteúdo do artigo

• Recall de herança de Java
• Uso da Super Keyword
• Conclusão

Recall de herança de Java

Considere a seguinte classe:

classe CPARENT
int a;
int b;
int add ()
retornar a + b;

Esta classe tem duas propriedades: A e B. Em Java, as propriedades são chamadas de campos. Esta classe possui um método que adiciona dois números, que são os valores do campo. O nome da classe é CPARENT, com o C anterior, para a calculadora. O seguinte segmento de código no método Main (), Saídas 5:

Pai cparent = new cparent ();
pai.a = 2;
pai.b = 3;
int radd = pai.adicionar();
Sistema.fora.println (radd);

Considere a aula a seguir, que é a subclasse da classe acima (CPARENT):

classe cchild estende CPARENT
int c;
int multiply ()
retornar a * c;

Observe o uso da palavra -chave se estende. Esta classe tem o campo, C e o método, multiply (). A classe herda os campos, 'a' e b, e o método, add (). No entanto, se o valor do campo para 'a' ou b for usado para esse objeto instanciado atual (objeto filho), ele ainda precisa ser transferido um valor. Para esta classe, o valor de 'A' herdado é multiplicado pelo valor de campo da classe de C. O nome desta classe é Cchild, com o C anterior, para a calculadora. O segmento de código a seguir no método Main () se adapta a esta classe:

CCHILD CHILD = NEW CCHILL ();
criança.a = 2;
criança.c = 4;
int rmult = criança.multiplicar();
Sistema.fora.println (rmult);

A saída é 8. Observe que, embora o campo 'A' tenha sido herdado, ele ainda precisava ser transferido um valor; Nesse caso, o mesmo valor.

Considere a aula a seguir, que é a subclasse da classe acima, Cchild:

classe CGrandChild estende CCHILD
int d;
int divide ()
retornar a / d;

Observe o uso da palavra -chave se estende. Esta classe tem o campo, D e o método, divide (). A classe herda os membros, 'a', b e add () da classe CCHILD, que os herdou da classe CPARENT. Também herda os membros, C e Multiply () da classe CCHILD. No entanto, se o valor do campo para 'a' ou b ou c, das classes pais ou avós, for usado para esse objeto instanciado atual (objeto neto), ele ainda precisa ser reatribuído um valor. Para esta classe, o valor de 'A' herdado é dividido pelo valor de campo da classe de D. O nome desta classe é CGrandChild, com o C anterior, para a calculadora. O segmento de código a seguir no método Main () se adapta a esta classe:

CGRANDCHILD GCHILD = new CGrandChild ();
gchild.a = 2;
gchild.d = 2;
int rdiv = gchild.dividir();
Sistema.fora.println (rdiv);

A saída é 1. Observe que, embora o campo 'A' tenha sido herdado, ele ainda precisava ser transferido um valor; Nesse caso, o mesmo valor, 2.

Uso da Super Keyword

Campo e super
No programa acima, o valor para o campo, 'a' foi definido três vezes, uma vez para o objeto pai, uma vez para o objeto filho, e uma vez para o objeto neto. Para evitar essa redefinição a cada vez, o valor de 2 pode ser atribuído uma vez, na implementação da classe pai (definição) da seguinte maneira:

classe CPARENT
int a = 2;
int b;
int add ()
retornar a + b;

Isso resolve o problema de redefinir para cada objeto descendente. Nas classes descendentes, o campo 'a' é simplesmente referido (normalmente).

Para acessar o valor de um campo herdado, a super palavra -chave deve ser usada na implementação de interesse da classe descendente, como segue:

super.FieldName

O segmento de código a seguir mostra como o nome 'A' foi acessado, em uma nova implementação do CCHILL:

classe cchild estende CPARENT
int p = super.a;
int c;
int multiply ()
retornar p * c;

A classe, Cchild, agora tem seu próprio nome, P em vez de 'a'. E assim a declaração no método add (),

retornar a * c;

é agora,

retornar p * c;

De maneira semelhante, a implementação da classe, CGrandChild pode ter 'A' substituído por Q, como segue:

classe CGrandChild estende CCHILD
int q = super.a;
int d;
int divide ()
retornar Q / D;

Nota: A herança ocorre em todas as classes descendentes. O método 'a' e o método add () são herdados na classe CCHILD e na aula de CGrandChild.

Método e super
Da mesma forma, um campo herdado pode ser acessado na implementação de uma classe descendente; Um método herdado também pode ser acessado em uma classe de descendente, usando a super -palavra -chave. A sintaxe é:

super.MethodName ()

A implementação da classe CCHILD original pode ser modificada da seguinte forma:

classe cchild estende CPARENT
int c;
int sum = super.adicionar();
int multiply ()
retornar a * c;

Observe que o uso de super. O método ADD () herdado agora é visto como uma "soma" na implementação do CCHILD. O campo C e o método, multiply (), ainda estão lá. Um segmento de código para adição no método Main () que se adapta a esta classe CCHILD modificado é:

CCHILD CHILD = NEW CCHILL ();
int rsum = criança.soma;
Sistema.fora.println (rum);

A saída é 5, assumindo que a classe pai foi modificada com:

int a = 2;
int b = 3;

Construtor e super
O construtor padrão, que não é implementado, é herdado em todas as classes descendentes e não precisa ser contabilizado na implementação dos descendentes e no método principal () (). No entanto, uma vez que uma classe pai tem um construtor personalizado, o restante de seus descendentes precisa ter um construtor semelhante. Considere a classe pai, com um construtor personalizado, como segue:

classe CPARENT
int a, b;
public cparent (int x, int y)
a = x; b = y;

int add ()
retornar a + b;

Os campos de 'A' e B são declarados sem atribuição. O construtor faz a tarefa. A classe infantil precisa ter o mesmo ou um construtor semelhante. A classe infantil correspondente para a hierarquia da calculadora original pode ser:

classe cchild estende CPARENT
Cchild (int x, int y)
super (x, y);

int c;
int multiply ()
retornar a * c;

O construtor aqui é o mesmo que o dos pais. O corpo do construtor aqui só tem:

super (x, y);

que apenas chama o construtor do pai, com os argumentos recebidos. "Super" aqui representa o construtor da classe pai. Este é outro uso de super. Não há modificação neste construtor infantil. A classe neto correspondente para a hierarquia da calculadora original pode ser:

classe CGrandChild estende CCHILD
int d;
Cgrandchild (int x, int y, int z)
super (x, y);
d = z;

int divide ()
retornar a / d;

O construtor aqui é modificado. Tem os mesmos parâmetros x e y e um parâmetro extra, z. Z é atribuir o valor a D, o divisor. O corpo do construtor começa chamando o construtor da classe pai. Então o campo para o divisor é atribuído. O segmento de código a seguir no método Main () se adapta a esta classe:

CGRANDCHILD GCHILD = novo CGRANDCHILD (2, 3, 2);
int rdiv = gchild.dividir();
Sistema.fora.println (rdiv);

A saída para isso é 1.

Conclusão

Super procurará algo na classe de pai imediato. Se não o vir lá, ele procurará na aula dos avós. Se não o vir lá, procurará na classe bisneto; e assim por diante, até que veja ou não o veja. "Super" é geralmente usado na implementação de uma subclasse. É usado para campo, método e construtor. A superclasse direta é a classe pai. A classe avô é uma superclasse, mas não a superclasse direta. Em seguida, o leitor deve entender o uso de "super" com as aulas aninhadas - veja mais tarde.