Java - Herança
A herança pode ser definida como o processo onde uma classe adquire as propriedades (métodos e campos) de outra. Com o uso da herança, as informações são gerenciadas em uma ordem hierárquica.
A classe que herda as propriedades de outra é conhecida como subclasse (classe derivada, classe filha) e a classe cujas propriedades são herdadas é conhecida como superclasse (classe base, classe pai).
estende a palavra-chave
estende é a palavra-chave usada para herdar as propriedades de uma classe. A seguir está a sintaxe da palavra-chave extends.
Sintaxe
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
Código de amostra
A seguir está um exemplo demonstrando a herança Java. Neste exemplo, você pode observar duas classes, a saber, Calculation e My_Calculation.
Usando a palavra-chave extends, o My_Calculation herda os métodos add() e Subtraction() da classe Calculation.
Copie e cole o seguinte programa em um arquivo com o nome My_Calculation.java
Exemplo
Demonstração ao vivo
class Calculation {
int z;
public void addition(int x, int y) {
z = x + y;
System.out.println("The sum of the given numbers:"+z);
}
public void Subtraction(int x, int y) {
z = x - y;
System.out.println("The difference between the given numbers:"+z);
}
}
public class My_Calculation extends Calculation {
public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]) {
int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b);
}
}
Compile e execute o código acima conforme mostrado abaixo.
javac My_Calculation.java java My_Calculation
Depois de executar o programa, ele produzirá o seguinte resultado -
Saída
The sum of the given numbers:30 The difference between the given numbers:10 The product of the given numbers:200
No programa fornecido, quando um objeto para My_Calculation classe é criada, uma cópia do conteúdo da superclasse é feita dentro dela. É por isso que, usando o objeto da subclasse, você pode acessar os membros de uma superclasse.
A variável de referência Superclass pode conter o objeto da subclasse, mas usando essa variável você pode acessar apenas os membros da superclasse, portanto, para acessar os membros de ambas as classes, é recomendável sempre criar uma variável de referência para a subclasse.
Se você considerar o programa acima, você pode instanciar a classe conforme indicado abaixo. Mas usando a variável de referência da superclasse ( cal neste caso) você não pode chamar o método multiplication() , que pertence à subclasse My_Calculation.
Calculation demo = new My_Calculation(); demo.addition(a, b); demo.Subtraction(a, b);
Observação − Uma subclasse herda todos os membros (campos, métodos e classes aninhadas) de sua superclasse. Construtores não são membros, então eles não são herdados por subclasses, mas o construtor da superclasse pode ser invocado da subclasse.
A super palavra-chave
O super palavra-chave é semelhante a esta palavra-chave. A seguir estão os cenários em que a palavra-chave super é usada.
-
É usado para diferenciar os membros da superclasse dos membros da subclasse, se eles tiverem os mesmos nomes.
-
É usado para invocar a superclasse construtor da subclasse.
Diferenciando os membros
Se uma classe está herdando as propriedades de outra classe. E se os membros da superclasse tiverem os mesmos nomes da subclasse, para diferenciar essas variáveis usamos a palavra-chave super conforme mostrado abaixo.
super.variable super.method();
Código de amostra
Esta seção fornece um programa que demonstra o uso do super palavra-chave.
No programa fornecido, você tem duas classes:Sub_class e Super_class , ambos têm um método chamado display() com implementações diferentes e uma variável chamada num com valores diferentes. Estamos invocando o método display() de ambas as classes e imprimindo o valor da variável num de ambas as classes. Aqui você pode observar que usamos a palavra-chave super para diferenciar os membros da superclasse da subclasse.
Copie e cole o programa em um arquivo com o nome Sub_class.java.
Exemplo
Demonstração ao vivo
class Super_class {
int num = 20;
// display method of superclass
public void display() {
System.out.println("This is the display method of superclass");
}
}
public class Sub_class extends Super_class {
int num = 10;
// display method of sub class
public void display() {
System.out.println("This is the display method of subclass");
}
public void my_method() {
// Instantiating subclass
Sub_class sub = new Sub_class();
// Invoking the display() method of sub class
sub.display();
// Invoking the display() method of superclass
super.display();
// printing the value of variable num of subclass
System.out.println("value of the variable named num in sub class:"+ sub.num);
// printing the value of variable num of superclass
System.out.println("value of the variable named num in super class:"+ super.num);
}
public static void main(String args[]) {
Sub_class obj = new Sub_class();
obj.my_method();
}
}
Compile e execute o código acima usando a seguinte sintaxe.
javac Super_Demo java Super
Ao executar o programa, você obterá o seguinte resultado -
Saída
This is the display method of subclass This is the display method of superclass value of the variable named num in sub class:10 value of the variable named num in super class:20
Invocando o Construtor de Superclasse
Se uma classe está herdando as propriedades de outra classe, a subclasse adquire automaticamente o construtor padrão da superclasse. Mas se você quiser chamar um construtor parametrizado da superclasse, precisará usar a palavra-chave super conforme mostrado abaixo.
super(values);
Código de amostra
O programa fornecido nesta seção demonstra como usar a palavra-chave super para invocar o construtor parametrizado da superclasse. Este programa contém uma superclasse e uma subclasse, onde a superclasse contém um construtor parametrizado que aceita um valor inteiro, e usamos a palavra-chave super para invocar o construtor parametrizado da superclasse.
Copie e cole o seguinte programa em um arquivo com o nome Subclass.java
Exemplo
Demonstração ao vivo
class Superclass {
int age;
Superclass(int age) {
this.age = age;
}
public void getAge() {
System.out.println("The value of the variable named age in super class is: " +age);
}
}
public class Subclass extends Superclass {
Subclass(int age) {
super(age);
}
public static void main(String args[]) {
Subclass s = new Subclass(24);
s.getAge();
}
}
Compile e execute o código acima usando a seguinte sintaxe.
javac Subclass java Subclass
Ao executar o programa, você obterá o seguinte resultado -
Saída
The value of the variable named age in super class is: 24
Relação IS-A
IS-A é uma maneira de dizer:Este objeto é um tipo daquele objeto. Vamos ver como o se estende palavra-chave é usada para obter herança.
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
}
Agora, com base no exemplo acima, em termos de Orientação a Objetos, o seguinte é verdadeiro -
- Animal é a superclasse da classe Mamífero.
- Animal é a superclasse da classe Reptile.
- Mamífero e Réptil são subclasses da classe Animal.
- Cachorro é a subclasse das classes Mamífero e Animal.
Agora, se considerarmos a relação IS-A, podemos dizer −
- Mamífero IS-A Animal
- Réptil é um animal
- Cão é um mamífero
- Portanto:o cão também é um animal
Com o uso da palavra-chave extends, as subclasses poderão herdar todas as propriedades da superclasse, exceto as propriedades privadas da superclasse.
Podemos garantir que Mammal é na verdade um Animal com o uso do operador de instância.
Exemplo
Demonstração ao vivo
class Animal {
}
class Mammal extends Animal {
}
class Reptile extends Animal {
}
public class Dog extends Mammal {
public static void main(String args[]) {
Animal a = new Animal();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
Isso produzirá o seguinte resultado -
Saída
true true true
Como temos uma boa compreensão das extends palavra-chave, vejamos como os implementa palavra-chave é usada para obter o relacionamento IS-A.
Geralmente, os implementa palavra-chave é usada com classes para herdar as propriedades de uma interface. Interfaces nunca podem ser estendidas por uma classe.
Exemplo
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}
A instância da palavra-chave
Vamos usar a instância de operador para verificar determinar se Mammal é realmente um Animal, e cão é realmente um Animal.
Exemplo
Demonstração ao vivo
interface Animal{}
class Mammal implements Animal{}
public class Dog extends Mammal {
public static void main(String args[]) {
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
Isso produzirá o seguinte resultado -
Saída
true true true
Relação TEM-A
Essas relações são baseadas principalmente no uso. Isso determina se uma determinada classe TEM-A determinada coisa. Esse relacionamento ajuda a reduzir a duplicação de código, bem como bugs.
Vejamos um exemplo -
Exemplo
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
Isso mostra que a classe Van HAS-A Speed. Por termos uma classe separada para Speed, não precisamos colocar todo o código que pertence a speed dentro da classe Van, o que possibilita reutilizar a classe Speed em várias aplicações.
No recurso Orientado a Objetos, os usuários não precisam se preocupar com qual objeto está fazendo o trabalho real. Para conseguir isso, a classe Van oculta os detalhes de implementação dos usuários da classe Van. Então, basicamente o que acontece é que os usuários pediriam à classe Van para fazer uma determinada ação e a classe Van faria o trabalho sozinha ou pediria a outra classe para executar a ação.
Tipos de herança
Existem vários tipos de herança, conforme demonstrado abaixo.
Um fato muito importante a ser lembrado é que Java não suporta herança múltipla. Isso significa que uma classe não pode estender mais de uma classe. Portanto, seguir é ilegal -
Exemplo
public class extends Animal, Mammal{}
No entanto, uma classe pode implementar uma ou mais interfaces, o que ajudou o Java a se livrar da impossibilidade de herança múltipla.
Java