Tutoriais - Programação Orientada a Objetos
Tutoriais
Programação Orientada a Objetos

/**
 * Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

/**
 * Animal ja registrado no zoologico
 */
public class AnimalDuplicateKeyException extends Exception
{
  /**
   * Identificador de serializacao da classe
   */
  private static final long serialVersionUID = 1L;

  /**
   * Constructs a new exception with null as its detail message
   */
  public AnimalDuplicateKeyException()
  {
    super();
  }

  /**
   * Constructs a new exception with the specified detail message
   * 
   * @param message the detail message
   */
  public AnimalDuplicateKeyException(String message)
  {
    super(message);
  }
}

/**
 * Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

/**
 * Animal nao registrado no zoologico
 */
public class AnimalNotFoundException extends Exception
{
  /**
   * Identificador de serializacao da classe
   */
  private static final long serialVersionUID = 1L;

  /**
   * Constructs a new exception with null as its detail message
   */
  public AnimalNotFoundException()
  {
    super();
  }

  /**
   * Constructs a new exception with the specified detail message
   * 
   * @param message the detail message
   */
  public AnimalNotFoundException(String message)
  {
    super(message);
  }
}

/**
 * Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

/**
 * Nenhum animal registrado no zoologico
 */
public class ZooEmptyException extends Exception
{
  /**
   * Identificador de serializacao da classe
   */
  private static final long serialVersionUID = 1L;

  /**
   * Constructs a new exception with null as its detail message
   */
  public ZooEmptyException()
  {
    super();
  }

  /**
   * Constructs a new exception with the specified detail message
   * 
   * @param message the detail message
   */
  public ZooEmptyException(String message)
  {
    super(message);
  }
}

/**
 * Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

import java.io.Serializable;

/**
 * Classe para representar um animal
 */
public class Animal implements Comparable<Animal>, Serializable
{
  /**
   * Identificador de serializacao da classe
   */
  private static final long serialVersionUID = 1L;

  /**
   * Apelido do animal
   */
  private String apelido;

  /**
   * Nome da especie do animal
   */
  private String especie;

  /**
   * Nome do animal
   */
  private String nome;

  /**
   * Construtor da classe Animal
   * 
   * @param especie nome da especie do animal
   * @param nome nome do animal
   * @param apelido apelido do animal
   * @throws IllegalArgumentException algum atributo do animal eh vazio
   * @throws NullPointerException algum atributo do animal eh nulo
   */
  public Animal(String especie, String nome, String apelido) throws IllegalArgumentException,
                                                                    NullPointerException
  {
    // Configurar o nome da especie do animal
    setEspecie(especie);

    // Configurar o nome do animal
    setNome(nome);

    // Configurar o apelido do animal
    setApelido(apelido);
  }

  /* (non-Javadoc)
   * @see java.lang.Object#clone()
   */
  public Animal clone()
  {
    // Retornar um clone da instancia atual
    return new Animal(getEspecie(), getNome(), getApelido());
  }

  /* (non-Javadoc)
   * @see java.lang.Comparable#compareTo(Object)
   */
  public int compareTo(Animal animal)
  {
    // Ordenar os animais pelo nome da especie
    int i = getEspecie().compareToIgnoreCase(animal.getEspecie());

    // Os animais sao da mesma especie
    if(i == 0)
    {
      // Ordenar os animais pelo nome
      i = getNome().compareToIgnoreCase(animal.getNome());

      // Os animais tem o mesmo nome
      if(i == 0)
      {
        // Ordenar os animais pelo apelido
        i = getApelido().compareToIgnoreCase(animal.getApelido());
      }
    }

    // Retornar o resultado da comparacao entre os dois animais
    return i;
  }

  /**
   * Retornar o apelido do animal
   * 
   * @return apelido do animal
   */
  public String getApelido()
  {
    // Retornar o apelido do animal
    return this.apelido;
  }

  /**
   * Retornar o nome da especie do animal
   * 
   * @return nome da especie do animal
   */
  public String getEspecie()
  {
    // Retornar o nome da especie do animal
    return this.especie;
  }

  /**
   * Retornar o nome do animal
   * 
   * @return nome do animal
   */
  public String getNome()
  {
    // Retornar o nome do animal
    return this.nome;
  }

  /**
   * Configurar o apelido do animal
   * 
   * @param apelido apelido do animal
   * @throws IllegalArgumentException apelido do animal eh vazio
   * @throws NullPointerException apelido do animal eh nulo
   */
  private void setApelido(String apelido) throws IllegalArgumentException, NullPointerException
  {
    // Verificar se o apelido do animal nao eh nulo
    if(apelido != null)
    {
      // Verificar se o apelido do animal nao esta vazio
      if(apelido.length() > 0)
      {
        // Configurar o apelido do animal 
        this.apelido = apelido;

        // Finalizar a configuracao do apelido do animal
        return;
      }

      // Disparar a excecao de que o apelido do animal eh vazio
      throw new IllegalArgumentException("Apelido do animal eh vazio");
    }

    // Disparar a excecao de que o apelido do animal eh nulo
    throw new NullPointerException("Apelido do animal eh nulo");
  }

  /**
   * Configurar o nome da especie do animal
   * 
   * @param especie nome da especie do animal
   * @throws IllegalArgumentException nome da especie do animal eh vazio
   * @throws NullPointerException nome da especie do animal eh nulo
   */
  private void setEspecie(String especie) throws IllegalArgumentException, NullPointerException
  {
    // Verificar se o nome da especie do animal nao eh nulo
    if(especie != null)
    {
      // Verificar se o nome da especie do animal nao esta vazio
      if(especie.length() > 0)
      {
        // Configurar o nome da especie do animal 
        this.especie = especie;

        // Finalizar a configuracao do nome da especie do animal
        return;
      }

      // Disparar a excecao de que o nome da especie do animal eh vazio
      throw new IllegalArgumentException("Nome da especie do animal eh vazio");
    }

    // Disparar a excecao de que o nome da especie do animal eh nulo
    throw new NullPointerException("Nome da especie do animal eh nulo");
  }

  /**
   * Configurar o nome do animal
   * 
   * @param nome nome do animal
   * @throws IllegalArgumentException nome do animal eh vazio
   * @throws NullPointerException nome do animal eh nulo
   */
  private void setNome(String nome) throws IllegalArgumentException, NullPointerException
  {
    // Verificar se o nome do animal nao eh nulo
    if(nome != null)
    {
      // Verificar se o nome do animal nao esta vazio
      if(nome.length() > 0)
      {
        // Configurar o nome do animal 
        this.nome = nome;

        // Finalizar a configuracao do nome do animal
        return;
      }

      // Disparar a excecao de que o nome do animal eh vazio
      throw new IllegalArgumentException("Nome do animal eh vazio");
    }

    // Disparar a excecao de que o nome do animal eh nulo
    throw new NullPointerException("Nome do animal eh nulo");
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString()
  {
    // Retornar as informacoes do animal, no formato apelido, nome (especie)
    return getApelido() + ", " + getNome() + " (" + getEspecie() + ")";
  }
}

/**
 * Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Classe para representar um zoologico
 */
public class Zoologico
{
  /**
   * Animais registrados no zoologico
   */
  private List<Animal> animais;

  /**
   * Construtor da classe Zoologico
   */
  public Zoologico()
  {
    // Inicilizar o registro dos animais do zoologico
    this.animais = new ArrayList<Animal>();
  }

  /**
   * Retornar a quantidade de animais de cada especie
   * 
   * @return a quantidade de animais de cada especie
   * @throws ZooEmptyException animal nao registrado
   */
  public Map<String, Integer> contabilizar() throws ZooEmptyException
  {
    // Mapa com a quantidade de cada especie
    Map<String, Integer> quantidade = new HashMap<String, Integer>();

    // Percorrer todos os animais registrados no zoologico
    for(Animal animal: this.animais)
    {
      // Verificar se a especie ja foi contabilizada
      if(quantidade.containsKey(animal.getEspecie()))
      {
        // Quantidade de animais ja contabilizados da especie
        Integer amount = quantidade.get(animal.getEspecie());

        // Atualizar a quantidade de animais da especie
        quantidade.put(animal.getEspecie(), new Integer(amount.intValue() + 1));
      }
      else
      {
        // Contabilizar pela primeira vez o animal da especie
        quantidade.put(animal.getEspecie(), new Integer(1));
      }
    }

    // Verificar se algum animal foi localizado
    if(!quantidade.isEmpty())
    {
      // Retornar a lista de animais localizados
      return quantidade;
    }

    // Disparar a excecao de animal nao registrado
    throw new ZooEmptyException("Nenhum animal registrado no zoologico");
  }

  /**
   * Retornar as especies registradas no zoologico
   * 
   * @return lista com as especies registradas no zoologico
   * @throws ZooEmptyException animal nao registrado
   */
  public Set<String> especies() throws ZooEmptyException
  {
    // Ordenar os animais registrados no zoologico
    Collections.sort(this.animais);

    // Lista com as especies registradas no zoologico
    Set<String> especies = new LinkedHashSet<String>();

    // Percorrer todos os animais registrados no zoologico
    for(Animal animal: this.animais)
    {
      especies.add(animal.getEspecie());
    }

    // Verificar se algum animal foi localizado
    if(!especies.isEmpty())
    {
      // Retornar a lista de animais localizados
      return especies;
    }

    // Disparar a excecao de animal nao registrado
    throw new ZooEmptyException("Nenhum animal registrado no zoologico");
  }

  /**
   * Retornar os animais com o apelido desejado
   * 
   * @param apelido apelido do animal
   * @return lista com os animais com o apelido desejado
   * @throws AnimalNotFoundException animal nao registrado
   */
  public List<Animal> findByApelido(String apelido) throws AnimalNotFoundException
  {
    // Nova lista de animais
    List<Animal> localizados = new ArrayList<Animal>();

    // Percorrer todos os animais registrados no zoologico
    for(Animal animal: this.animais)
    {
      // Verificar se o animal possui o apelido desejado
      if(animal.getApelido().equalsIgnoreCase(apelido))
      {
        localizados.add(animal.clone());
      }
    }

    // Verificar se algum animal foi localizado
    if(!localizados.isEmpty())
    {
      // Retornar a lista de animais localizados
      return localizados;
    }

    // Disparar a excecao de animal nao registrado
    throw new AnimalNotFoundException("Nenhum animal localizado com o apelido '" +
                                      apelido + "'");
  }

  /**
   * Retornar os animais com o nome da especie desejado
   * 
   * @param especie nome da especie do animal
   * @return lista com os animais com o nome da especie desejado
   * @throws AnimalNotFoundException animal nao registrado
   */
  public List<Animal> findByEspecie(String especie) throws AnimalNotFoundException
  {
    // Nova lista de animais
    List<Animal> localizados = new ArrayList<Animal>();

    // Percorrer todos os animais registrados no zoologico
    for(Animal animal: this.animais)
    {
      // Verificar se o animal possui o nome da especie desejado
      if(animal.getEspecie().equalsIgnoreCase(especie))
      {
        localizados.add(animal.clone());
      }
    }

    // Verificar se algum animal foi localizado
    if(!localizados.isEmpty())
    {
      // Retornar a lista de animais localizados
      return localizados;
    }

    // Disparar a excecao de animal nao registrado
    throw new AnimalNotFoundException("Nenhum animal localizado com o nome da especie '" +
                                      especie + "'");
  }

  /**
   * Retornar os animais com o nome desejado
   * 
   * @param nome nome do animal
   * @return lista com os animais com o nome desejado
   * @throws AnimalNotFoundException animal nao registrado
   */
  public List<Animal> findByNome(String nome) throws AnimalNotFoundException
  {
    // Nova lista de animais
    List<Animal> localizados = new ArrayList<Animal>();

    // Percorrer todos os animais registrados no zoologico
    for(Animal animal: this.animais)
    {
      // Verificar se o animal possui o nome desejado
      if(animal.getNome().equalsIgnoreCase(nome))
      {
        localizados.add(animal.clone());
      }
    }

    // Verificar se algum animal foi localizado
    if(!localizados.isEmpty())
    {
      // Retornar a lista de animais localizados
      return localizados;
    }

    // Disparar a excecao de animal nao registrado
    throw new AnimalNotFoundException("Nenhum animal localizado com o nome '" + nome + "'");
  }

  /**
   * Registrar o animal no zoologico
   * 
   * @param animal animal a ser registrado no zoologico
   * @throws AnimalDuplicateKeyException animal ja registrado
   */
  public void registrar(Animal animal) throws AnimalDuplicateKeyException
  {
    /*
     * Verificar se o animal ja encontra-se registrado no zoologico
     */

    // Percorrer todos os animais registrados no zoologico
    for(Animal registrado: this.animais)
    {
      // Verificar se o animal ja esta registrado
      if(registrado.compareTo(animal) == 0)
      {
        // Disparar a excecao de que o animal ja encontra-se registrado no zoologico
        throw new AnimalDuplicateKeyException("Animal ja registrado");
      }
    }

    // Registra o animal no zoologico
    this.animais.add(animal);
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString()
  {
    // Ordenar os animais pelo nome de suas especies
    Collections.sort(this.animais);

    // Saida com os animais registrados no zoologico
    String saida = "";

    // Imprimir todos os animais registrados no zoologico
    for(Animal animal: this.animais)
    {
      // Construir a saida com os animais registrados no zoologico
      saida += animal.toString() + "\n";
    }

    // Retornar todos os animais registrados no zoologico
    return saida;
  }
}

/**
 * Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

import java.util.Map;

/**
 * Classe responsavel pela aplicacao
 */
public class Aplicacao
{
  /**
   * Metodo principal da linguagem de programacao Java
   * 
   * @param args argumentos da linha de comando (nao utilizado)
   */
  public static void main(String[] args)
  {
    // Instanciar o zoologico XPTO
    Zoologico XPTO = new Zoologico();

    try
    {
      // Registrar os elefantes
      XPTO.registrar(new Animal("Loxodonta africana", "Elefante-da-savana", "Dumbo"));
      XPTO.registrar(new Animal("Loxodonta africana", "Elefante-da-savana", "Timba"));

      // Registrar os tigres
      XPTO.registrar(new Animal("Panthera tigris", "Tigre-siberiano", "Tom"));
      XPTO.registrar(new Animal("Panthera tigris", "Tigre-do-sul-da-china", "Felix"));
      XPTO.registrar(new Animal("Panthera tigris", "Tigre-da-indochina", "Oncinha"));
      XPTO.registrar(new Animal("Panthera tigris", "Tigre-de-sumatra", "Elliot"));
      XPTO.registrar(new Animal("Panthera tigris", "Tigre-de-bengala", "Milk"));
      XPTO.registrar(new Animal("Panthera tigris", "Tigre-malaio", "Nacho"));

      // Registrar os ursos
      XPTO.registrar(new Animal("Ursus arctos", "Urso-europeu", "Alecrim"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-cinzento", "Bisteca"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-castanho-do-himalaia", "Cookie"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-grizzly", "Lord"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-de-kodiak", "Pirata"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-cinzento-mexicano", "Black"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-azul-tibetano", "Duque"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-pardo-de-hokkaido", "Hunter"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-pardo-siberiano", "Neve"));
      XPTO.registrar(new Animal("Ursus arctos", "Urso-siriaco", "Manchinha"));
    }
    catch(AnimalDuplicateKeyException exception)
    {
      exception.printStackTrace();
    }

    // Imprimir os animais registrados no zoologico
    System.out.println(XPTO.toString());

    try
    {
      // Apresentar a contabilizacao do zoologico
      Map<String, Integer> animais = XPTO.contabilizar();

      // Imprimir a contabilizado do zoologico
      for(String especie: animais.keySet())
      {
        System.out.println(especie + ": " + animais.get(especie));
      }
    }
    catch(ZooEmptyException exception)
    {
      exception.printStackTrace();
    }
  }
}