Introdução
Neste laboratório, você aprenderá sobre sobrecarga de métodos (method overloading) e sobrescrita de métodos (method overriding). Sobrescrita e sobrecarga são dois conceitos utilizados na linguagem de programação Java. Ambos os conceitos permitem que o programador forneça implementações diferentes para métodos sob o mesmo nome. A sobrecarga ocorre em tempo de compilação, enquanto a sobrescrita ocorre em tempo de execução. Métodos estáticos podem ser sobrecarregados, mas não podem ser sobrescritos. Sobrecarga é uma ligação estática, enquanto sobrescrita é uma ligação dinâmica.
Sobrecarga (Overloading)
Na parte anterior, já utilizamos sobrecarga na classe Person, pois ela tinha três construtores. Esse é um exemplo simples. Sobrecarga é um recurso que permite que uma classe tenha mais de um método com o mesmo nome. Por meio disso, podemos lidar com diferentes situações e não ficaremos confusos. Tipicamente, existem três maneiras de alcançar a sobrecarga:
- Número diferente de parâmetros
- Tipos diferentes de parâmetros
- Ordem diferente de tipos diferentes de parâmetros
Exemplo:
Escreva o seguinte código no arquivo /home/labex/project/overloadingTest.java:
public class overloadingTest{
public static void main(String[] args){
overloadingTest test = new overloadingTest();
System.out.println("add(10,20)= " + test.add(10,20));
System.out.println("add(10,20,30)= " + test.add(10,20,30));
System.out.println("add(5.5, 10.5)= " + test.add(5.5f, 10.5f));
test.printInfo(1 , "an error!");
test.printInfo("another error!" , 2);
}
// this method has two int params, returns an integer
int add(int a, int b){
return a+b;
}
// this method has three int params, returns an integer
int add(int a, int b, int c){
return a+b+c;
}
// this method has two float params, returns a float number
float add(float a, float b){
return a+b;
}
// this method has one string param and one int param, returns nothing
void printInfo(String str, int code){
System.out.println("Code: " + code + "\nMessage: " + str);
}
// this method has one int param and one string param, returns nothing
void printInfo(int code, String str){
System.out.println("Code: " + code + "\nMessage: " + str);
}
}
Saída:
Execute o arquivo overloadingTest.java usando os seguintes comandos:
javac /home/labex/project/overloadingTest.java
java overloadingTest
Veja a saída:
add(10,20)= 30
add(10,20,30)= 60
add(5.5, 10.5)= 16.0
Code: 1
Message: an error!
Code: 2
Message: another error!
Sobrescrita (Overriding)
Se uma classe herda um método de sua superclasse, então há a possibilidade de sobrescrever o método, desde que ele não seja marcado como final ou private. Ao sobrescrever, podemos definir um comportamento que é específico para a subclasse, o que significa que uma subclasse pode implementar um método da classe pai com base em sua necessidade. Em POO (Programação Orientada a Objetos), sobrescrita significa substituir a funcionalidade de um método existente. O tipo de retorno deve ser o mesmo ou um subtipo do tipo de retorno declarado no método original (sobrescrito) na superclasse. O nível de acesso não pode ser mais restritivo do que o nível de acesso do método sobrescrito. Por exemplo: Se um método da superclasse for declarado public, então o método de sobrescrita na subclasse não pode ser nem private nem protected. Também usamos o caso de Animal (uma versão simples).
Exemplo:
Escreva o seguinte código no arquivo /home/labex/project/overridingTest.java:
class Animal{
public void grow(){
System.out.println("I'm animal, I grow up.");
}
public void sleep(){
System.out.println("I'm animal, I am sleeping.");
}
}
class Dog extends Animal{
// overriding method
public void grow(){
System.out.println("I'm dog, I grow up.");
}
}
class Bird extends Animal{
// keep superclass grow(), add own statements
// overriding method
public void grow(){
super.grow();
System.out.println("I'm bird, I grow up.");
}
// overriding method
public void sleep(){
System.out.println("I'm bird, I am sleeping...");
}
// Bird own method
public void sing(){
System.out.println("I'm bird, I am singing a song...");
}
}
public class overridingTest{
public static void main(String[] args){
Dog dog = new Dog();
dog.grow();
Bird bird = new Bird();
bird.grow();
}
}
Saída:
Execute o arquivo overridingTest.java usando os seguintes comandos:
javac /home/labex/project/overridingTest.java
java overridingTest
Veja a saída:
I'm dog, I grow up.
I'm animal, I grow up.
I'm bird, I grow up.
Resumo
Para organizar um projeto grande, é necessário um bom planejamento da arquitetura, portanto, você deve conhecer os conceitos essenciais abordados neste laboratório. Sobrescrita (Overriding) e sobrecarga (Overloading) nos fornecem mais flexibilidade para fazer uso de métodos.
