Problemas na leitura de um arquivo:

No trabalho, preciso colocar o método para leitura de arquivo no início do método main e um de gravação ao final dele.
Porém estou com problemas, porque na primeira vez ainda não existe o arquivo, então dá erro no método de leitura.
E também não sei como não sobrescrever, sem perder os dados anteriores, na hora do encerramento do programa.

Segue a classe Interface, que contém o método main:

[code]package biblioteca.iterface;

import biblioteca.;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
import java.util.
;
import java.lang.String;

/**

  • Classe Interface (interação com o usuário)
  • @author Jr Mendes
  • @version 1.0
    */

public class Interface {

/**
* @param args
* @throws ParseException
* @throws FileNotFoundException
* @throws IOException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ParseException, FileNotFoundException, IOException, ClassNotFoundException {

boolean continuar=true;
Biblioteca biblioteca = new Biblioteca();
Scanner entrada = new Scanner(System.in);

biblioteca.lerDados();

do {

   String s1,s2,s3,s4 = null;
   GregorianCalendar gc = new GregorianCalendar();      
   
   System.out.println(""); 
   System.out.println("");
   System.out.println("O que deseja fazer? ");
   System.out.println("");
   System.out.println("1- Cadastrar Usuário");
   System.out.println("2- Cadastrar Livro");
   System.out.println("3- Cadastrar Empréstimo");
   System.out.println("4- Inserir Novo Ítem Ao Empréstimo");
   System.out.println("5- Excluir Usuário");
   System.out.println("6- Excluir Livro");
   System.out.println("7- Excluir Empréstimo");
   System.out.println("8- Excluir Um Ítem De Um Empréstimo");
   System.out.println("9- Devolver Todos Os Livros de Um Empréstimo");
   System.out.println("10- Devolver Um Livro do Empréstimo");
   System.out.println("11- Pesquisar Livros Por Título");
   System.out.println("12- Pesquisar Livros Por Autor");
   System.out.println("13- Listar Todos Os Usuários");
   System.out.println("14- Listar Todos Os Livros");
   System.out.println("15- Listar Todos Os Empréstimos e Seus Ítens");
   System.out.println("0- Sair do Programa");
   System.out.println("");
   System.out.print("Digite sua opção: ");    

   /**
    * Essa parte do código irá se certificar que a opção digitada pelo usuário
    * seja um número e se certificará também da conversão da string para inteiro.
    * O uso de nextInteger() não foi realizado, pois dava erro devido ao "lixo" 
    * capturado pelo método (pulava pra receber outra entrada sem receber a anterior)
    */
   int temp = -1;  
   String s = entrada.nextLine();    
   if (!s.trim().isEmpty() && s.trim().matches("\\d+")) {    
     temp = Integer.parseInt(s.trim());       
   } 
 
     switch (temp) {
       case 1: //===================================================
               System.out.print("Digite o nome do usuário: ");
               s1=entrada.nextLine();
               System.out.print("Digite o CPF do usuário: ");
               s2=entrada.nextLine();
               System.out.print("Digite o endereço do usuário: ");
               s3=entrada.nextLine();
               System.out.print("Digite o telefone do usuário: ");
               s4=entrada.nextLine();
               Usuario usuario = new Usuario (s1,s2,s3,s4);
               biblioteca.inserirUsuario(usuario);
               System.out.print("Usuário adicionado!");
               break;
       case 2: //====================================================
               System.out.print("Digite o código do livro: ");
               s1=entrada.nextLine();
               System.out.print("Digite a quantidade de exemplares do livro: ");
               s2=entrada.nextLine();
               System.out.print("Digite o título do livro: ");
               s3=entrada.nextLine();
               System.out.print("Digite o(s) autor(es) do livro: ");
               s4=entrada.nextLine();
               Livro livro = new Livro (Integer.parseInt(s1),Integer.parseInt(s2),s3,s4);
               biblioteca.inserirLivro(livro);
               System.out.print("Livro adicionado!");
               break;             
       case 3: //====================================================
               System.out.print("Digite o nome do usuário: ");
               s1=entrada.nextLine();
               System.out.print("Digite a data de devolução: ");
               s2=entrada.nextLine();
               Emprestimo emprestimo = new Emprestimo(biblioteca.pesquisaUsuario(s1),biblioteca.stringGC(s2));
               biblioteca.inserirEmprestimo(emprestimo);
               do{
                 s3=null;
                 System.out.print("Digite o título do livro que será emprestado: ");
                 s3=entrada.nextLine();
                 itemEmprestimo item = new itemEmprestimo(biblioteca.pesquisaLivro(s3));
                 biblioteca.inserirItemEmprestimo(emprestimo,item);
                 System.out.print("Ok!");
                 System.out.print("Deseja adicionar outro livro ao empréstimo? (s ou n): ");
                 s4=entrada.nextLine();
               }while(s4.equals("s"));  
               break;
       case 5: //====================================================
               System.out.print("Digite o usuário do empréstimo correspondente: ");
               s1=entrada.nextLine();
               do{
                 s2=null;
                 System.out.print("Digite o título do livro que será emprestado: ");
                 s2=entrada.nextLine();
                 itemEmprestimo item = new itemEmprestimo(biblioteca.pesquisaLivro(s2));
                 biblioteca.inserirItemEmprestimo(biblioteca.pesquisaEmprestimo(s1),item);
                 System.out.print("Ok!");
                 System.out.print("Deseja adicionar outro livro ao empréstimo? (s ou n): ");
                 s4=entrada.nextLine();
               }while(s4.equals("s")); 
               break;
       case 6: //====================================================
               System.out.print("Digite o nome do usuário: ");
               s1=entrada.nextLine();
               biblioteca.excluirUsuario(biblioteca.pesquisaUsuario(s1));
               break;
       case 7: //====================================================
               System.out.print("Digite o título do livro: ");
               s1=entrada.nextLine();
               biblioteca.excluirLivro(biblioteca.pesquisaLivro(s1));
               break;
       case 8: //====================================================
               System.out.print("Digite o nome do usuário do qual o empréstimo será excluído: ");
               s1=entrada.nextLine();
               biblioteca.excluirEmprestimo(biblioteca.pesquisaEmprestimo(s1));
               break;
       case 9: //====================================================
               System.out.print("Digite o nome do usuário responsável pelo empréstimo: ");
               s1=entrada.nextLine();
               System.out.print("Digite o título do livro que deseja excluir do empréstimo: ");
               s2=entrada.nextLine();
               biblioteca.devolverItem(biblioteca.pesquisaEmprestimo(s1), biblioteca.pesquisaLivro(s2));
               break;
      case 10: //====================================================
               System.out.print("Digite o nome do usuário responsável pelo empréstimo a ser devolvido: ");
               s1=entrada.nextLine();
               biblioteca.devolverTodosItensEmprestimo(biblioteca.pesquisaEmprestimo(s1));
      case 11: //====================================================
               System.out.print("Digite o nome do usuário responsável pelo empréstimo a ser devolvido: ");
               s1=entrada.nextLine();
               System.out.print("Digite o título do livro que deseja devolver do empréstimo: ");
               s2=entrada.nextLine();
               ArrayList<itemEmprestimo> itensEmp = biblioteca.pesquisaEmprestimo(s1).getItens();
               for (int i=0;i<itensEmp.size()-1;i++){
                 if (biblioteca.pesquisaLivro(s2).equals(itensEmp.get(i).getLivro())){
                   biblioteca.devolverItem(biblioteca.pesquisaEmprestimo(s1),itensEmp.get(i).getLivro());    
                   System.out.print("Livro " + itensEmp.get(i).getLivro().getTitulo() + " devolvido com sucesso!" );
                 }
               }
      case 12: //====================================================
               System.out.print("Digite o título procurado: ");
               s1=entrada.nextLine();  
               biblioteca.pesquisaTitulo(s1);
               for (int i=0; i<biblioteca.pesquisaTitulo(s1).size()-1;i++){
                 System.out.println(biblioteca.pesquisaTitulo(s1).get(i).getTitulo());
               }
      case 13: //====================================================
               System.out.print("Digite o autor procurado: ");
               s1=entrada.nextLine();
               for (int i=0; i<biblioteca.pesquisaAutor(s1).size()-1;i++){
                 System.out.println(biblioteca.pesquisaAutor(s1).get(i).getAutores());
               }
      case 14: //====================================================
               for (int i=0; i<biblioteca.obterListaLivros().size()-1 ;i++){
                 System.out.println("Título: " + biblioteca.obterListaLivros().get(i).getTitulo());
                 System.out.println("Autor(es): " + biblioteca.obterListaLivros().get(i).getAutores());
                 System.out.println("Código: " + biblioteca.obterListaLivros().get(i).getCodLivro());
                 System.out.println("Quantidade de Exemplares: " + biblioteca.obterListaLivros().get(i).getQtdeExemplares());
               }
      case 15: //====================================================
               for (int i=0; i<biblioteca.obterListaEmprestimos().size()-1 ;i++){
                 System.out.println("Emprésimo Número: " + biblioteca.obterListaEmprestimos().get(i).getNumero());  
                 for (int j=0; j < biblioteca.obterListaEmprestimos().get(i).getItens().size()-1; j++){
                   System.out.println("Título: " + biblioteca.obterListaEmprestimos().get(i).getItens().get(j).getLivro().getTitulo());
                   System.out.println("Autor(es): " + biblioteca.obterListaEmprestimos().get(i).getItens().get(j).getLivro().getAutores());
                   System.out.println("Código: " + biblioteca.obterListaEmprestimos().get(i).getItens().get(j).getLivro().getCodLivro());
                   System.out.println("Quantidade de Exemplares: " + biblioteca.obterListaEmprestimos().get(i).getItens().get(j).getLivro().getQtdeExemplares());  
                 }    
               }      
       case 0:  //====================================================
                System.out.println("");
                System.out.println("Obrigado por utilizar o programa");
                System.out.println("");
                biblioteca.gravarDadados(biblioteca);
                System.out.println("Dados gravados em arquivo");
                continuar=false;
                break;
       default: //====================================================
                System.out.println("Opção inválida.");
                break; 
     }
 }while(continuar); 

}
}[/code]

Aqui os métodos de leitura e gravação:

[code] public void gravarDadados(Biblioteca biblioteca) throws FileNotFoundException, IOException{
ObjectOutputStream objetoOut = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(“Arquivo.obj”)));
objetoOut.writeObject(biblioteca);
objetoOut.close();
}
/**

  • Método para ler os dados (objetos) de um arquivo
  • @return (Biblioteca) objeto - (objeto lido, do tipo Biblioteca)
  • @throws FileNotFoundException
  • @throws IOException
  • @throws ClassNotFoundException
    */
    public Biblioteca lerDados() throws FileNotFoundException, IOException, ClassNotFoundException{
    ObjectInputStream objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream(“Arquivo.obj”)));
    Biblioteca objeto = (Biblioteca)objetoIn.readObject();
    objetoIn.close();
    return (Biblioteca) objeto;
    }[/code]

Este método retorna um objeto Biblioteca:

public Biblioteca lerDados() throws FileNotFoundException, IOException, ClassNotFoundException{  
  ObjectInputStream objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream("Arquivo.obj")));    
  Biblioteca objeto = (Biblioteca)objetoIn.readObject();    
  objetoIn.close();   
return (Biblioteca) objeto;  
}  

Então:

biblioteca.lerDados();  

Você estaria descartando o objeto retornado.

Portanto, primeiramente, vamos fazer todas as verificações para caso hajam erros na desserialização do objeto:

[code]public Biblioteca lerDados() {
ObjectInputStream objetoIn;
Biblioteca objeto = null;
try {
objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream(“Arquivo.obj”)));
Biblioteca objeto = (Biblioteca)objetoIn.readObject();
objetoIn.close();
} catch (FileNotFoundException e)
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return objeto;

} [/code] então no main:

Biblioteca biblioteca2 = biblioteca.lerDados();
if(biblioteca2 == null)
{
       //nesse caso nao existe o objeto Biblioteca serializado
}
else
{
     //caso exista o objeto, continua a execucao do programa
}

Quanto a serialização sem sobrescrever, você só pode salvar 1 objeto por arquivo, isso quer dizer que somente 1 objeto Biblioteca será serializado no “Arquivo.obj”, entretanto você pode usar estruturas como ArrayList para serializar vários objetos Biblioteca dentro de apenas 1 arquivo.

E uma dica é fazer os métodos de leitura e gravação como métodos [color=darkred]static [/color]

[quote=C. Porto]Este método retorna um objeto Biblioteca:

public Biblioteca lerDados() throws FileNotFoundException, IOException, ClassNotFoundException{  
  ObjectInputStream objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream("Arquivo.obj")));    
  Biblioteca objeto = (Biblioteca)objetoIn.readObject();    
  objetoIn.close();   
return (Biblioteca) objeto;  
}  

Então:

biblioteca.lerDados();  

Você estaria descartando o objeto retornado.

Portanto, primeiramente, vamos fazer todas as verificações para caso hajam erros na desserialização do objeto:

[code]public Biblioteca lerDados() {
ObjectInputStream objetoIn;
Biblioteca objeto = null;
try {
objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream(“Arquivo.obj”)));
Biblioteca objeto = (Biblioteca)objetoIn.readObject();
objetoIn.close();
} catch (FileNotFoundException e)
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return objeto;

} [/code] então no main:

Biblioteca biblioteca2 = biblioteca.lerDados();
if(biblioteca2 == null)
{
       //nesse caso nao existe o objeto Biblioteca serializado
}
else
{
     //caso exista o objeto, continua a execucao do programa
}

Quanto a serialização sem sobrescrever, você só pode salvar 1 objeto por arquivo, isso quer dizer que somente 1 objeto Biblioteca será serializado no “Arquivo.obj”, entretanto você pode usar estruturas como ArrayList para serializar vários objetos Biblioteca dentro de apenas 1 arquivo.

E uma dica é fazer os métodos de leitura e gravação como métodos [color=darkred]static [/color][/quote]

Primeiramente obrigado pela ajuda e me desculpem a demora para dar continuidade ao tópico.
Bom, eu reconstruí a classe lerdados como você recomendou:

public static Biblioteca lerDados(){ ObjectInputStream objetoIn; Biblioteca objeto = null; try { objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream("Arquivo.obj"))); objeto = (Biblioteca) objetoIn.readObject(); objetoIn.close(); } catch (FileNotFoundException e){ e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return (Biblioteca) objeto; }

Só alterei essa linha Biblioteca objeto = (Biblioteca) objetoIn.readObject(); porque objeto já havia sido criado acima como null.
Os “catch”, “try” e exceções ainda não entendo bem, o professor ainda não explicou essa parte, então não entendo porque recomendou mudar. E com a mudança o NetBeans faz um alerta “Rastreamento de pilha de impressão”. Gostaria que me falasse um pouco disso e das implicações práticas em mudar a leitura a gravação para static.

O resto implementei assim:

[code] Biblioteca biblioteca;

biblioteca = Biblioteca.lerDados();
if(biblioteca == null){
biblioteca = new Biblioteca();
Biblioteca.gravarDadados(biblioteca);
}

Biblioteca.lerDados(); [/code]

Se não houver o objeto ele cria e depois lê. Pode ser?

Quando a gravação, queria algo como adicionar as informações no objeto gravado, não ficar regravando ou gravando vários.

public static Biblioteca lerDados(){  
   ObjectInputStream objetoIn;    
   Biblioteca objeto = null;      
     try {    
       objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream("Arquivo.obj")));    
       objeto = (Biblioteca) objetoIn.readObject();  
       objetoIn.close();    
       } catch (FileNotFoundException e){    
           e.printStackTrace();    
       } catch (IOException e) {    
           e.printStackTrace();    
       } catch (ClassNotFoundException e) {    
           e.printStackTrace();    
       }            
      return (Biblioteca) objeto;    
}      

Ok, agora quando você lê os dados do arquivo você já faz o tratamento das exceções, seu professor não te passou ainda mas é melhor que fique assim do que “estourar” no main. A estrutura do “try{//commands//}catch(exception){//commands//}”, tem como funcionamento para o programador bem como está escrito em inglês, “tenta{//comandos//}pega(exceção){//comandos//}”, significa que os comandos utilizados dentro desses blocos tentarão executar “try{//commands//}”, caso haja algum erro o fluxo de execução do programa irá para o “catch(exception){//commands//}” dependendo de qual exceção for especificada no “catch([color=red]exception[/color]){}”, então ele executa os comandos dentro do catch.
E também tem o “finally{//comands//}” mas como não está sendo implementado não vale a pena falar agora. Agora no caso do código acima você está tentando trazer do arquivo o objeto Biblioteca e retorná-lo, e os “catchs” estão ali para pegar as exceções que podem vir a ocorrer, caso não exista o arquivo onde supostamente está guardado o objeto, solta “[color=red]FileNotFoundException[/color]”, caso haja algum erro durante a desserialização, solta “[color=red]IOException[/color]”, e caso haja algum erro durante o cast, solta “[color=red]ClassNotFoundException[/color]”, dentro de cada um desses “catchs” existe o comando que rastreia desde a origem do erro até a última linha de todo o processo em que esse comando estava envolvido (No caso do seu código ele “estouraria” no main), o “printStackTrace()”, então você pode saber de onde veio o erro, o tipo de exceção e a linha onde ocorreu a exceção.

Feito a explicação das exceções, uma coisa:

return (Biblioteca) objeto;

A linha 15 desse método lerDados(), você não precisa retornar fazendo um cast, o cast já foi feito na linha 06:

objeto = (Biblioteca) objetoIn.readObject(); 

Então você só precisa fazer isso:

return objeto;

Sobre o [color=darkred]static[/color], você percebe que no seu código antigo, para executar os métodos lerDados e gravarDados(Biblioteca b) você precisava criar uma instância da classe Biblioteca isto é:

Biblioteca exemplo = new Biblioteca();
//gravar dados
exemplo.gravarDados(/*Alguma Biblioteca*/);
//Ou entao para ler
Biblioteca outra = exemplo.lerDados();

Ou seja você acaba criando uma instância para apenas ler e gravar dados de outras instâncias. Pense bem, as operações para serialização e desserialização de objetos são métodos que cada objeto Biblioteca deve ter?
Ou são métodos que independente do objeto existem, é óbvio que esses métodos são utilizados para manipular os objetos Biblioteca, mas eles não necessitam estar vinculados em todos os objetos, mas sim numa representação onde eles façam parte da classe Biblioteca mas não dos objetos, então utilizamos [color=darkred]static[/color], agora os métodos serão invocados assim:

//ler dados
Biblioteca exemplo = Biblioteca.lerDados(); //invocaçao de um metodo static, invoca direto da classe, le do arquivo e retorna um objeto Biblioteca
//gravar dados
Biblioteca.gravarDados(exemplo);//invocaçao de um metodo static, invoca direto da classe, grava no arquivo um objeto Biblioteca

Então são métodos que pertencem somente à classe, no exemplo acima estou chamando os métodos direto da classe Biblioteca.
Neste caso você estaria economizando algumas linhas, memória e seguindo padrões de programação.

Agora, quanto à essa parte do código:

Biblioteca biblioteca;    
    
  biblioteca = Biblioteca.lerDados();    
  if(biblioteca == null){    
    biblioteca = new Biblioteca();    
    Biblioteca.gravarDadados(biblioteca);    
   }    
       
  Biblioteca.lerDados();    

Caso não haja um objeto gravado no arquivo, penso eu que não há necessidade de gravá-lo e depois lê-lo, você simplesmente deve criar um novo objeto, e deixar que o encerramento do programa se encarregue de gravá-lo no arquivo:

Biblioteca b = Biblioteca.lerDados();
if(b == null)
   b = new Biblioteca();
//continua execucao normal do programa

Não sei como funciona quanto à questão das informações que a classe Biblioteca manipula, mas caso o usuário faça operações de consulta nela (caso a leitura do arquivo tenha retornado um objeto Biblioteca [color=blue]null[/color]), você deve retornar alguma coisa como: “Livro não cadastrado.” ou “Cliente não cadastrado”, já que é um objeto que acabou de ser instanciado.
Mas novamente não sei como funciona por dentro desta classe.

Agora última coisa, quanto à serialização, o objeto que acabou de ser gravado no arquivo irá sobrescrever um outro objeto que já se encontra no arquivo, mas no seu caso você provavelmente está trabalhando com apenas uma Biblioteca, então a informação que o objeto Biblioteca possuir, estará sempre com ele, caso seja mais de uma Biblioteca, sugiro utilizar as estruturas como ArrayList ou então criar mais arquivos para serializar os objetos (O que na verdade não recomendo).
Não tem como adicionar informações no objeto gravado, você desserializa ele, grava as informações, e serializa novamente.

[quote=C. Porto] public static Biblioteca lerDados(){ ObjectInputStream objetoIn; Biblioteca objeto = null; try { objetoIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream("Arquivo.obj"))); objeto = (Biblioteca) objetoIn.readObject(); objetoIn.close(); } catch (FileNotFoundException e){ e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return (Biblioteca) objeto; }

Ok, agora quando você lê os dados do arquivo você já faz o tratamento das exceções, seu professor não te passou ainda mas é melhor que fique assim do que “estourar” no main. A estrutura do “try{//commands//}catch(exception){//commands//}”, tem como funcionamento para o programador bem como está escrito em inglês, “tenta{//comandos//}pega(exceção){//comandos//}”, significa que os comandos utilizados dentro desses blocos tentarão executar “try{//commands//}”, caso haja algum erro o fluxo de execução do programa irá para o “catch(exception){//commands//}” dependendo de qual exceção for especificada no “catch([color=red]exception[/color]){}”, então ele executa os comandos dentro do catch.
E também tem o “finally{//comands//}” mas como não está sendo implementado não vale a pena falar agora. Agora no caso do código acima você está tentando trazer do arquivo o objeto Biblioteca e retorná-lo, e os “catchs” estão ali para pegar as exceções que podem vir a ocorrer, caso não exista o arquivo onde supostamente está guardado o objeto, solta “[color=red]FileNotFoundException[/color]”, caso haja algum erro durante a desserialização, solta “[color=red]IOException[/color]”, e caso haja algum erro durante o cast, solta “[color=red]ClassNotFoundException[/color]”, dentro de cada um desses “catchs” existe o comando que rastreia desde a origem do erro até a última linha de todo o processo em que esse comando estava envolvido (No caso do seu código ele “estouraria” no main), o “printStackTrace()”, então você pode saber de onde veio o erro, o tipo de exceção e a linha onde ocorreu a exceção.

Feito a explicação das exceções, uma coisa:

return (Biblioteca) objeto;

A linha 15 desse método lerDados(), você não precisa retornar fazendo um cast, o cast já foi feito na linha 06:

objeto = (Biblioteca) objetoIn.readObject(); 

Então você só precisa fazer isso:

return objeto;

Sobre o [color=darkred]static[/color], você percebe que no seu código antigo, para executar os métodos lerDados e gravarDados(Biblioteca b) você precisava criar uma instância da classe Biblioteca isto é:

Biblioteca exemplo = new Biblioteca();
//gravar dados
exemplo.gravarDados(/*Alguma Biblioteca*/);
//Ou entao para ler
Biblioteca outra = exemplo.lerDados();

Ou seja você acaba criando uma instância para apenas ler e gravar dados de outras instâncias. Pense bem, as operações para serialização e desserialização de objetos são métodos que cada objeto Biblioteca deve ter?
Ou são métodos que independente do objeto existem, é óbvio que esses métodos são utilizados para manipular os objetos Biblioteca, mas eles não necessitam estar vinculados em todos os objetos, mas sim numa representação onde eles façam parte da classe Biblioteca mas não dos objetos, então utilizamos [color=darkred]static[/color], agora os métodos serão invocados assim:

//ler dados
Biblioteca exemplo = Biblioteca.lerDados(); //invocaçao de um metodo static, invoca direto da classe, le do arquivo e retorna um objeto Biblioteca
//gravar dados
Biblioteca.gravarDados(exemplo);//invocaçao de um metodo static, invoca direto da classe, grava no arquivo um objeto Biblioteca

Então são métodos que pertencem somente à classe, no exemplo acima estou chamando os métodos direto da classe Biblioteca.
Neste caso você estaria economizando algumas linhas, memória e seguindo padrões de programação.

Agora, quanto à essa parte do código:

Biblioteca biblioteca;    
    
  biblioteca = Biblioteca.lerDados();    
  if(biblioteca == null){    
    biblioteca = new Biblioteca();    
    Biblioteca.gravarDadados(biblioteca);    
   }    
       
  Biblioteca.lerDados();    

Caso não haja um objeto gravado no arquivo, penso eu que não há necessidade de gravá-lo e depois lê-lo, você simplesmente deve criar um novo objeto, e deixar que o encerramento do programa se encarregue de gravá-lo no arquivo:

Biblioteca b = Biblioteca.lerDados();
if(b == null)
   b = new Biblioteca();
//continua execucao normal do programa

Não sei como funciona quanto à questão das informações que a classe Biblioteca manipula, mas caso o usuário faça operações de consulta nela (caso a leitura do arquivo tenha retornado um objeto Biblioteca [color=blue]null[/color]), você deve retornar alguma coisa como: “Livro não cadastrado.” ou “Cliente não cadastrado”, já que é um objeto que acabou de ser instanciado.
Mas novamente não sei como funciona por dentro desta classe.

Agora última coisa, quanto à serialização, o objeto que acabou de ser gravado no arquivo irá sobrescrever um outro objeto que já se encontra no arquivo, mas no seu caso você provavelmente está trabalhando com apenas uma Biblioteca, então a informação que o objeto Biblioteca possuir, estará sempre com ele, caso seja mais de uma Biblioteca, sugiro utilizar as estruturas como ArrayList ou então criar mais arquivos para serializar os objetos (O que na verdade não recomendo).
Não tem como adicionar informações no objeto gravado, você desserializa ele, grava as informações, e serializa novamente.[/quote]

Muito obrigado pela ajuda. Fiz os ajustes que recomendou aqui. Infelizmente o programa deu algumas falhas no restante do código e não vai dar tempo de corrigir antes do prazo máximo de envio para o professor. Mas você me ajudou bastante. Obrigado mesmo.

Na hora de gravar tá dando isso aí:

Exception in thread "main" java.io.NotSerializableException: biblioteca.Usuario at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1164) at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:330) at java.util.ArrayList.writeObject(ArrayList.java:570) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at java.io.ObjectStreamClass.invokeWriteObject(ObjectStreamClass.java:945) at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1469) at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400) at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158) at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1518) at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1483) at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400) at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158) at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:330) at biblioteca.Biblioteca.gravarDadados(Biblioteca.java:250) at biblioteca.iterface.Interface.main(Interface.java:224) Java Result: 1

E se eu deixar mandando imprimir nos catch (o netbeans manda tirar os print) ele imprime isso:

[code]run:
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2280)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2749)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:779)
at java.io.ObjectInputStream.(ObjectInputStream.java:279)
at biblioteca.Biblioteca.lerDados(Biblioteca.java:264)
at biblioteca.iterface.Interface.main(Interface.java:31)
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2280)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2749)

at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:779)

O que deseja fazer?

1- Cadastrar Usuário
at java.io.ObjectInputStream.(ObjectInputStream.java:279)
at biblioteca.Biblioteca.lerDados(Biblioteca.java:264)
2- Cadastrar Livro
3- Cadastrar Empréstimo
at biblioteca.iterface.Interface.main(Interface.java:36)
4- Inserir Novo Ítem Ao Empréstimo
5- Excluir Usuário
6- Excluir Livro
7- Excluir Empréstimo
8- Excluir Um Ítem De Um Empréstimo
9- Devolver Todos Os Livros de Um Empréstimo
10- Devolver Um Livro do Empréstimo
11- Pesquisar Livros Por Título
12- Pesquisar Livros Por Autor
13- Listar Todos Os Usuários
14- Listar Todos Os Livros
15- Listar Todos Os Empréstimos e Seus Ítens
0- Sair do Programa

Digite sua opção: [/code]

O problema dessa vez é que você implementou a interface Serializable na classe Biblioteca mas não implementou na classe Usuario, como provavelmente você está utilizando Usuario dentro da classe Biblioteca, o processo tenta serializar a biblioteca mas não consegue, use:

public class Usuario implements Serializable

Isso vale obviamente para qualquer outra classe que você tenha codificado e que esteja sendo utilizada dentro da classe Biblioteca.

[quote=C. Porto]O problema dessa vez é que você implementou a interface Serializable na classe Biblioteca mas não implementou na classe Usuario, como provavelmente você está utilizando Usuario dentro da classe Biblioteca, o processo tenta serializar a biblioteca mas não consegue, use:

public class Usuario implements Serializable

Isso vale obviamente para qualquer outra classe que você tenha codificado e que esteja sendo utilizada dentro da classe Biblioteca.[/quote]

Cara, eu fiz um tray, igual o do método de ler o arquivo e parou de apresentar esses problemas (mas acho que só ficaram “mascarados”). Daí enviei para o professor.
Via sua mensagem agora pouco e saí correndo e implementei serializable em todas as outras classes (pensei que não era necessário, já que vai gravar arquivos só do tipo biblioteca). Enviei o novo arquivo depois de 3min do prazo final que o professor deu. Mandei também um e-mail pra ele explicando a situação. Acho que vai aceitar numa boa.

Você realmente me ajudou muito. Muitíssimo obrigado.