Sobrecarga e Sobreposição
Sobrecarga (Overload)
Sobrecarga de métodos é a capacidade de definir vários métodos com o mesmo nome em uma mesma classe, mas com diferentes parâmetros. Isso permite que a mesma operação seja realizada com diferentes tipos de dados, sem a necessidade de criar vários métodos com nomes diferentes.
Para sobrecarregar um método, é necessário que a assinatura do método seja diferente. A assinatura do método inclui o nome do método e a lista de parâmetros, incluindo o tipo de cada um e sua ordem.
Exemplo de sobrecarga de métodos:
public class Matematica {
public int somar(int x, int y) {
return x + y;
}
public float somar(float x, float y) {
return x + y;
}
public int somar(int x, int y, int z) {
return x + y + z;
}
}Nesse exemplo, a classe Matematica possui três métodos com o mesmo nome somar, mas com diferentes parâmetros. O primeiro método soma dois inteiros, o segundo soma dois floats e o terceiro soma três inteiros.
A seleção do método adequado é feita pelo compilador em tempo de compilação, com base no número e tipo de parâmetros fornecidos. Quando um método é chamado com um conjunto de parâmetros que corresponde à sua assinatura, esse método será executado.
A sobrecarga de métodos é útil para simplificar o código e torná-lo mais legível, além de permitir que uma classe possa oferecer diferentes versões de uma mesma operação para tipos de dados diferentes.
É importante lembrar que métodos sobrecarregados não podem ter apenas tipos de retorno diferentes, pois o compilador não pode distingui-los apenas pelo tipo de retorno.
Sobreposição (Override)
A sobreposição de métodos é uma técnica usada para modificar o comportamento de um método em uma classe filha que foi herdado da classe pai. Essa técnica está intimamente relacionada com o polimorfismo, que é a capacidade de objetos de classes diferentes responderem ao mesmo método de maneiras diferentes.
Quando uma classe filha sobrepõe um método da classe pai, ela redefine a implementação desse método para fornecer um comportamento específico à classe filha. Isso permite que a classe filha substitua o comportamento padrão da classe pai e forneça sua própria implementação para o método. Quando um objeto da classe filha é criado, ele responderá ao método sobrescrito de acordo com a implementação da classe filha, em vez da implementação da classe pai.
Para sobrepor um método, é necessário definir um método com a mesma assinatura na classe filha. A assinatura do método inclui o nome do método, o tipo e a ordem dos parâmetros e o tipo de retorno. O modificador de acesso (public, private, protected) pode ser alterado, mas a visibilidade do método na classe filha não pode ser menor do que a visibilidade na classe pai, ou seja, se o método da classe pai for protected, o método da classe filha pode ser alterado para public, mas não pode ser alterado para private.
Veja um exemplo de sobreposição de método:
public class Animal {
public void emitirSom() {
System.out.println("O animal emitiu um som.");
}
}
public class Cachorro extends Animal {
@Override
public void emitirSom() {
System.out.println("O cachorro latiu.");
}
}
public class Gato extends Animal {
@Override
public void emitirSom() {
System.out.println("O gato miou.");
}
}
public class Main {
public static void main(String[] args) {
Animal animal1 = new Cachorro();
Animal animal2 = new Gato();
animal1.emitirSom(); // imprime "O cachorro latiu."
animal2.emitirSom(); // imprime "O gato miou."
}
}Neste exemplo, a classe Animal define um método emitirSom() que é sobrescrito na classe Cachorro e na classe Gato. Quando o método emitirSom() é chamado em um objeto da classe Cachorro, ele executa a implementação da classe Cachorro, e quando é chamado em um objeto da classe Gato, ele executa a implementação da classe Gato. Isso é possível porque a chamada do método é resolvida em tempo de execução, com base no tipo real do objeto em questão, que é determinado durante a execução do programa.
Referências
Last updated