Wiki**3

Este exemplo ilustra o uso de herança e packaging para modelar um evento no qual ocorrem duas refeições, um almoço e um jantar, cada um tendo sopa e o jantar, adicionalmente, um bolo.

Classe "RefeiçãoComSopa"

A classe RefeiçãoComSopa representa o conceito geral de uma refeição com sopa. Assim, não há qualquer designação prévia, devendo esta ser passada como argumento no construtor. É com base nesta classe que serão definidas as classes Almoço e Jantar.

  package refeições;
  public abstract class RefeiçãoComSopa {
    private Sopa   _sopa;
    private String _designação;
  
    public RefeiçãoComSopa(String designação, Sopa sopa) {
      _sopa       = sopa;
      _designação = designação;
      System.out.println("-- refeição com " + _sopa + " criada!");
    }
  
    public String toString() { return "refeição (" + _designação + ") com " + _sopa; }
  
    public void aquecerSopa(double temperatura) { _sopa.aquecer(temperatura); }
  
    public void degustar() {
      _sopa.comer();
      System.out.println("** " + this + "... hmmm!");
    }
  }

Classe "Almoço"

  package refeições;
  public class Almoço extends RefeiçãoComSopa {
    public Almoço(String sopa) {
      super("almoço", new Sopa(sopa));
      System.out.println("## " + this + " criada!");
    }
  }

Classe "Jantar"

  package refeições;
  import sobremesas.*;
  
  public class Jantar extends RefeiçãoComSopa {
    private Bolo _bolo;
  
    public Jantar(String sopa, String bolo) {
      super("jantar", new Sopa(sopa));
      _bolo = new Bolo(bolo);
      System.out.println("++ " + this + " criada!");
    }
  
    public String toString() { return super.toString() + " e um " + _bolo; }
  
    public void preparar() {
      aquecerSopa(50);
      System.out.println("++ a sopa foi aquecida...");
    }
  
    public void degustar() {
      preparar();
      super.degustar();
      _bolo.comer();
      System.out.println("++ " + this + "... hmmm!");
    }
  
  }

Classe "Sopa"

  package refeições;
  class Sopa {
    private double _temperatura = 0;
    private String _descrição;
  
    Sopa(String descrição) {
      _descrição = descrição;
      System.out.println("-- " + this + " criada!");
    }
    public String toString() {
      return "sopa de " + _descrição + " a " + (_temperatura + 273.15) + "K";
    }
  
    double getTemperatura() { return _temperatura; }
    void actualizarTemperatura(double temperatura) {
      if (temperatura < -273.15) return;
      _temperatura = temperatura;
    }
  
    void aquecer(double temperatura) {
      if (temperatura > _temperatura) setTemperatura(temperatura);
    }
    void arrefecer(double temperatura) {
      if (temperatura < _temperatura) setTemperatura(temperatura);
    }
  
    String getDescrição() { return _descrição; }
    void comer() { System.out.println("-- " + this + "... hmmm!"); }
  
  }

Classe "Bolo"

  package sobremesas;
  
  public class Bolo {
  
    private String _descrição;
  
    public Bolo(String descrição) {
      _descrição = descrição;
      System.out.println("** " + this + " criado!");
    }
  
    public String toString() {
      return "bolo de " + _descrição;
    }
  
    public void comer() {
      System.out.println("** " + this + "... hmmm!");
    }
  
  }

Classe "Evento" e Função Principal

  import refeições.*;
  
  public class Evento {
    Almoço _almoço;
    Jantar _jantar;
  
    Evento(String almoço, String jantar, String sobremesa) {
      _almoço = new Almoço(almoço);
      _jantar = new Jantar(jantar, sobremesa);
    }
  
    void decorrer() {
      _almoço.degustar();
      System.out.println("== parte da tarde");
      _jantar.degustar();
      System.out.println("== já está!");
    }
  
    public static void main(String[] args) {
      System.out.println("========== EVENTO ==========");
      Evento e = new Evento("batata", "cebola", "bolota");
      System.out.println("============================");
      e.decorrer();
      System.out.println("============================");
    }
  
  }

Saída da Função Principal

O quadro seguinte ilustra a execução da função main da classe Evento.

O primeiro bloco representa a iniciação de todos os objectos: Evento, Almoço (com Sopa), Jantar (com Sopa e Bolo). O segundo bloco é a saída correspondente ao decurso do evento (método decorrer).

 $ java Evento
 
 ========== EVENTO ==========
 -- sopa de batata a 273.15K criada!
 -- refeição com sopa de batata a 273.15K criada!
 ## refeição (almoço) com sopa de batata a 273.15K criada!
 -- sopa de cebola a 273.15K criada!
 -- refeição com sopa de cebola a 273.15K criada!
 ** bolo de bolota criado!
 ++ refeição (jantar) com sopa de cebola a 273.15K e um bolo de bolota criada!
 ============================
 -- sopa de batata a 273.15K... hmmm!
 ** refeição (almoço) com sopa de batata a 273.15K... hmmm!
 == parte da tarde
 ++ a sopa foi aquecida...
 -- sopa de cebola a 323.15K... hmmm!
 ** refeição (jantar) com sopa de cebola a 323.15K e um bolo de bolota... hmmm!
 ** bolo de bolota... hmmm!
 ++ refeição (jantar) com sopa de cebola a 323.15K e um bolo de bolota... hmmm!
 == já está!
 ============================