AGRADECIMENTO...

Pessoal, Gostaria de pedir desculpas aqueles que deixam perguntas/comentários/elogios/críticas e ainda não foram respondidos.

Aproveito a oportunidade para informar a todos que devido a correria do dia a dia não conclui o curso de BSI, por isso meus conhecimentos são limitados rsrsrs...

Ainda não retirei o blog do ar porque tem ajudado a diversos estudantes, principalmente os iniciantes.

As vezes, quando o trabalho me permite, ainda arrisco tentar resolver algumas questões rs... mas para não deixar esse blog parar no tempo, o ESTUDANTE que quiser enviar a resolução de alguma questão (código próprio) para o meu e-mail, terei o prazer de posta-la neste blog e será mantido a autoria.

Desde já agradeço a todos pelas visitas e desejo bons estudos.

Thiago Campos
(srthiago@hotmail.com)

sábado, 24 de novembro de 2012

Questão 1 do livro Java 7 de Sergio Furgeri página 135

Faça uma classe que simule o funcionamento de uma lampada. A classe Lâmpada deve conter um atributo boleano "status" e os métodos "ligar" e "desligar" (ambos sem retorno). O método "ligar" colocar true em "status", já o método "desligar" coloca false em "status". Crie também o método "observar" que  retorna uma palavra referente ao estado da lâmpada ("ligada" ou "desligada").


Código Java
---------------------------------------------------------------------------
CLASSE LAMPADA
---------------------------------------------------------------------------
public class Lampada {
    private boolean status; //variavel que vai armazenar o estado da lampada
   
    //get e set
    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }
   
    /**
     * Este metodo vai colocar em status true, que significa que está a lãmpada
     * está ligada
     */
    public void ligar(){
        status = true;
    }
   
    /**
     * Este metodo vai colocar em status true, que significa que está a lãmpada
     * está ligada
     */
    public void desligar(){
        status = false;
    }
    /**
     * Este método vai retornar para o main o status para que possa ser mostrado
     * o estado da lampada
     * @return 
     */
    public String observar(){
        if(status == true)
           return "ligada";
       else
        return "desligada";
    }
} //fim da classe


---------------------------------------------------------------------------
CLASSE ESTADOLAMPADA - MAIN
---------------------------------------------------------------------------

//Autor: Thiago Campos
//Data: 23.11.2012

import javax.swing.JOptionPane;
import exercicioP135.Lampada;

/**
 *
 * @author Thiago
 */
public class EstadoLampada {
    public static void main(String[] args){
        //variaveis
        int estado = 0;
       
        Lampada acao = new Lampada();
       
       estado = JOptionPane.showConfirmDialog(null, "Ligar a lâmpada");
     
       //como ha apenas um comando no if e else podemos omitir as chaves
       if(estado == 0)
           acao.ligar();
       else
           acao.desligar();
     
       //saida
       JOptionPane.showMessageDialog(null, acao.observar());
     
    } //fim do main
} //fim da classe




quinta-feira, 22 de novembro de 2012

Projeto Biblioteca - Código Java

1.   Exercício da Biblioteca Simplificada

BIBLIOTECA SIMPLIFICADA


1) Considere o contexto de uma biblioteca simplificada, onde se pode realizar empréstimos de materiais informacionais.
Existem três tipos de materiais informacionais: livros, periódicos e materiais especiais.

2) Cada livro é representado por um número identificador (ISBN), título, ano, edição, volume, editora
e um ou mais autores.

3) Um autor é representando por um código (que o identifica na biblioteca), um nome e seu sobrenome.

4) Uma editora tem um nome e a informação se é nacional ou internacional

5) Cada periódico possui apenas um número identificador (ISSN), um título e um volume

6) O material especial possui uma descrição geral e um tipo (DVD, CD, FITA).

7) Cada material informacional possui um código de barras, o número da estante em que fica guardado, o número total de exemplares e o número total de exemplares disponíveis para empréstimo

8) Quando uma pessoa faz um empréstimo, deve-se registrar a pessoa, a data em que o empréstimo foi ralizado, o material informacional emprestado e uma indicação se houve ou não devolução.

9) Deve ser possível:
      9.1) Listar todos os empréstimos ativos realizados, onde são exibidos o  nome, telefone, cpf de quem efetuou o empréstimo, os dados
do material informacional emprestado e a data do empréstimo

9.2) Listar as devoluções (semelhante ao item 9.1)

9.3) Realizar  Empréstimo
9.3.1) Informar CPF da pessoa que deseja fazer o empréstimo
9.3.2) Se a pessoa já existir, usa a referência da pessoa existente
9.3.3) Se a pessoa não existir, cadastra pessoa
9.3.4) Solicitar Tipo de Material informacional
9.3.5) Listar materiais do tipo informado
9.3.6) Informa o cód. de barras do material escolhido para empréstimo
9.3.7) Cria registro do empréstimo, associando a pessoa e o material informacional escolhido
9.3.8) Reduz a quantidade disponível para empréstimo do material informacional

9.4) Registrar Devoluções
9.4.1) Informa CPF da Pessoa e código de barras do material informacional
9.4.2) Marca empréstimo como devolvido
9.4.3) Incrementa quantidade disponível para empréstimo

9.5) Cancelar empréstimo
9.5.1) Informa CPF da Pessoa e código de barras do material informacional
9.5.2) Remove registro de empréstimo
9.5.3) Incrementa quantidade disponível para empréstimo

-------------------------------------------------------------------------------

--> Considere o modelo abaixo do sistema acima usando os conceitos de orientação a objeto: classes (concreta e abstrata) e herança. Implemente-o.
--> Identifique os casos de uso e implemente códigos de testes
--> Os cadastros de pessoas, materiais informacionais e empréstimos devem ser simulados com a base de dados sendo Listas (ArrayList), ou seja, para cada classe existirá uma lista que representará o repositório de dados.

-------------------------------------------------------------------------------

Simulando a base de dados com listas

- DAO (Data Access Object) é um padrão para persistência de dados que permite separar regras de negócio das regras de acesso a banco de dados.

- Deve ser criada uma classe DAO para Pessoa, MaterialInformacional e Emprestimo. Cada uma classe dessas irá interagir com uma lista, que representa
uma tabela no banco de dados.



- No momento que necessitar fazer uma operação que "modifique a base de dados", deve-se invocar o objeto DAO correspondente. No início da aplicação de testes, crie uma única referência para cada um dos DAOs especificados. Por exemplo, na hora que necessitar adicionar um material informacional na base de dados, por exemplo, um livro, deve-se fazer da seguinte forma:


MaterialInformacionalDao matInfDao = new MaterialInformacionalDao(); //Criado uma única vez

//Cria objeto Livro
Livro livro = new Livro();
livro.setCodigoBarras(1837463);

//Define valores para restantes dos atributos
//...

//Adiciona o livro à base de dados
matInfDao.create(livro);

-------------------------------------------------------------------------------

Criar uma classes para simular esse exemplo que deverá: :


- Criar objetos DAOs
- Criar objetos MaterialInformacional dos três tipos e adiciona à base de dados, através de MaterialInformacionalDao
- Simular menu com as seguintes opções

1. Listar Empréstimos
2. Listar Devoluções
3. Realizar  Empréstimo
4. Registrar Devoluções
5. Cancelar empréstimo
6. Sair

-------------------------------------------------------------------------------
BIBLIOTECA: Imagem do projeto no NetBeans
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
BIBLIOTECA: CLASSES DO PACOTE DAO
-------------------------------------------------------------------------------

//Autor: Thiago Campos e Roberto Queiroz
//Data: 09/11/12
//CLASSE: EMPRESTIMODAO

package br.unirn.dao;

import br.unirn.dominio.Emprestimo;
import br.unirn.dominio.Livro;
import br.unirn.dominio.MaterialInformacional;
import br.unirn.dominio.Pessoa;
import br.unirn.dao.MaterialInformacionalDao;
import java.util.ArrayList;
import java.util.Date;
import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class EmprestimoDao {
    private int i = 0; //incrementa o id do emprestimo
    //cria listas
    private ArrayList<Emprestimo> emprestimos = new ArrayList<Emprestimo>();
    private ArrayList<Emprestimo> devolucoes = new ArrayList<Emprestimo>();
    
    //geteres e seters

    public ArrayList<Emprestimo> getDevolucoes() {
        return devolucoes;
    }

    public void setDevolucoes(ArrayList<Emprestimo> devolucoes) {
        this.devolucoes = devolucoes;
    }

    public ArrayList<Emprestimo> getEmprestimos() {
        return emprestimos;
    }

    public void setEmprestimos(ArrayList<Emprestimo> emprestimos) {
        this.emprestimos = emprestimos;
    }
    
    /**
     * Metodo 01 - Realiza um emprestimo e retorno do tipo Emprestimo
     * @param pessoa
     * @param material
     * @param data
     * @return 
     */
    public Emprestimo create(Pessoa pessoa, MaterialInformacional material, Date data){
        Emprestimo empReal = new Emprestimo();
        empReal.setId(i);
        empReal.setPessoa(pessoa);
        empReal.setMaterial(material);
        empReal.setDataEmprestimo(data);
        empReal.setDataDevolucao(null); //reafirma que o conteudo é null, deixando o emprestimo ativo
        
        //Foi necessario fazer um ploxi 
        if(material instanceof Livro ) {
            empReal.setAutor(((Livro) material).getAutor());
            empReal.setEditora(((Livro) material).getEditora());
        } 
        
        emprestimos.add(empReal); //adiciona no ArrayList emprestimo
        i++;
        return empReal;     
    } //fim da função create
    
    /**
     * Metodo 02: Este metodo recebe o cpf e o codigo de barras e retorna o id do emprestimo
     * @param cpf
     * @param cBarras
     * @return 
     */
    
        public Emprestimo findByIdentificador(long cpf, long cBarras){
        //converter os valores para Strings
        String CBStr = String.valueOf(cBarras);
        int v=0;
        //percorre o ArrayList Emprestimo
        for (Emprestimo e : emprestimos) {
            if(e.getPessoa().getCpf() == cpf){ //verifica se há pessoa com o mesmo cpf  
               v=1;
                if(e.getMaterial().getCodigoBarras().equals(CBStr)) //verifica se a pessoa encontrada possui um emprestimo com o CBarras informado
                    return e;  
                else 
                    JOptionPane.showMessageDialog(null, "O CPF(" + cpf + ") não possui o codigo de Barras (" + CBStr + ") emprestado");
                break;
            } if (v==1)
                JOptionPane.showMessageDialog(null, "Esta pessoa não possui emprestimo");
        } //fim do for
        return null;
    } //fim da função
    
    /**
     * Metodo 03: Este metodo recebe o codigo de barras do material cadastrado. 
     * Identificar a posição dele e percorre o emprestimo ate encontrar o elemento com o mesmo codigo de barras. 
     * Depois ele seta a data de devolução deixando o emprestimo inativo e o adiciona novamente na lista emprestimo 
     * na mesma posição.
     * @param codBarras
     * @param cpf 
     */
    public void removerEmprestimo(String codBarras, long cpf){
        Emprestimo emprestimoGuardado = null; //vai guardar o emprestimo qdo for encontrado
        Date data = new java.util.Date(); //vai registrar a data do pc
        
        for (Emprestimo e : emprestimos) { //vai percorrer a lista emprestimo em busca do elemento que contenha o mesmo codigo de barras
            if(e.getMaterial().getCodigoBarras().equals(codBarras)){
                    if(e.getPessoa().getCpf()==cpf){
                        emprestimoGuardado = e;
                        devolucoes.add(e); //adiciona o emprestimo e no ArrayList da devolução
                        break; //para de percorrer qdo encontrar 
                    } 
            } //fim do if
        } //fim do for
        
        int posicao = emprestimos.indexOf(emprestimoGuardado); //vai guardar a posição do elemento emprestimo na lista
        emprestimoGuardado.setDataDevolucao(data); //ao setar a data torna o emprestimo inativo
        emprestimos.add(posicao, emprestimoGuardado); //adiciona o elemento emprestimo na lista

        JOptionPane.showMessageDialog(null, "Material devolvido com sucesso!"); //saida: confirmação da operação
    } //fim da função create   

    //....................................................................................................
   
 /**
     * Método 3.1: Este metodo recebe emprestimo cadastrado. 
     * Identificar a posição dele e percorre o emprestimo ate encontrar o elemento com o mesmo codigo de barras. 
     * Depois ele seta a data de devolução deixando o emprestimo inativo e o adiciona novamente na lista emprestimo 
     * na mesma posição.
     * @param e 
     */
    public void devolverEmprestimo(Emprestimo e){
        Emprestimo emprestimoGuardado = null; //vai guardar o emprestimo qdo for encontrado
        Date data = new java.util.Date(); //vai registrar a data do pc
        
        if(e!=null){
           
                for (Emprestimo eE : emprestimos) {
                    if(e.getPessoa().getCpf() == eE.getPessoa().getCpf() && eE.getDataDevolucao() == null){ 
                        if(e.getMaterial().getExemplares( )>= e.getMaterial().getDisponiveis()){
                            emprestimoGuardado = e;
                            devolucoes.add(e);

                            int posicao = emprestimos.indexOf(emprestimoGuardado); //vai guardar a posição do elemento emprestimo na lista
                            emprestimoGuardado.setDataDevolucao(data); //ao setar a data torna o emprestimo inativo
                            emprestimos.add(posicao, emprestimoGuardado); //adiciona o elemento emprestimo na lista


                            JOptionPane.showMessageDialog(null, "Material devolvido com sucesso!"); //saida: confirmação da operação
                            break;
                        } 
                    }else
                        JOptionPane.showMessageDialog(null, "Cpf não encontrado na lista dos emprestimos");
                } //fim do for
            } //fim do if
            else 
                JOptionPane.showMessageDialog(null, "Exemplar ja devolvido ... ");
    }
     //.......................................................................................................

    /**
     * Metodo 04: Realiza o cancelamento do emprestimo, retirando-o da lista dos emprestimos
     * @param id 
     */
    public void cancelarEmprestimo(long id){
        for (Emprestimo e : emprestimos) { 
            if(e.getId() == (id)){ //vai verificar se existe algum emprestimo na lista com o id informado
               emprestimos.remove(e);
                break;
            } //fim do if
        } //fim do for
    } //fim da função
    
    /**
     * Metodo 05: Lista todos os emprestimos
     * @return 
     */
    public ArrayList<Emprestimo> findEmprestimos(){
        return emprestimos;
    }
    
    /**
     * Metodo 06: Vai listar todas as devoluções registradas. Retorna um ArrayList 
     * @return 
     */
    public ArrayList<Emprestimo> findDevolucoes(){
        return devolucoes;
    } //fim da função findDevolucao
    
    
    /**
     * Método 07: Recebe o codigo de barras do material informacional e busca o material na lista dos emprestimos
     * @param codigo
     * @return 
     */
    public Emprestimo findByCBEmprestado(long codigo){
        if(!emprestimos.isEmpty()){
            for (Emprestimo matEncontrado : emprestimos) {
                if(matEncontrado.getMaterial().getCodigoBarras().equals(String.valueOf(codigo)))
                    return matEncontrado;
            } //fim do for
        } //fim do if
        return null;
    } //fim da função
    
}


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------


package br.unirn.dao;

import br.unirn.dominio.MaterialInformacional;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class MaterialInformacionalDao {

    ArrayList<MaterialInformacional> material = new ArrayList<MaterialInformacional>();

    /**
     * getMaterial() retorna a lista de todos os materiais cadastrados no
     * ArrayList<MaterialInformacional>
     *
     * @return
     */
    public ArrayList<MaterialInformacional> getMaterial() {
        return material;
    }

    public void setMaterial(ArrayList<MaterialInformacional> material) {
        this.material = material;
    }

    /**
     * Metodo 01: Cria um material na lista Ok
     *
     * @param novoMaterial
     * @return
     */
    public MaterialInformacional create(MaterialInformacional novoMaterial) {
        this.material.add(novoMaterial);
        return novoMaterial;
    } //fim do metodo

    /**
     * Metodo 02: Realiza a listagem dos Materiais Informacionais. Ok
     *
     * @return
     */
    public ArrayList<MaterialInformacional> findAll() {
        return material;
    } //fim do metodo

    /**
     * Metodo 03: Realiza a busca do material informacional pelo tipo. Ele
     * utiliza o primeiro algarismo do codigo de barra para determinar o tipo do
     * material. Sendo: 1-Para Livro 2-Para Periodico 3-Para Material Especial
     *
     * @param tipo
     * @return
     */
    public ArrayList<MaterialInformacional> findByTipo(int tipo) {
        ArrayList<MaterialInformacional> subLista = new ArrayList<MaterialInformacional>();

        //se o primeiro numero do codigo de barras for == 1 trata-se de um livro
        if (tipo == 1) {
            for (MaterialInformacional m : material) {
                if (m.getCodigoBarras().substring(0, 1).equals("1")) {
               //   saida += m.getCodigoBarras() + m.getTitulo() + "\n";
                    subLista.add(m);
                }
            }
            return subLista;
        } //se o primeiro numero do codigo de barras for == 2 trata-se de um Periodico
        else if (tipo == 2) {
            for (MaterialInformacional m : material) {
                if (m.getCodigoBarras().substring(0, 1).equals("2")) {
                    subLista.add(m);
                }
            }
            return subLista;
        } //se o primeiro numero do codigo de barras for == 3 trata-se de um Material especial
        else if (tipo == 3) {
            for (MaterialInformacional m : material) {
                if (m.getCodigoBarras().substring(0, 1).equals("3")) {
                    subLista.add(m);
                }
            }
            return subLista;
        }
        return null;
    } //fim da função 
    /**
     * Metodo 04: Busca o material informacional pelo codigo de barras. O metodo vai verificar 
     * inicialmente se a lista está vazia e depois percorrer o material informacional ate encontrar 
     * um igual ao codigo de barras.
     * @param codigo
     * @return 
     */
    public MaterialInformacional findByCodigoBarras(long codigo){
        if(!material.isEmpty()){
            for (MaterialInformacional m : material) {
                if(m.getCodigoBarras().equals(String.valueOf(codigo)))
                    return m;
            } //fim do for
        } //fim do if
        return null;
    } //fim da função
    
    /**
     * Metodo 05: Atualiza o numero de exemplares disponiveis, dependendo do tipo da operação. 
     * Se realizar um emprestimo ele vai diminuir o numero de exemplares disponiveis, 
     * caso seja uma devolução irá aumentar o numero de exemplares disponiveis
     * @param materialRet
     * @param quantidade 
     */
    public void updateQuantExemplaresDisponiveis(MaterialInformacional materialRet, int quantidade){      
        materialRet.setDisponiveis(quantidade);
    } //fim da função
    
//fim da CLASSE


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dao;

import br.unirn.dominio.Pessoa;
import java.util.ArrayList;
import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class PessoaDao {
    private ArrayList<Pessoa> pessoa = new ArrayList<Pessoa>();
    
    //geteres e seteres
    public ArrayList<Pessoa> getPessoa() {
        return pessoa;
    }

    public void setPessoa(ArrayList<Pessoa> pessoa) {
        this.pessoa = pessoa;
    }        
    
    /**
     * 01 Metodo CREATE que cria uma pessoa
     * Ok
     * @param pessoa
     * @return 
     */  
    public Pessoa createPessoa(Pessoa pessoaNova){
        //adiciona a lista
        this.pessoa.add(pessoaNova);
        return pessoaNova;
    } //fim da função create
    
    /**
     * 02 Metodo que realiza a listagem das pessoas
     * Ok
     * @return 
     */
    public ArrayList<Pessoa> findAll() {
        return pessoa;
    }
   
   /**
     * Metodo 03 que realiza a busca da pessoa pelo cpf. Retorna um elemento Pessoa
     * @param cpf
     * @return 
     */
    public Pessoa findByCpf(long cpf){
        if(!pessoa.isEmpty()){
            for (Pessoa p : pessoa) {
                if(p.getCpf() == cpf)
                    return p;
            } //fim do for
        }
        return null;
    } //fim da função findByCpf
    
    /**
     * Metodo 04: Remove da lista uma pessoa cadastrada. Metodo Extra que não possui retorno: void
     * @param cpf 
     */
    public void removeByCpf(long cpf){
        Pessoa p = findByCpf(cpf);
        if(cpf == p.getCpf()){
            pessoa.remove(p);
            JOptionPane.showMessageDialog(null, "Pessoa removida com sucesso!");
        }else
            JOptionPane.showMessageDialog(null, "Não há pessoa cadastrada com esse CPF.");
                           
    } //fim da função     
//fim da Classe



-------------------------------------------------------------------------------
BIBLIOTECA: CLASSES DO PACOTE DOMINIO
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class Autor {
    private long id;
    private String nome;
    private String sobreNome;
    
    private Livro livro;
    
    //geteres e seteres

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getSobreNome() {
        return sobreNome;
    }

    public void setSobreNome(String sobreNome) {
        this.sobreNome = sobreNome;
    }
    
    //classe Livro

    public Livro getLivro() {
        return livro;
    }

    public void setLivro(Livro livro) {
        this.livro = livro;
    }
    
    /**
     * equals -> vai verificar se objetos da mesma classe são iguais
     *
     * @param outroAutor
     * @return
     */
    @Override
    public boolean equals(Object outroAutor){
        return id == ((Autor) outroAutor).getId();
    }
}
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class Editora {
    private long id;
    private String nome;
    private int tipo;
    
    //geteres e seteres

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public int getTipo() {
        return tipo;
    }

    public void setTipo(int tipo) {
        this.tipo = tipo;
    }
    
    /**
     * equals -> vai verificar se objetos da mesma classe são iguais
     *
     * @param outraEditora
     * @return
     */
    @Override
    public boolean equals (Object outraEditora){
        return id == ((Autor) outraEditora).getId();
    }
}

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

import java.util.Date;

/**
 *
 * @author Thiago
 */
public class Emprestimo {
    private long id;
    private Date dataEmprestimo;
    private Date dataDevolucao = null;
   
    
    //variaveis de relacionamento
    Pessoa pessoa; //obj da classe pessoa
    Autor autor; //obj da classe Autor
    Editora editora; //obj da classe Editora
    MaterialInformacional material; //obj da Classe MaterialInformacional
    
    //geteres e seteres
    /**
     * getDataDevolucao vai retornar a data de devolução do emprestimo
     * @return 
     */
    public Date getDataDevolucao() {
        return dataDevolucao;
    }

    /**
     * setDataDevolucao vai setar a data de devolução do emprestimo
     * @param dataDevolucao 
     */
    public void setDataDevolucao(Date dataDevolucao) {
        this.dataDevolucao = dataDevolucao;
    }
    
    public Date getDataEmprestimo() {
        return dataEmprestimo;
    }

    public void setDataEmprestimo(Date dataEmprestimo) {
        this.dataEmprestimo = dataEmprestimo;
    }
    
    
    /**
     * getId() vai retornar o codigo do emprestimo
     * @return 
     */
    public long getId() {
        return id;
    }
   
 /**
     * setId() vai setar o codigo do emprestimo
     * @param id 
     */
    public void setId(long id) {
        this.id = id;
    }

    //get e set das variaveis da classe
    public Pessoa getPessoa() {
        return pessoa;
    }

    public void setPessoa(Pessoa pessoa) {
        this.pessoa = pessoa;
    }
    
    public MaterialInformacional getMaterial() {
        return material;
    }

    public void setMaterial(MaterialInformacional material) {
        this.material = material;
    }

    public Autor getAutor() {
        return autor;
    }

    public void setAutor(Autor autor) {
        this.autor = autor;
    }

    public Editora getEditora() {
        return editora;
    }

    public void setEditora(Editora editora) {
        this.editora = editora;
    }

    
    /**
     * equals -> vai verificar se objetos da mesma classe são iguais
     *
     * @param outroEmprestimo
     * @return
     */
    @Override
    public boolean equals (Object outroEmprestimo){
        return id == ((Emprestimo) outroEmprestimo).getId();
    }
}


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class Livro extends MaterialInformacional{
    //variaveis exclusiveis da classe Livro
    private int isbn;
    private int ano;
    private int volume;
    private int edicao;
    
    private Autor autor;
    private Editora editora;
    
    
    //geteres e seteres

    public int getAno() {
        return ano;
    }

    public void setAno(int ano) {
        this.ano = ano;
    }

    public int getEdicao() {
        return edicao;
    }

    public void setEdicao(int edicao) {
        this.edicao = edicao;
    }

    public int getIsbn() {
        return isbn;
    }

    public void setIsbn(int isbn) {
        this.isbn = isbn;
    }

    public int getVolume() {
        return volume;
    }

    public void setVolume(int volume) {
        this.volume = volume;
    }

    public Autor getAutor() {
        return autor;
    }

    public void setAutor(Autor autor) {
        this.autor = autor;
    }

    public Editora getEditora() {
        return editora;
    }

    public void setEditora(Editora editora) {
        this.editora = editora;
    }
    
    
    /**
     * equals -> vai verificar se objetos da mesma classe são iguais
     *
     * @param outroLivro
     * @return
     */
    @Override
    public boolean equals(Object outroLivro){
        return isbn == ((Livro) outroLivro).getIsbn();
    }
}



-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class MaterialEspecial extends MaterialInformacional{
    //variaveis exclusiveis da classe Periodico
    private String descricao;
    private TipoMaterialEspecial tipoMaterialEspecial;
    
    //variavel da classe filha
    private long idTipoMaterial;
    
    //geteres e seteres

    public String getDescricao() {
        return descricao;
    }

    public void setDescricao(String descricao) {
        this.descricao = descricao;
    }

    //geteres e seteres da variavel da classe filha

    public long getIdTipoMaterial() {
        return idTipoMaterial;
    }

    public void setIdTipoMaterial(long idTipoMaterial) {
        this.idTipoMaterial = idTipoMaterial;
    }

    public TipoMaterialEspecial getTipoMaterialEspecial() {
        return tipoMaterialEspecial;
    }

    public void setTipoMaterialEspecial(TipoMaterialEspecial tipoMaterialEspecial) {
        this.tipoMaterialEspecial = tipoMaterialEspecial;
    }
    
}



-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class MaterialInformacional {
    private long id;
    private String titulo;
    private String codigoBarras; //CRITERIO: Primeiro numero vai indicar o tipo/o segundo a estante
    private int estante;
    private int exemplares;
    private int disponiveis;

    public String getCodigoBarras() {
        return codigoBarras;
    }

    public void setCodigoBarras(String codigoBarras) {
        this.codigoBarras = codigoBarras;
    }

    public int getDisponiveis() {
        return disponiveis;
    }

    public void setDisponiveis(int disponiveis) {
        this.disponiveis = disponiveis;
    }

    public int getEstante() {
        return estante;
    }

    public void setEstante(int estante) {
        this.estante = estante;
    }

    public int getExemplares() {
        return exemplares;
    }

    public void setExemplares(int exemplares) {
        this.exemplares = exemplares;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
    
    public boolean equals(Object outroMaterial){
        return id == ((MaterialInformacional) outroMaterial).getId();
    }
}


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class Periodico extends MaterialInformacional{
    //variaveis exclusiveis da classe Periodico
    private int issn;
    private int ano;
    private int volume;
    
    //geteres e seteres

    public int getAno() {
        return ano;
    }

    public void setAno(int ano) {
        this.ano = ano;
    }

    public int getIssn() {
        return issn;
    }

    public void setIssn(int issn) {
        this.issn = issn;
    }

    public int getVolume() {
        return volume;
    }

    public void setVolume(int volume) {
        this.volume = volume;
    }
    
    /**
     * equals -> vai verificar se objetos da mesma classe são iguais
     *
     * @param outroPeriodico
     * @return
     */
    @Override
    public boolean equals(Object outroPeriodico){
        return issn == ((Periodico) outroPeriodico).getIssn();
    }
}



-------------------------------------------------------------------------------
-------------------------------------------------------------------------------


package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class Pessoa {
    //variaveis
    private long id;
    private long cpf;
    private String nome;
    private String telefone;
    
    //geteres e seteres

    public long getCpf() {
        return cpf;
    }

    public void setCpf(long cpf) {
        this.cpf = cpf;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

    /**
     * equals -> vai verificar se objetos da mesma classe são iguais
     * Ok
     * @param outraPessoa
     * @return
     */
    @Override
    public boolean equals(Object outraPessoa){
        return id == ((Pessoa) outraPessoa).getId();
    }//fim da funcão equals
}

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

package br.unirn.dominio;

/**
 *
 * @author Thiago
 */
public class TipoMaterialEspecial {
    private long id;
    private String nome;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }    
}











-------------------------------------------------------------------------------
BIBLIOTECA: CLASSE DO PACOTE MAIN
-------------------------------------------------------------------------------

//Autor: Thiago Campos e Roberto Queiroz
//Data: 09/11/12

/*
 * Esta classe possui o main
 */
package br.unirn.main;

import br.unirn.dao.EmprestimoDao;
import br.unirn.dao.MaterialInformacionalDao;
import br.unirn.dao.PessoaDao;
import br.unirn.dominio.*;
import br.unirn.dominio.Emprestimo;
import java.sql.Date;
import java.text.SimpleDateFormat; //Responsavel por formatar a saida da data
import javax.swing.JOptionPane; //Responsavel pelas janelas

/**
 *
 * @author Thiago
 */
public class Biblioteca {

    public static void main(String[] args) {

        //referencia para cada Dao
        MaterialInformacionalDao matInf = new MaterialInformacionalDao();
        PessoaDao pessoa = new PessoaDao();
        EmprestimoDao emprestimo = new EmprestimoDao();
       // Emprestimo emprestimoDom = new Emprestimo();
       
        //Variaveis
        int op; //variavel utilizada nos menus
        int ip = 4; //incrementa o id do objeto pessoa
        int miL = 4; //incrementa o id do mat. Inf. Livro
        int miP = 3; //incrementa o id do mat. Inf. Livro
        int miE = 3; //incrementa o id do mat. Inf. Livro
        int tipoMat = 0; //usada na busca do material por tipo
        String str = ""; //vai tratar a listagem dos usuarios cadastrados
        String tipoStr = ""; //vai tratar a listagem do Material por tipo
        String strEmp = ""; //vai tratar a listagem dos emprestimos
        String saida = ""; //vai tratar a listagem do material informacional
        long eCpf=0; //usada no case da devolução do material
        long eCodigoBarras=0; //usada no case da devolução do material
       

        //CADASTRO AUTOMATICO DE PESSOAS
        //PESSOA 1
        Pessoa p = new Pessoa();  //Nova pessoa
        p.setId(1);
        p.setNome("Thiago Campos");
        p.setCpf(1111);
        p.setTelefone("9900-7500");
        pessoa.createPessoa(p); //adiciona a lista

        Pessoa p1 = new Pessoa(); //Nova pessoa
        p1.setId(2);
        p1.setNome("Roberto Queiroz");
        p1.setCpf(2222);
        p1.setTelefone("8710-1002");
        pessoa.createPessoa(p1); //adiciona a lista

        Pessoa p2 = new Pessoa(); //Nova pessoa
        p2.setId(3);
        p2.setNome("Ronaldo da Silva");
        p2.setCpf(3333);
        p2.setTelefone("8155-5554");
        pessoa.createPessoa(p2); //adiciona a lista
        //FIM DO CADASTRO AUTOMATICO DAS PESSOAS

        //CADASTRO AUTOMATICO DO MATERIAL INFORMACIONAL
        //LIVRO 1
        Livro livro = new Livro();
        livro.setId(101);
        livro.setTitulo("Quebrando a Cabeça com Java");
        livro.setCodigoBarras("11001");
        livro.setEstante(1);
        livro.setExemplares(2);
        livro.setDisponiveis(2);
        livro.setIsbn(101);
        livro.setAno(2010);
        livro.setVolume(3);
        //Instanciando Autor
        Autor autor = new Autor();
        autor.setId(11);
        autor.setNome("Itamir");
        autor.setSobreNome("Filho");
        livro.setAutor(autor); //add autor
        //instanciando Editora
        Editora editora = new Editora();
        editora.setId(10);
        editora.setNome("Abril");
        editora.setTipo(1);
        livro.setEditora(editora); //add editora

        //LIVRO 2
        Livro livro2 = new Livro();
        livro2.setId(102);
        livro2.setTitulo("Programação Orientada a Objeto");
        livro2.setCodigoBarras("11002");
        livro2.setEstante(1);
        livro2.setExemplares(1);
        livro2.setDisponiveis(1);
        livro2.setIsbn(102);
        livro2.setAno(2009);
        livro2.setVolume(1);
        //Instanciando autor
        Autor autor2 = new Autor();
        autor2.setId(12);
        autor2.setNome("Paulo");
        autor2.setSobreNome("Coelho");
        livro2.setAutor(autor2); //add autor
        //instanciando editora
        Editora editora1 = new Editora();
        editora1.setId(20);
        editora1.setNome("Saraiva");
        editora1.setTipo(2);
        livro2.setEditora(editora1); //add editora

        //LIVRO 3
        Livro livro3 = new Livro();
        livro3.setId(103);
        livro3.setTitulo("Java 7: Como Programar");
        livro3.setCodigoBarras("11003");
        livro3.setEstante(1);
        livro3.setExemplares(3);
        livro3.setDisponiveis(3);
        livro3.setIsbn(103);
        livro3.setAno(2011);
        livro3.setVolume(3);
        //instanciando autor
        Autor autor3 = new Autor();
        autor3.setId(13);
        autor3.setNome("Jose");
        autor3.setSobreNome("Brandão");
        livro3.setAutor(autor3); //add autor
        //instanciando editora
        Editora editora3 = new Editora();
        editora3.setId(20);
        editora3.setNome("Saraiva");
        editora3.setTipo(2);
        livro.setEditora(editora3);

        //Adicionar o livro a base de dado
        matInf.create(livro);
        matInf.create(livro2);
        matInf.create(livro3);

        //PERIODICO 01
        Periodico per = new Periodico();
        per.setId(201);
        per.setTitulo("Diario de Natal");
        per.setCodigoBarras("22001");
        per.setEstante(2);
        per.setExemplares(5);
        per.setDisponiveis(5);
        per.setIssn(201);
        per.setVolume(5);
        per.setAno(2004);

        //PERIODICO 02
        Periodico per2 = new Periodico();
        per2.setId(202);
        per2.setTitulo("Tribuna do Norte");
        per2.setCodigoBarras("22002");
        per2.setEstante(2);
        per2.setExemplares(2);
        per2.setDisponiveis(2);
        per2.setIssn(202);
        per2.setVolume(1);
        per2.setAno(2012);

        //Adicionar o livro a base de dado
        matInf.create(per);
        matInf.create(per2);

        //MATERIAL ESPECIAL 1
        MaterialEspecial especial = new MaterialEspecial();
        especial.setId(301);
        especial.setTitulo("A Vitoria do Brasil na Copa de 94");
        especial.setCodigoBarras("33001");
        especial.setEstante(3);
        especial.setExemplares(4);
        especial.setDisponiveis(4);
        especial.setDescricao("Trata-se de trabalho escolar");
        //instanciando o tipo de material especial
        TipoMaterialEspecial tipoME = new TipoMaterialEspecial();
        tipoME.setId(1);
        tipoME.setNome("DVD");
        especial.setTipoMaterialEspecial(tipoME);

        //MATERIAL ESPECIAL 2
        MaterialEspecial especial2 = new MaterialEspecial();
        especial2.setId(301);
        especial2.setTitulo("O impacto da Programação na atualidade");
        especial2.setCodigoBarras("33002");
        especial2.setEstante(3);
        especial2.setExemplares(3);
        especial2.setDisponiveis(3);
        especial2.setDescricao("Trata-se de estudo realizado por estudantes");
        //instanciando o tipo de material especial
        TipoMaterialEspecial tipoME2 = new TipoMaterialEspecial();
        tipoME2.setId(1);
        tipoME2.setNome("FITA");
        especial2.setTipoMaterialEspecial(tipoME2);

        //Adicionar o livro a base de dado
        matInf.create(especial);
        matInf.create(especial2);
        //FIM DO CADASTRAMENTO AUTOMATICO DO MATERIAL INFORMACIONAL

        do {
            op = Integer.parseInt(JOptionPane.showInputDialog("Informe a opção:"
                    + "\n1-Emprestimo de Material"
                    + "\n2-Devolução de Material"
                    + "\n3-Cadastro / Informações (Pessoa ou Material) "
                    + "\n4-Sair do Programa"));
            switch (op) {
                case 1: //Emprestimo
                    do {
                        op = Integer.parseInt(JOptionPane.showInputDialog("Menu Emprestimo:"
                                + "\n1-Listar Emprestimo"
                                + "\n2-Realizar Emprestimo"
                                + "\n3-Cancelar Emprestimo"
                                + "\n4-Sair do Menu Emprestimo"));
                        switch (op) {
                            case 1: //LISTAR EMPRESTIMOS    


                                SimpleDateFormat spf = new SimpleDateFormat("dd/MM/yyyy"); //formatad a saida da data
                               
                                for (Emprestimo e : emprestimo.findEmprestimos()) {
                                    if (e.getDataDevolucao() == null) {
                                        strEmp += "+ Nome: " + e.getPessoa().getNome() + " CPF: " + e.getPessoa().getCpf() + " Tel.: " + e.getPessoa().getTelefone()
                                        + "\n " + " CB:" + e.getMaterial().getCodigoBarras() + " Titulo: " + e.getMaterial().getTitulo()
                                        + " Autor: " + (e.getAutor() != null ? e.getAutor().getSobreNome() : " - ") + ", " + (e.getAutor() != null ? e.getAutor().getNome() : "-")
                                        + "\n " + " Data do Emprestimo: " + spf.format(e.getDataEmprestimo())+ "\n\n";
                                    }
                                }
                                if (strEmp.equals("")) {
                                    JOptionPane.showMessageDialog(null, "Não há material emprestado!");
                                } else {
                                    JOptionPane.showMessageDialog(null, strEmp);
                                }
                                strEmp = ""; //zerar a String
                                break;
                            case 2: //REALIZAR EMPRESTIMO              
                                eCpf = Long.parseLong(JOptionPane.showInputDialog("Informe o CPF da pessoa:"));
                                Pessoa retornoPessoa = pessoa.findByCpf(eCpf);
                                if (retornoPessoa != null) { //verifica se existe a pessoa (9.32)

                                    //BUSCA DO MATERIAL POR TIPO
                                    do {

                                        tipoMat = Integer.parseInt(JOptionPane.showInputDialog("Informe o tipo:"
                                                + "\n1-Livro"
                                                + "\n2-Periodico"
                                                + "\n3-Material Especial"
                                                + "\n4-Não Realizar o emprestimo"));
                                        switch (tipoMat) {
                                            case 1:
                                            case 2:
                                            case 3:
                                                if (tipoMat != 4) {//Condição para efetuar o cadastro
                                                    tipoStr = "";
                                                    for (MaterialInformacional elem : matInf.findByTipo(tipoMat)) {
                                                        tipoStr += "CB:" + elem.getCodigoBarras() + "     Título: " + elem.getTitulo()
                                                                + "          Estante: " + elem.getEstante() + "     Qtd. Exemplares: " + elem.getExemplares() + "     Qtd. Disp.: " + elem.getDisponiveis() + "\n";
                                                    }
                                                    JOptionPane.showMessageDialog(null, tipoStr); //lista todo o material disponivel

                                                    eCodigoBarras = Long.parseLong(JOptionPane.showInputDialog("Informe o codigo de barra do material:"));
                                                    MaterialInformacional retornoMaterial = matInf.findByCodigoBarras(eCodigoBarras);
                                                    if (retornoMaterial == null) {
                                                        JOptionPane.showMessageDialog(null, "Código de barras inválido, material Não Cadastrado!");
                                                    } else {

                                                        if (retornoMaterial.getDisponiveis() > 0) { //if responsavel pela verificação de exemplares disponiveis
                                                            matInf.updateQuantExemplaresDisponiveis(retornoMaterial, (retornoMaterial.getDisponiveis() - 1));

                                                            Emprestimo e = new Emprestimo(); //instancia e cria o emprestimo na lista
                                                            e = emprestimo.create(retornoPessoa, retornoMaterial, new java.util.Date()); //chama e recebe a função  ( new java.util.Date() -> guarda a data do pc)        
                                              //              i++; //incrementa o id do emprestimo    

                                                            JOptionPane.showMessageDialog(null, "Emprestimo realizado com sucesso"); //saida
                                                        } else {
                                                            JOptionPane.showMessageDialog(null, "Não existe exemplares disponiveis!");
                                                        }
                                                    } //fim do else
                                                    tipoMat = 4;
                                                } //fim do if que verifica se o usuario deseja cadastrar o material
                                                break;
                                            case 4:
                                                JOptionPane.showMessageDialog(null, "Saindo do cadastro de material");
                                                break;
                                            default:
                                                JOptionPane.showMessageDialog(null, "Opção invalida!");

                                        } //fim do switch
                                    } while (tipoMat != 4);
                                    //FIM DA BUSCA
                                } else { //Se a pessoa não existir (9.3.3)
                                    JOptionPane.showMessageDialog(null, "CPF inválido ou Pessoa Não Cadastrada!");
                                    op = 0;
                                    do {
                                        op = Integer.parseInt(JOptionPane.showInputDialog("Deseja cadastrar novo usuário?"
                                                + "\n1-Sim"
                                                + "\n2-Não"));
                                        if (op == 1) {
                                            Pessoa p5 = new Pessoa();  //Nova pessoa
                                            p5.setId(ip);
                                            p5.setNome(JOptionPane.showInputDialog("Informe o nome:"));
                                            p5.setCpf(eCpf);
                                            p5.setTelefone(JOptionPane.showInputDialog("Informe o telefone:"));
                                            pessoa.createPessoa(p5); //adiciona a lista
                                            ip++; //incrementa o id

                                            JOptionPane.showMessageDialog(null, "Cadastro realizado com sucesso!");
                                            op = 2;
                                        }
                                    } while (op != 2); //Realiz novo cadastro

                                }
                                strEmp = ""; //zerar a String
                                break;
                            case 3: //CANCELAR EMPRESTIMO
                                long cpfRet = Long.parseLong(JOptionPane.showInputDialog("Informe o cpf:"));
                                long CBarras = Long.parseLong(JOptionPane.showInputDialog("Informe o codigo de barra do material:")); //Guarda o codigo de barras

                                Emprestimo eE = emprestimo.findByIdentificador(cpfRet, CBarras);
                                if (eE != null) {
                                    matInf.updateQuantExemplaresDisponiveis(eE.getMaterial(), (eE.getMaterial().getDisponiveis() + 1));
                                    emprestimo.cancelarEmprestimo(eE.getId()); //passa o id do emprestimo e o retira da lista de emprestimo

                                    JOptionPane.showMessageDialog(null, "Cancelamento realisado com sucesso!");
                                }
                                strEmp = ""; //zerar a String
                                break;  
                            case 4: //SAIR
                                break;
                            default:
                                JOptionPane.showMessageDialog(null, "Opção invalida!");
                                break;
                        } //fim do switch op
                    } while (op != 4);
                    op = 0;
                    break;
                case 2: //MENU DAS DEVOLUÇÕES
                    do {
                        op = Integer.parseInt(JOptionPane.showInputDialog("Menu Devolução:"
                                + "\n1-Listar Devolução"
                                + "\n2-Realizar Devolução"
                                + "\n3-Sair do Menu Devolução"));
                        switch (op) {
                            case 1: //LISTA TODAS AS DEVOLUÇÕES
                                for (Emprestimo d : emprestimo.findDevolucoes()) {
                                    if (d.getDataDevolucao() != null) {
                                        strEmp += "+ Nome: " + d.getPessoa().getNome() + "     CPF: " + d.getPessoa().getCpf() + "     Tel.: " + d.getPessoa().getTelefone()
                                                + "\n " + "  CB:" + d.getMaterial().getCodigoBarras() + "      Titulo: " + d.getMaterial().getTitulo()
                                                + "        Autor: " + (d.getAutor() != null ? d.getAutor().getSobreNome() : " - ") + ", " + (d.getAutor() != null ? d.getAutor().getNome() : "-")
                                                + "\n " + "  Data do Emprestimo: " + d.getDataEmprestimo() + "  Data da Devolução: " + d.getDataDevolucao() + "\n\n";
                                    }
                                }
                                if (!strEmp.equals("")) {
                                    JOptionPane.showMessageDialog(null, strEmp);
                                } else {
                                    JOptionPane.showMessageDialog(null, "Não há material emprestado");
                                }
                                strEmp = ""; //zerar a String
                                break;
                            case 2: //REALIZA A DEVOLUÇÃO DO MATERIAL        
                                eCodigoBarras = Long.parseLong(JOptionPane.showInputDialog("Informe o codigo de barra do material:")); //Guarda o codigo de barras
                                eCpf = Long.parseLong(JOptionPane.showInputDialog("Informe o cpf:"));

                                Emprestimo e = emprestimo.findByIdentificador(eCpf, eCodigoBarras);
                                if (e != null) {
                                    if (e.getDataDevolucao() == null && e.getPessoa().getCpf() == eCpf) {
                                        if (e.getMaterial().getDisponiveis() < e.getMaterial().getExemplares()) { //vai observar o numero de exemplares disponiveis em relação ao numero de exemplares 
                                            matInf.updateQuantExemplaresDisponiveis(e.getMaterial(), (e.getMaterial().getDisponiveis() + 1)); //atualiza o numero de exemplares disp
                                            emprestimo.devolverEmprestimo(e);
                                        } else {
                                            JOptionPane.showMessageDialog(null, "Todos os exemplares estão na biblioteca.");
                                        }
                                    }
                                } else {
                                    JOptionPane.showMessageDialog(null, "Cpf não encontrado na lista dos emprestimos");
                                }
                                break;
                            case 3: //SAIR

                                break;
                            default:
                                JOptionPane.showMessageDialog(null, "Opção invalida!");
                                break;
                        } //fim do switch
                    } while (op != 3);
                    op = 0;
                    break;
                case 3: //MENU DOS CADASTROS
                    do {
                        op = Integer.parseInt(JOptionPane.showInputDialog("Menu Cadastro:"
                                + "\n1-Pessoa"
                                + "\n2-Material Informacional"
                                + "\n3-Sair do Menu Cadastro"));
                        switch (op) {
                            case 1: //Pessoa
                                do {
                                    op = Integer.parseInt(JOptionPane.showInputDialog("Menu Pessoa:"
                                            + "\n1-Listar Cadastro"
                                            + "\n2-Buscar Cadastro"
                                            + "\n3-Realizar Cadastro"
                                            + "\n4-Excluir Cadastro"
                                            + "\n5-Sair do Cadastro de Pessoa"));
                                    switch (op) {
                                        case 1: //LISTAR CADASTRO DAS PESSOAS

                                            for (Pessoa pLista : pessoa.findAll()) {
                                                str += pLista.getCpf() + "  " + pLista.getNome() + "  Tel:  " + pLista.getTelefone() + "\n";
                                            }
                                            if (!pessoa.findAll().isEmpty()) {
                                                JOptionPane.showMessageDialog(null, str);
                                            } else {
                                                JOptionPane.showMessageDialog(null, "Não há pessoa cadastrada!");
                                            }
                                            str = ""; //Prepara a String para nova consulta
                                            break;
                                        case 2: //BUSCAR CADASTRO
                                            long cpfBuscado = Long.parseLong(JOptionPane.showInputDialog("BUSCA DE PESSOA:\n Informe o CPF:"));
                                            Pessoa retPessoa = pessoa.findByCpf(cpfBuscado);
                                            if (retPessoa != null) {
                                                str = retPessoa.getCpf() + "  " + retPessoa.getNome() + " Tel:  " + retPessoa.getTelefone();
                                                JOptionPane.showMessageDialog(null, str);
                                            } else {
                                                JOptionPane.showMessageDialog(null, "Não ha pessoa cadastrada com esse CPF.");
                                            }
                                            str = ""; //Prepara a String para nova consulta
                                            break;
                                        case 3: //REALIZAR CADASTRO DE PESSOA
                                           
                                            Pessoa p4 = new Pessoa(); //Nova pessoa
                                            Pessoa retPessoa2 = new Pessoa(); //cria um obj para armazenar retorno
                                           
                                            cpfBuscado = Long.parseLong(JOptionPane.showInputDialog("Informe o CPF:"));
                                           
                                            retPessoa2 = pessoa.findByCpf(cpfBuscado);
                                         
                                            if (retPessoa2 != null) { //verifica a existencia do cadastro
                                                JOptionPane.showMessageDialog(null, "Ja existe pessoa cadastrada com esse CPF.");
                                                break;
                                            }
                                            else {
                                                p4.setCpf(cpfBuscado);
                                                p4.setId(ip);
                                                p4.setNome(JOptionPane.showInputDialog("Informe o nome:"));
                                                p4.setTelefone(JOptionPane.showInputDialog("Informe o telefone:"));
                                                pessoa.createPessoa(p4); //adiciona a lista
                                                ip++; //incrementa o id
                                                JOptionPane.showMessageDialog(null, "Cadastro realizado com sucesso!");
                                            }
                                            break;

                                        case 4: //EXCLUIR CADASTRO DE PESSOA
                                            cpfBuscado = Long.parseLong(JOptionPane.showInputDialog("REMOVER CADASTRO:\n Informe o CPF:"));
                                            pessoa.removeByCpf(cpfBuscado);
                                            break;
                                        case 5: //Sair
                                            break;
                                        default:
                                            JOptionPane.showMessageDialog(null, "Opção invalida!");
                                            break;
                                    } //fim do switch op
                                } while (op != 5);
                                op = 0;

                                break;
                            case 2: //MENU DO MATERIAL INFORMACIONAL
                                do {
                                    op = Integer.parseInt(JOptionPane.showInputDialog("CADASTRO DE MATERIAL:"
                                            + "\n1-Listar Cadastro"
                                            + "\n2-Realizar Cadastro"
                                            + "\n3-Procurar Cadastro por tipo"
                                            + "\n4-Procurar por codigo"
                                            + "\n5-Sair do Cadastro de Material"));
                                    switch (op) {
                                        case 1: //LISTAR CADASTRO DE MATERIAL INFORNCIONAL
                                            saida = "";
                                            for (MaterialInformacional elem : matInf.getMaterial()) {
                                                if (elem.getCodigoBarras().substring(0, 1).equals("1")) {
                                                    saida += "Livro: ";
                                                    saida += "CB:" + elem.getCodigoBarras() + " - " + elem.getTitulo() + " - Estante: " + elem.getEstante() + " - Qtd.Exemplares: " + elem.getExemplares() + " - Qtd.Disp.: " + elem.getDisponiveis() + "\n";
                                                } else if (elem.getCodigoBarras().substring(0, 1).equals("2")) {
                                                    saida += "Period.: ";
                                                    saida += "CB:" + elem.getCodigoBarras() + " - " + elem.getTitulo() + " - Estante: " + elem.getEstante() + " - Qtd.Exemplares: " + elem.getExemplares() + " - Qtd.Disp.: " + elem.getDisponiveis() + "\n";
                                                } else if (elem.getCodigoBarras().substring(0, 1).equals("3")) {
                                                    saida += "Mat.Esp.: ";
                                                    saida += "CB:" + elem.getCodigoBarras() + " - " + elem.getTitulo() + " - Estante: " + elem.getEstante() + " - Qtd.Exemplares: " + elem.getExemplares() + " - Qtd.Disp.: " + elem.getDisponiveis() + "\n";
                                                }
                                            }
                                            JOptionPane.showMessageDialog(null, "MATERIAL CADASTRADO:\n" + saida);
                                            break;
                                        case 2: //BUSCAR CADASTRO DE MATERIAL INFORMACIONAL
                                            int tipo = Integer.parseInt(JOptionPane.showInputDialog("Escolha o tipo:"
                                                    + "\n1-Livro"
                                                    + "\n2-Periodico"
                                                    + "\n3-Material Especial"));
                                            if (tipo == 1) {
                                                //criando obj de material informacional
                                                //LIVRO 1                                            
                                                Livro livro4 = new Livro();
                                                livro4.setId(miL);
                                                livro4.setTitulo(JOptionPane.showInputDialog("Informe o Nome do livro:"));
                                                livro4.setCodigoBarras(String.valueOf(10000 + miL)); //vai gerar o codigo de barra automatico
                                                livro4.setEstante(Integer.parseInt(JOptionPane.showInputDialog("Informe a estante(int):")));
                                                livro4.setExemplares(Integer.parseInt(JOptionPane.showInputDialog("Informe a quantidade de exemplares(int):")));
                                                livro4.setDisponiveis(livro4.getExemplares()); //Pq no ato do cadastro todos os exemplares estão disponiveis
                                                livro4.setIsbn(Integer.parseInt(JOptionPane.showInputDialog("Informe o ISBN(int):")));
                                                livro4.setAno(Integer.parseInt(JOptionPane.showInputDialog("Informe o ano(aaaa):")));
                                                livro4.setVolume(Integer.parseInt(JOptionPane.showInputDialog("Informe o volume(int):")));
                                                //Instanciando Autor
                                                Autor autor4 = new Autor();
                                                autor4.setId(miL + 10);
                                                autor4.setNome(JOptionPane.showInputDialog("Informe o 1º Nome do Autor:"));
                                                autor4.setSobreNome(JOptionPane.showInputDialog("Informe o 2º Nome do livro:"));
                                                livro4.setAutor(autor4); //add autor
                                                //instanciando Editora
                                                Editora editora4 = new Editora();
                                                editora4.setId(miL * 10);
                                                editora4.setNome(JOptionPane.showInputDialog("Informe o Nome da Editora:"));
                                                editora4.setTipo(1);
                                                livro.setEditora(editora4); //add editora

                                                //Adicionar o livro a base de dado
                                                matInf.create(livro4);
                                                miL++;

                                            } else if (tipo == 2) {
                                                //criando obj de material informacional
                                                //PERIODICO 01
                                                Periodico per3 = new Periodico();
                                                per3.setId(miP);
                                                per3.setTitulo(JOptionPane.showInputDialog("Informe o Nome do Titulo:"));
                                                per3.setCodigoBarras(String.valueOf(20000 + miP)); //vai gerar o codigo de barra automatico
                                                per3.setEstante(Integer.parseInt(JOptionPane.showInputDialog("Informe a Estante(int):")));
                                                per3.setExemplares(Integer.parseInt(JOptionPane.showInputDialog("Informe o exemplar(int):")));
                                                per3.setDisponiveis(per3.getExemplares()); //Pq no ato do cadastro todos os exemplares estão disponiveis
                                                per3.setIssn(Integer.parseInt(JOptionPane.showInputDialog("Informe o ISSN(int):")));
                                                per3.setVolume(Integer.parseInt(JOptionPane.showInputDialog("Informe o volume(int):")));
                                                per3.setAno(Integer.parseInt(JOptionPane.showInputDialog("Informe o ano(aaaa):")));

                                                //Adicionar o livro a base de dado
                                                matInf.create(per3);
                                                miP++;
                                            } else if (tipo == 3) {
                                                //criando obj de material informacional
                                                //MATERIAL ESPECIAL 1
                                                MaterialEspecial especial3 = new MaterialEspecial();
                                                especial3.setId(miE);
                                                especial3.setTitulo(JOptionPane.showInputDialog("Informe o titulo:"));
                                                especial3.setCodigoBarras(String.valueOf(30000 + miE)); //vai gerar o codigo de barra automatico
                                                especial3.setEstante(Integer.parseInt(JOptionPane.showInputDialog("Informe a estante(int):")));
                                                especial3.setExemplares(Integer.parseInt(JOptionPane.showInputDialog("Informe o numero de exemplares(int):")));
                                                especial3.setDisponiveis(especial3.getExemplares()); //Pq no ato do cadastro todos os exemplares estão disponiveis
                                                especial3.setDescricao(JOptionPane.showInputDialog("Descrição do material:"));
                                                //instanciando o tipo de material especial
                                                TipoMaterialEspecial tipoME3 = new TipoMaterialEspecial();
                                                tipoME3.setId(miE + 10);
                                                tipoME3.setNome(JOptionPane.showInputDialog("Informe o tipo do Material Especial(DVD, CD ou FITA):"));
                                                especial.setTipoMaterialEspecial(tipoME3);

                                                //Adicionar o livro a base de dado
                                                matInf.create(especial3);
                                                miE++;

                                            } else {
                                                JOptionPane.showMessageDialog(null, "Opção invalida!");
                                            }
                                            break;
                                        case 3: //Buscar Cadastro por tipo - RETORNO OK - falta formata-la apenas
                                            tipoMat = Integer.parseInt(JOptionPane.showInputDialog("Informe o tipo:"
                                                    + "\n1-Livro"
                                                    + "\n2-Periodico"
                                                    + "\n3-Material Especial"));
                                            //Trata o retorno da função que é uma lista

                                            for (MaterialInformacional elem : matInf.findByTipo(tipoMat)) {
                                                tipoStr += elem.getCodigoBarras() + " - " + elem.getTitulo()
                                                        + " Estante: " + elem.getEstante() + " - Qtd.Exemplares: " + elem.getExemplares()
                                                        + " - Qtd.Disp.: " + elem.getDisponiveis() + "\n";
                                            }
                                            JOptionPane.showMessageDialog(null, tipoStr);
                                            break;
                                        case 4: //BUSCAR MATERIAL INFORMACIONAL POR CODIGO DE BARRAS
                                            long matBuscado = Integer.parseInt(JOptionPane.showInputDialog("Informe o codigo de barras:"));

                                            //Trata o retorno da função que é uma lista
                                            MaterialInformacional matRetorno = matInf.findByCodigoBarras(matBuscado); //instanciei para receber o retorno da função

                                            String strMI = matRetorno.getCodigoBarras() + " - " + matRetorno.getTitulo() + "     Estante: "
                                                    + matRetorno.getEstante() + "    Qtd: " + matRetorno.getExemplares() + "     Disp.: " + matRetorno.getDisponiveis() + "\n";

                                            JOptionPane.showMessageDialog(null, strMI); //saida tratada
                                            break;
                                        case 5: //Sair
                                            break;
                                        default:
                                            JOptionPane.showMessageDialog(null, "Opção invalida!");
                                            break;
                                    } //fim do switch op
                                } while (op != 5);
                                op = 0;
                                break;
                            case 3: //Sair
                                break;
                            default:
                                JOptionPane.showMessageDialog(null, "Opção invalida!");
                                break;
                        } //fim do switch op
                    } while (op != 3);
                    op = 0;
                    break;
                case 4: //Sair
                    JOptionPane.showMessageDialog(null, "Fechando o Programa...");
                    break;
                default:
                    JOptionPane.showMessageDialog(null, "Opção invalida!");
                    break;
            } //fim do switch op
        } while (op != 4);
    } //fim do main
} //fim da classe