Por que não há Herança Múltipla de Classes
Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 26 de 87.
Java impede deliberadamente que uma classe estenda mais de uma classe. Essa restrição existe por causa de um problema conhecido como Problema do Diamante.
Imagine se Java permitisse herança múltipla. Considere este cenário hipotético:
// Este código NÃO é válido em Java
public class A {
public void greet() {
System.out.println("Hello from A");
}
}
public class B extends A {
@Override
public void greet() {
System.out.println("Hello from B");
}
}
public class C extends A {
@Override
public void greet() {
System.out.println("Hello from C");
}
}
// NÃO é permitido em Java!
public class D extends B, C { }Se você chamasse greet() em um objeto D, qual versão deveria ser executada? A de B ou a de C? Essa ambiguidade é o Problema do Diamante, chamado assim por causa do formato de diamante formado pelo diagrama de herança.
A solução do Java é simples: permitir apenas herança única de classes. No entanto, o Java oferece uma alternativa. Uma classe pode implementar várias interfaces, sobre as quais você aprenderá em um próximo capítulo.
As interfaces resolvem o problema do diamante de outra forma e oferecem flexibilidade sem ambiguidade.
// Isso É válido em Java
public class Dog extends Animal implements Runnable, Comparable<Dog> {
// Pode implementar várias interfaces
}Essa escolha de design mantém o modelo de herança do Java simples e previsível, enquanto ainda permite a reutilização poderosa de código por meio de interfaces.
Desafio
FácilVamos criar um sistema de reprodução de música que demonstra a regra de herança simples do Java e mostra como você ainda pode criar designs flexíveis dentro dessa restrição.
Imagine que você quer criar um alto-falante inteligente que combina recursos de um reprodutor de música e de um assistente de voz. Como Java não permite estender várias classes, você precisará projetar sua hierarquia com cuidado usando herança simples.
Você criará quatro arquivos para organizar seu código:
AudioDevice.java: Crie a classe base compartilhada por todos os dispositivos de reprodução de áudio. Ela deve ter:- Um campo privado para
deviceName(String) - Um construtor que aceita o nome do dispositivo
- Um método
getDeviceName()que retorna o nome - Um método
playSound()que imprime:[deviceName]: Playing audio
- Um campo privado para
MusicPlayer.java: Crie uma classe que estende AudioDevice e adiciona recursos específicos de música:- Um campo privado para
currentSong(String) - Um construtor que recebe o nome do dispositivo e usa
super(deviceName) - Um método
setSong(String song)que define a música atual - Sobrescreva
playSound()para imprimir:[deviceName]: Now playing - [currentSong]
- Um campo privado para
SmartSpeaker.java: Crie uma classe que estende MusicPlayer (não MusicPlayer e alguma classe VoiceAssistant ao mesmo tempo — isso seria herança múltipla!). O alto-falante inteligente se baseia no reprodutor de música, adicionando recursos de voz:- Um campo privado para
assistantName(String) - Um construtor que recebe o nome do dispositivo e o nome do assistente, usando
super(deviceName) - Um método
voiceCommand(String command)que imprime:[assistantName]: Processing "[command]" - Um método
getFullInfo()que imprime:[deviceName] with [assistantName] assistant
- Um campo privado para
Main.java: Demonstre sua cadeia de herança multinível. Você receberá três entradas: o nome de um dispositivo (String), o nome de um assistente (String) e o nome de uma música (String). Crie um SmartSpeaker, defina uma música e, em seguida, chame estes métodos nesta ordem:getFullInfo()playSound()voiceCommand("skip to next")
Você receberá três entradas: o nome do dispositivo, o nome do assistente e o nome da música.
Observe como SmartSpeaker adquire recursos de música ao estender MusicPlayer em uma cadeia (AudioDevice -> MusicPlayer -> SmartSpeaker), em vez de tentar estender várias classes não relacionadas. Essa é a abordagem do Java para manter a herança clara e sem ambiguidades!
Experimente você mesmo
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Leia as entradas
String deviceName = scanner.nextLine();
String assistantName = scanner.nextLine();
String songName = scanner.nextLine();
// TODO: Crie um SmartSpeaker com deviceName e assistantName
// TODO: Defina a música usando setSong()
// TODO: Chame getFullInfo()
// TODO: Chame playSound()
// TODO: Chame voiceCommand("skip to next")
}
}
Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.
Todas as lições de Programação Orientada a Objetos
1Fundamentos de POO
Arquivos ExternosIntrodução à POOClasses vs ObjetosA Palavra-chave thisMétodosCampos (Atributos)Método ConstrutorSobrecarga de ConstrutorRecapitulação - Calculadora Simples4Herança
Herança Básica (extends)A Palavra-chave superSobrescrita de Método (@Override)Encadeamento de ConstrutoresA Classe ObjectHerança Simples e MultinívelPor que não há Herança Múltipla de ClassesRecapitulação - Hierarquia de Funcionários7Métodos Especiais e a Classe Object
Método toString()equals() e hashCode()Método clone()compareTo() e ComparableInterface ComparatorRecapitulação - Ordenação Personalizada2Modificadores de Acesso e Encapsulamento
Visão Geral dos Níveis de AcessoMétodos Getter e SetterOcultação de InformaçõesA Palavra-chave finalRecapitulação - Gerenciador de Conta Bancária5Polimorfismo
Fundamentos de Sobrecarga de MétodosSobrescrita de Métodos (Tempo de Execução)Upcasting e DowncastingO Operador instanceofClasses e Métodos AbstratosRecapitulação - Calculadora de Formas8Conceitos Avançados de OOP
Composição vs HerançaAgregação vs ComposiçãoClasses Internas, Aninhadas e AnônimasEnums e Métodos de EnumRecords (Java 16+)Classes Seladas (Java 17+)11Padrões de Projeto Parte 1
Introdução aos Padrões de ProjetoPadrão SingletonPadrão FactoryPadrão BuilderPadrão ObserverPadrão Strategy3Propriedades de Classe e Membros Estáticos
Variáveis de Instância vs EstáticasMétodos EstáticosBlocos EstáticosConstantes (static final)Recapitulação - Contador e Utilitário6Interfaces e Classes Abstratas
Introdução às InterfacesImplementando InterfacesImplementação de Múltiplas InterfacesDefault e Static em InterfacesClasses Abstratas vs InterfacesInterfaces FuncionaisRecapitulação - Sistema de Pagamento9Generics
Introdução a GenericsClasses GenéricasMétodos GenéricosParâmetros de Tipos DelimitadosWildcards (?, extends, super)Recapitulação - Container Genérico12Padrões de Projeto Parte 2
Padrão CommandPadrão AdapterPadrão DecoratorPadrão Template MethodPadrão StatePadrão CompositePadrão IteratorPratique por conta própria: Compilador de Java online