Menu
CoddyTech

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.

challenge icon

Desafio

Fácil

Vamos 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
  • 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]
  • 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
  • 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")
    }
}
quiz iconTeste seus conhecimentos

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

Pratique por conta própria: Compilador de Java online