13.1 Herança e Polimorfismo em Java: Conceito de Herança
A herança é um dos pilares fundamentais da programação orientada a objetos (POO), e o Java, sendo uma linguagem que adota esse paradigma, oferece recursos robustos para sua implementação. Herança é um mecanismo que permite que uma nova classe derive propriedades e comportamentos de uma classe existente. A classe que é herdada é chamada de classe base, superclasse ou classe pai, enquanto a classe que herda é conhecida como classe derivada, subclasse ou classe filha.
Na prática, a herança possibilita a reutilização de código e a criação de uma hierarquia de classes relacionadas. Isso não só economiza tempo e esforço no desenvolvimento de software, mas também ajuda a manter o código organizado, mais fácil de manter e expandir.
Como a Herança Funciona em Java
Em Java, a herança é realizada com a palavra-chave extends. Quando uma classe é definida como a extensão de outra, ela herda todos os campos não privados (atributos) e métodos da classe pai. Isso significa que a classe filha pode usar esses membros como se fossem seus.
Exemplo:
class Vehicle {
protected String brand = "Ford"; // Atributo da classe Vehicle
public void honk() { // Método da classe Vehicle
System.out.println("Tuut, tuut!");
}
}
class Car extends Vehicle {
private String modelName = "Mustang"; // Atributo da classe Car
public static void main(String[] args) {
// Cria um objeto da classe Car
Car myCar = new Car();
// Chama o método da classe Vehicle
myCar.honk();
// Acessa o atributo da classe Vehicle
System.out.println(myCar.brand + " " + myCar.modelName);
}
}
Neste exemplo, Car é uma subclasse de Vehicle. A classe Car herda o método honk e o atributo brand da classe Vehicle, e também define seu próprio atributo, modelName.
Sobrescrita de Métodos
Uma subclasse em Java pode sobrescrever os métodos da superclasse. Isso é feito quando a subclasse precisa de uma implementação específica para um método herdado. A sobrescrita é uma forma de polimorfismo, que será discutido mais adiante.
Exemplo:
class Animal {
public void sound() {
System.out.println("O animal faz um som");
}
}
class Pig extends Animal {
public void sound() {
System.out.println("O porco diz: wee wee");
}
}
class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Cria um objeto da classe Animal
Animal myPig = new Pig(); // Cria um objeto da classe Pig
myAnimal.sound();
myPig.sound();
}
}
Neste exemplo, a classe Pig sobrescreve o método sound da classe Animal. Quando o método é chamado no objeto myPig, a implementação da classe Pig é usada, não a da classe Animal.
Uso do super
A palavra-chave super em Java é usada dentro de métodos de subclasses para fazer referência a membros (métodos ou atributos) da superclasse. Isso é útil especialmente quando estamos sobrescrevendo métodos, mas queremos ainda assim acessar a implementação da superclasse.
Exemplo:
class Animal {
public void sound() {
System.out.println("O animal faz um som");
}
}
class Pig extends Animal {
public void sound() {
super.sound(); // Chama o método da superclasse
System.out.println("O porco diz: wee wee");
}
}
Aqui, a classe Pig chama o método sound da superclasse Animal antes de executar seu próprio código.
O Polimorfismo em Java
O polimorfismo, outro pilar da POO, permite que objetos de diferentes classes sejam tratados como objetos de uma superclasse comum. Isso é particularmente poderoso em combinação com a herança, pois permite que um único método ou classe opere em objetos de diferentes classes.
Polimorfismo em Java é, em sua maioria, realizado através de sobrecarga e sobrescrita de métodos. A sobrecarga ocorre quando dois ou mais métodos na mesma classe têm o mesmo nome, mas parâmetros diferentes. A sobrescrita, como vimos, é quando uma subclasse fornece uma implementação específica para um método que já é fornecido por sua superclasse.
Exemplo de polimorfismo:
class Animal {
public void sound() {
System.out.println("O animal faz um som");
}
}
class Pig extends Animal {
public void sound() {
System.out.println("O porco diz: wee wee");
}
}
class Dog extends Animal {
public void sound() {
System.out.println("O cachorro diz: bow wow");
}
}
class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal();
Animal myPig = new Pig();
Animal myDog = new Dog();
myAnimal.sound();
myPig.sound();
myDog.sound();
}
}
Neste exemplo, a classe Main cria objetos de diferentes tipos, mas todos são tratados como instâncias da classe Animal. Isso demonstra polimorfismo, pois o método sound se comporta de maneira diferente dependendo do tipo de objeto que o invoca.
Conclusão
A herança e o polimorfismo são conceitos chave na programação orientada a objetos e são extensivamente utilizados em Java para criar código reutilizável e sistemas extensíveis. Ao compreender e aplicar esses conceitos, desenvolvedores podem escrever código mais limpo, mais modular e mais fácil de manter.
Espera-se que este curso sobre Java forneça uma compreensão sólida desses conceitos, permitindo que você os aplique em cenários do mundo real e construa aplicações robustas e eficientes.
