Mensajes

Pues te respondo ahora

Siento no haberlo hecho antes, me he dejado las pestañas en este trabajo, que tengo los exámenes el lunes y soy un despiste con patas en todo lo demás.

Comentarte que lo hice y lo entregué en primera instancia trabajando con archivo de texto plano tal y como me explicabas en el post y volví a hacerlo trabajando con objetos directamente que al final me pareció más adecuado.

Sea como sea, tus orientaciones iniciales me llevaron por el buen camino, que andaba más perdido que un elefante en una cristalería.

Un saludo.

Ejercicio resuelto.

Muchas gracias.

He puesto los códigos en este otro post.

http://foro.elhacker.net/ejercicios/ejercicio_resuelto_gracias_por_la_ayuda-t411089.0.html

Recientemente pedí ayuda en el lugar equivocado de este foro.

Gracias a la ayuda y los buenos consejos recibidos no solo he aprendido un montón si no que además me han puesto una buena nota

Inicialmente empecé trabajando con un fichero de texto plano, pero me pareció un sistema muy farragoso y opté por trabajar con objetos directamente.
Pego el enlace al post original y los códigos del programa por si a alguien le valen de algo.

Muchas gracias.

http://foro.elhacker.net/java/ayuda_con_un_ejercicio_grabar_datos_en_un_fichero_secuencial_de_texto-t410283.0.html

Clase Principal:

Código [Seleccionar] Expandir

public class Tarea6_3 implements java.io.Serializable {
    //Se implementa la interfaz serializable para que el objeto Cliente pueda
    //escribir todos sus datos en fichero.

    /**
     * @param args the command line arguments
     * @throws java.lang.Exception
     */
    public static void main(String[] args) throws Exception {

        /**
         * Menú
         * Presenta el menú de operaciones con todas las opciones disponibles
         */
        int opcion = 0;
        do{
            try{
                opcion = Integer.parseInt(Menu()); // Mostramos el menu
                }
            catch (NumberFormatException nfe){
                System.out.println(nfe.getMessage());
                opcion = 10;
            }
        switch (opcion){
        case 0://Salir del menú
        break;
           
        case 1: //Añadir cliente
            //Creamos un nuevo objeto cliente de la clase Clientes
            Clientes cliente = new  Clientes(Clientes.setNombre(),
                                    Clientes.setNif(),
                                    Clientes.setTlf(),
                                    Clientes.setDireccion(),
                                    Clientes.setDeuda());
            //Llamada al método guardarEnArchivo.
            Archivo.guardarClienteEnArchivo("clientes.dat", cliente);
        break;
                       
        case 2: //Listar clientes
            Archivo.listarClientes();
        break;

        case 3: //Buscar clientes.
            Archivo.buscarCliente();
        break;
           
           
        case 4://Borrar cliente
            Archivo.borrarCliente();
        break;

        case 5://Borrar fichero de clientes. Ojo que no hay vuelta atrás.
            Archivo.borrarClientesDat();
        break;

        default:
        System.out.println("Introduzca un valor entre 0 y 6");
        }
    }while (opcion !=0);
  }

    /**
     * menu()
     * Menú de selección. Presenta el menú de opciones
     * @return opcion
     */
    public static String Menu() {
        System.out.println("Men\u00fa");
        System.out.println("-------------------------------");
        System.out.println("1 - A\u00f1adir cliente");
        System.out.println("2 - Listar clientes");
        System.out.println("3 - Buscar cliente");
        System.out.println("4 - Borrar cliente");
        System.out.println("5 - Borrar fichero clientes.dat");
        System.out.println("0 - Salir");
        System.out.println("-------------------------------");
        String opcion = Archivo.sc.next();
        return opcion;
    }
}


Clase Archivo.

Código [Seleccionar] Expandir

package tarea6_3;

import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* Recoge todos los métodos necesarios para manipular el archivo clientes.dat
* @author adec29
*/
public class Archivo implements java.io.Serializable {
    //Inicializo los miembros de clase.
    private static FileOutputStream fos;
    private static ObjectOutputStream salida;
    private static FileInputStream fis;
    private static ObjectInputStream entrada;
    final static String temporal = "temporal.dat";
    final static String archivo = "clientes.dat";
    static Scanner sc=new Scanner(System.in); //Para leer de teclado
    static boolean check;// para hacer comprobaciones
   
    /**
     * Comprueba si clientes.dat tiene registros
     * @return check
     */
    private static boolean tieneRegistros(){
        //Inicialmente presuponemos que no tenemos registros en clientes.dat
        check = false ;
        Clientes cliente = null ;

        try {
            //Abrimos el archivo para lectur.
            fis = new FileInputStream(archivo);
            entrada = new ObjectInputStream(fis);
            // Lee el primer objeto del fichero
            cliente = (Clientes) entrada.readObject();
            //Hacemos la comprobación.
            if (cliente != null){ //Si el objeto cliente tiene algo.
                check = true ;    //tieneRegistros() devuelve true
            }

        } catch (FileNotFoundException  e) {
            System.out.println( "Fichero no encontrado en tieneRegistros()"+e ) ;
        } catch (IOException | ClassNotFoundException ex) {
            System.out.println( "Capturada excepción en tieneRegistros()"+ex ) ;
        }

        return(check) ;
    }   
   
    /**
     * Lee los clientes de clientes.dat
     * @throws java.io.IOException
     */
    public static void listarClientes () throws IOException {
        //Preparamos un objeto de la clase Cliente para poder mostrar su
        //contenido cuando leamos.
        Clientes cliente = null;
       
        try {
            //Como vamos a listar solamente, no vamos a modificar nada, abrimos
            //clientes.dat en modo lectura.
            fis = new FileInputStream(archivo);
            entrada = new ObjectInputStream(fis);
            //Comprobamos que hay algo en el flujo de datos fis
            if (fis != null){
                do{
                //Leemos el primer objeto cliente a través del buffer "entrada"
                //que antes vinculamos al flujo de datos "fis" que lee el
                //archivo clientes.dat
                cliente = (Clientes) entrada.readObject();
                            System.out.println(
                             cliente.getNombre()+" "
                            +cliente.getNif()+" "
                            +cliente.getDireccion()+" "
                            +cliente.getTlf()+" "
                            +cliente.getDeuda());
                //Pero esto sólo lee el primer cliente, si queremos leerlos
                //todos habrá que repetir hasta llegar al último.                           
                }while (cliente != null);
            }   //Cerramos el archivo.
                fis.close();
                entrada.close();
        } catch (EOFException eof) {
            System.out.println("¡Fin del fichero!");
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Archivo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
   
    /**
     * Nos posibilita la escritura de un nuevo registro en clientes.dat
     * @param archivo
     * @param cliente
     */
    public static void guardarClienteEnArchivo(String archivo,
                                                Clientes cliente) {
        try {
            //Creamos un fujo de salida hacia clientes.dat
            fos = new FileOutputStream(archivo, true);
            if (tieneRegistros() == true){
                //Si clientes.dat YA tiene registros.
                //El fujo ObjectOutputStream es el que procesa los datos de
                //salida y se ha de vincular a un objeto de la clase
                //FileOutputStream.(Serializar)
                salida = new MiObjectOutputStream (fos);
                ////////////////////////////////////////////////////////////////
                // ¿Por qué usamos MiObjectOutputStream?                      //
                // Visita esta página. Muy bien explicado.
                // http://www.chuidiang.com/java/ficheros/ObjetosFichero.php  //
                ////////////////////////////////////////////////////////////////               
            }
            else {
                //Si no tiene registros uso la clase ObjectOutputStream para
                //escribir la cabecera y el PRIMER registro
                salida = new ObjectOutputStream (fos);
            }     
            //Grabar cliente
            if (fos != null) {salida.writeObject(cliente);}
            //Cerrar archivo.
            fos.close();
            salida.close();
          //Captura de excepciones.
        } catch (IOException ex) {
            System.out.println("Excepción capturada en guardarClienteEnArchivo"
                    +ex.getMessage());
        }
    }

    /**
     * Nos permite buscar un cliente a través de su dni
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void buscarCliente() throws IOException,
                                              ClassNotFoundException {
        //Preparamos un objeto de la clase Cliente para poder mostrar su
        //contenido cuando leamos.
        Clientes cliente = null;
        //Preguntamos por el nif a buscar.
        String buscado = Clientes.setNif();
        try {
            //Como vamos a buscar solamente, no vamos a modificar nada, abrimos
            //clientes.dat en modo lectura.
            fis = new FileInputStream(archivo);
            entrada = new ObjectInputStream(fis);
            //Comprobamos que hay algo en el flujo de datos fis
            if (fis != null){
                do{
                //Leemos el primer objeto cliente a través del buffer "entrada"
                //que antes vinculamos al flujo de datos "fis" que lee el
                //archivo clientes.dat
                cliente = (Clientes) entrada.readObject();
                //Preguntamos por el cliente a buscar.
                String encontrado = cliente.getNif();
                //Comparamos buscado y encontrado
                if (buscado.equals(encontrado)){
                    System.out.println("Encontrado cliente."+
                            "\nNombre: "+cliente.getNombre()+
                            "\nNif: "+cliente.getNif()+
                            "\nDirección: "+cliente.getDireccion()+
                            "\nTlf: "+cliente.getTlf()+
                            "\nDeuda: "+cliente.getDeuda());
                }
                //Pero esto sólo lee el primer cliente, si queremos leerlos
                //todos habrá que repetir hasta llegar al último.
                }while (cliente != null);
                //Cerramos Archivo
                fis.close();
                entrada.close();
            }
        } catch (EOFException eof) {
            //No hagas nada
        } catch (ClassNotFoundException ex) {
            System.out.println(ex.getMessage());
        }
        //Informamos del fin de la búsqueda
        System.out.println("Búsqueda finalizada.");
    }

    /**
     * Borra un cliente que buscamos a través de su nif tantas veces como lo
     * encuentre dentro del fichero clientes.dat
     * Para ello creamos un fichero temporal.dat que guarda los clientes
     * que vamos leyendo excepto aquellos cuyo nif coincida con el buscaco.
     * Posteriormente renombramos clientes.dat a clientes.bak y renombramos
     * temporal.dat a clientes.dat.
     * Después borramos temporal.dat
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void borrarCliente() throws IOException,
                ClassNotFoundException {
        //Preparamos un objeto de la clase Cliente para poder comparar su
        //contenido cuando leamos.
        Clientes cliente = null;
        //Preguntamos por el nif del cliente a borrar.
        String buscado = Clientes.setNif();
        try {
            //Vamos a buscar. Abrimos clientes.dat en modo LECTURA
            fis = new FileInputStream(archivo);
            entrada = new ObjectInputStream(fis);
            //Comprobamos que hay algo en el flujo de datos fis
            if (fis != null){
                do{
                //Leemos el primer objeto cliente a través del buffer "entrada"
                //que antes vinculamos al flujo de datos "fis" que lee el
                //archivo clientes.dat
                cliente = (Clientes) entrada.readObject();
                //Preguntamos por el nif del objeto cliente leido.
                String encontrado = cliente.getNif();
                //Comparamos buscado y encontrado
                if (buscado.equals(encontrado)){
                    System.out.println("Eliminado cliente."+
                            "\nNombre: "+cliente.getNombre()+
                            "\nNif: "+cliente.getNif()+
                            "\nDirección: "+cliente.getDireccion()+
                            "\nTlf: "+cliente.getTlf()+
                            "\nDeuda: "+cliente.getDeuda());
                }else {
                    Temporal.guardarClienteEnArchivoTemporal(temporal, cliente);
                }
                //Pero esto sólo lee el primer cliente, si queremos leerlos
                //todos habrá que repetir hasta llegar al último.
                }while (cliente != null);
                //Cerramos archivo.
                fis.close();
                entrada.close();;
            }
        } catch (EOFException eof) {
            //No hagas nada
        } catch (ClassNotFoundException ex) {
            System.out.println(ex.getMessage());
        }
        //Informamos del fin de la búsqueda
        System.out.println("Búsqueda finalizada.");
        //Renombramos, copiamos y borramos.
        //Creamos tres abstracciones usando la clase File
        File clientesDat = new File ("clientes.dat");
        File clientesBak = new File ("clientes.bak");
        File temp = new File ("temporal.dat");
        try {
            //Renombramos y comprobamos.
            check = clientesDat.renameTo(clientesBak);
            if (check) {
                System.out.println("clientes.dat renombrado a clientes.bak");
            } else {
                System.out.println("El renombrado no se ha podido realizar");
            }
            //Renombramos y comprobamos.
            check = temp.renameTo(clientesDat);
            if (check) {
                System.out.println("temporal.dat renombrado a clientes.dat");
            } else {
                System.out.println("El renombrado no se ha podido realizar");
            }
            //Borramos los clientes.bak que ya no lo necesitamos.
            check = clientesBak.delete();
            if (check) {
                System.out.println("clientes.bak borrado");
            } else {
                System.out.println("El borrado no se ha podido realizar");
            }
        } catch (Exception e) {
                        System.out.println(e.getMessage());

        }
    }
   
    /**
     * Borra el archivo clientes.dat
     */
    public static void borrarClientesDat(){
        //Instanciamos clientesDat la clase File y le pasamos el nombre del
        //fichero con el que vamos a trabajar
        File clientesDat = new File ("clientes.dat");
        //Para borrar el fichero deberemos de invocar el método .delete()
        //de la clase File. En caso de que se pueda realizar el borrado del
        //fichero, dicho método devolverá true.
        //En caso contrario devolverá false.
try {
            if (clientesDat.delete())//true
            {
                System.out.println("Fichero borrado con éxito");
            } else //false
            {
                System.out.println("No se ha podido borrar el fichero");
            }
        } catch (Exception e) {
                        System.out.println(e.getMessage());
        }
    }
}

Clase Cliente:

Código [Seleccionar] Expandir

import java.util.Scanner;

/**
*
* @author adec29
*/
public class Clientes implements java.io.Serializable {
   
    //Inicializo los miembros de clase.
    static Scanner teclado=new Scanner(System.in); //Para leer de teclado
    static boolean check;// Para hacer comprobaciones
    //Inicializo atributos de clase
    private String nif; //Nif del cliente
    private String nombre; //Nombre del cliente
    private String telefono; // Teléfono del cliente
    private String direccion; // Dirección del cliente
    private String deuda; //Deuda del dliente

   
    /**
     * Constructor de la clase
     * Los datos son comprobados dentro del método que los crea
     * @param nombre
     * @param nif
     * @param telefono
     * @param direccion
     * @param deuda
     * @throws Exception
     */
       
    public Clientes(String nombre, String nif, String telefono,
                          String direccion, String deuda) throws Exception {
      Archivo.check = false;
      this.nombre = nombre;
      this.nif = nif;
      this.telefono = telefono;
      this.direccion = direccion;
      this.deuda = deuda;
  }
   
// Métodos set y get
   
     /**
     * setNombre()
     * @return nombre
     * Nos permite establecer el nombre del cliente. Verifica que el nombre
     * introducido es correcto siempre y cuando la longitud del String nombre
     * se halle entre 3 y 40 caracteres.
     */
    public static String setNombre(){
        String nombre = "x";
        do{
            System.out.println("Introduce el nombre del cliente (3-40 caracteres):");
            nombre = teclado.nextLine();
            if ((nombre.length() < 3) || (nombre.length() > 40))
                System.out.println("El nombre debe tener entre 3 y 40 caracteres");
            }
        while ((nombre.length() < 3) || (nombre.length() > 40));
        return nombre;
        }
   
     /**
     * setNif()
     * @return nif
     * Nos permite establecer el nif del cliente. Voy a dar por correcto una
     * cadena de 9 caracteres
     */
    public static String setNif(){
        String nif = "x";
        do{
            System.out.println("Introduce el nif del cliente (9 caracteres):");
            nif = teclado.nextLine();
            if ((nif.length() < 9) || (nif.length() > 9))
                System.out.println("El nif debe tener 9 caracteres");
            }
        while ((nif.length() < 9) || (nif.length() > 9));
        return nif;
        }
   
    /**
     * setTlf()
     * @return tlf
     * Nos permite establecer el teléfono del cliente. Voy a dar por correcto una
     * cadena de 9 caracteres
     */
    public static String setTlf(){
        String tlf = "x";
        do{
            System.out.println("Introduce el teléfono del cliente (9 caracteres):");
            tlf = teclado.nextLine();
            if ((tlf.length() < 9) || (tlf.length() > 9))
                System.out.println("El teléfono debe tener 9 caracteres");
            }
        while ((tlf.length() < 9) || (tlf.length() > 9));
        return tlf;
        }
   
     /**
     * setDireccion()
     * @return dir
     * Nos permite establecer la dirección del cliente. Asume que la dirección
     * introducida es correcta siempre y cuando la longitud del String dir
     * se halle entre 3 y 40 caracteres.
     */
    public static String setDireccion(){
        String dir = "x";
        do{
            System.out.println("Introduce la dirección cliente (10-50 caracteres):");
            dir = teclado.nextLine();
            if ((dir.length() < 3) || (dir.length() > 40))
                System.out.println("El nombre debe tener entre 10 y 50 caracteres");
            }
        while ((dir.length() < 10) || (dir.length() > 50));
        return dir;
        }
   
    /**
     * setDeuda
     * Nos permite establecer la cantidad que debe el cliente
     * @return deuda
     */
    public static String setDeuda() {
    String deuda;
    System.out.println("Indique la cantidad adeudada por el cliente: ");
    deuda = teclado.next();
    return deuda;
       
  }
   
    /**
     * getNif
     * Nos devuelve el nif del cliente
     * @return nif
     */
    public String getNif() {
        return nif;
    }

    /**
     * getNombre
     * Nos devuelve el nombre del cliente
     * @return nombre
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * getTlf
     * Nos devuelve el teléfono del cliente
     * @return teléfono
     */
    public String getTlf() {
        return telefono;
    }

    /**
     * getDireccion
     * Nos devuelve la dirección del cliente
     * @return direccion
     */
    public String getDireccion() {
        return direccion;
    }

    /**
     * getDeuda
     * Nos devuelve la deuda que tiene el cliente
     * @return deuda
     */
    public String getDeuda() {
        return deuda;
    }
}

Clase temporal:

Código [Seleccionar] Expandir

public class Temporal implements java.io.Serializable {
   
    private static FileInputStream fistemp;
    static final String temporal = "temporal.dat";
    private static ObjectInputStream entradatemp;
    private static ObjectOutputStream salidatemp;
    private static FileOutputStream fostemp;
    private static boolean tempcheck;

    /**
     * Nos posibilita la escritura de un nuevo registro en temporal.dat
     * @param temporal
     * @param cliente
     */
    public static void guardarClienteEnArchivoTemporal(String temporal,
                                                       Clientes cliente) {
        try {
            fostemp = new FileOutputStream(temporal, true);
            if (tieneRegistrosTemporal() == true) {
                salidatemp = new MiObjectOutputStream(fostemp);
            } else {
                salidatemp = new ObjectOutputStream(fostemp);
            }
              if (fostemp != null) {
                salidatemp.writeObject(cliente);
            }
            fostemp.close();
            salidatemp.close();
        } catch (IOException ex) {
            System.out.println("Excepci\u00f3n capturada en "
                    + "guardarClienteEnArchivo" + ex.getMessage());
        }
    }

     /**
     * Comprueba si temporal.dat tiene registros.
     */
    private static boolean tieneRegistrosTemporal() {
        tempcheck = false;
        Clientes cliente = null;
        try {
            fistemp = new FileInputStream(temporal);
            entradatemp = new ObjectInputStream(fistemp);
            cliente = (Clientes) entradatemp.readObject();
            if (cliente != null) {
                tempcheck = true;
            }
        } catch (FileNotFoundException e) {
            System.out.println("Fichero no encontrado en "
                    + "tieneRegistrosTemporal()" + e);
        } catch (IOException | ClassNotFoundException ex) {
            //no hagas nada
        }
        return tempcheck;
    }
}

Y por último, la solución a todos los problemas que tenía.
cito fuente:
http://www.chuidiang.com/java/ficheros/ObjetosFichero.php

y pego clase:

Código [Seleccionar] Expandir

public class MiObjectOutputStream extends ObjectOutputStream
{
   
    public MiObjectOutputStream(OutputStream out) throws IOException
    {
        super(out);
    }

   
    protected MiObjectOutputStream() throws IOException, SecurityException
    {
        super();
    }

   
    @Override
    protected void writeStreamHeader() throws IOException
    {
    }

}

¡Vaya!

Pues sí que es listo Scanner sí.

Gracias por la respuesta  y un saludo.

Saludos a tod@s.

Me pasa algo que no soy capaz de entender.

Código [Seleccionar] Expandir

package javaya2.pkg1;

import java.util.Scanner;

/**
* Hallar la superficie de un cuadrado conociendo el valor de un lado.
* @author droigor
*/
public class Javaya21 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       
        //Declaraciones
        float lado;
        float superficie;
        Scanner sc = new Scanner(System.in);
       
        //Proceso
        System.out.println("Introduzca el lado del cuadrado:");
        lado = sc.nextFloat();
       
        //Resultado
        superficie = lado * lado;
        System.out.println("La superficie del cuadrado de lado "
                +lado+" es de "+superficie);
       
    }
   
}

Ejecuto el programa, introduzco cualquier número que no sea un entero y me pasa esto :

run:
Introduzca el lado del cuadrado:
2.0
Exception in thread "main" java.util.InputMismatchException
   at java.util.Scanner.throwFor(Scanner.java:909)
   at java.util.Scanner.next(Scanner.java:1530)
   at java.util.Scanner.nextFloat(Scanner.java:2388)
   at javaya2.pkg1.Javaya21.main(Javaya21.java:29)
Java Result: 1
BUILD SUCCESSFUL (total time: 1 second)

Soy un melón o le pasa algo a mi IDE?

Gracias.

Muchas gracias.

Me pongo a ello ahora mismo, a ver que tal.

Un saludo.

Perdón por haber colocado esto aquí. No se como moverlo al foro de ejercicios.

Un saludo.

Lo primero un saludo. Soy nuevo en estos foros y nuevo también en la poo
De ahí el lio tremendo que tengo con un ejercicio de clase que nos han mandado.

Pego el enunciado y comento cual es el problema.

Se trata de hacer una aplicación en Java que gestione los clientes de una empresa. Esos datos, se almacenarán en un fichero serializado, denominado clientes.dat.

Los datos que se almacenarán sobre cada cliente son:

   NIF.
   Nombre.
   Teléfono.
   Dirección.
   Deuda.

Mediante un menú se podrán realizar determinadas operaciones:

   Añadir cliente. Esta opción pedirá los datos del cliente y añadirá el registro correspondiente en el fichero.
   Listar clientes. Recorrerá el fichero mostrando los clientes almacenados en el mismo.
   Buscar clientes. Pedirá al usuario el nif del cliente a buscar, y comprobará si existe en el fichero.
   Borrar cliente. Pedirá al usuario el nif del cliente a borrar, y si existe, lo borrará del fichero.
   Borrar fichero de clientes completamente. Elimina del disco el fichero clientes.dat
   Salir de la aplicación.


Bueno, pues el problema es que tras clear la clase y el main, no me añade ninguna linea al fichero clientes.dat, con lo que me he quedado superatascado en el apartado 1 y no puedo seguir.

Pego los códigos y a ver que me podeis decir. Muchisimas gracias de antemanos.


Clase principal:

Código (java) [Seleccionar] Expandir

package tarea6;

/**
*
* @author adec29
*/
public class Tarea6 implements java.io.Serializable {
   //Se implementa la interfaz serializable para que el objeto Cliente pueda
   //escribir todos sus datos en fichero.
   

   static ManejaClientes cliente;

   /**
    * @param args the command line arguments
    * @throws java.lang.Exception
    */
   public static void main(String[] args) throws Exception {
      /**
       * Creo un cliente por defecto. No se añade al archivo.
       */
       String nombred = "John Doe";
       String nifd = "123456789K";
       String tlfd = "924123456";
       String dird = "13 rue del Percebe";
       String deudad = "2500";
       String ruta = "/home/droigor/Documentos/DAM/PROG - Programación/Unidad 6/Tarea/clientes.dat";

       cliente = new ManejaClientes(nombred, nifd, tlfd, dird, deudad);
       /**
        * Menú
        * Presenta el menú de operaciones con todas las opciones disponibles
        */
       int opcion = 0;
       do{
           try{
               opcion = Integer.parseInt(cliente.Menu()); // Mostramos el menu
               }
           catch (NumberFormatException nfe){
               System.err.println("Sólo valores entre 0 y 6");
               opcion = 10;
           }
       switch (opcion){
       case 0://Salir del menú
       break;
           
       case 1://Añadir cliente

       //Se crea un nuevo objeto (cliente) de la clase ManejaClientes
       String nombre = ManejaClientes.setNombre();
       String nif = ManejaClientes.setNif();
       String tlf = ManejaClientes.setTlf();
       String dir = ManejaClientes.setDireccion();
       String deuda = ManejaClientes.setDeuda();
       // Se invoca al constructor de la clase para que nos guarde un objeto c
       // con los datos recién introducidos
       ManejaClientes c = new ManejaClientes(nombre, nif, tlf, dir, deuda);
       //Añadimos el nuevo cliente al fichero clientes.dat invocando el método EscribeFichero()
       ManejaClientes.EscribeFichero(ruta, c.getNombre(), c.getNif(), c.getDireccion(), c.getTlf(), c.getDeuda());
       break;
                       
       case 2://Listar clientes
       break;

       case 3://Buscar clientes
       break;

       case 4://Borrar cliente
       break;

       case 5://Borrar fichero de clientes. Ojo que no hay vuelta atrás.
       break;

       default:
       System.out.println("Introduzca un valor entre 0 y 6");
     }
               
       
       }while (opcion !=0);
   }
}





Y la clase con sus constructores y métodos.

Código (java) [Seleccionar] Expandir

package tarea6;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

/**
*
* @author droigor
*/
public class ManejaClientes implements java.io.Serializable {
   //Habilitamos la entrada de datos por teclado
   static Scanner teclado=new Scanner(System.in);
   
   //Atriutos
   private String nif; //Nif del cliente
   private String nombre; //Nombre del cliente
   private String telefono; // Teléfono del cliente
   private String direccion; // Dirección del cliente
   private String deuda; //Deuda del dliente
   private static boolean check;
   
   /**
    * Constructor de la clase
    * Los datos son comprobados dentro del método que los crea
    * @param nombre
    * @param nif
    * @param telefono
    * @param direccion
    * @param deuda
    * @throws Exception
    */
       
   public ManejaClientes(String nombre, String nif, String telefono,
                         String direccion, String deuda) throws Exception {
     ManejaClientes.check = false;
     this.nombre = nombre;
     this.nif = nif;
     this.telefono = telefono;
     this.direccion = direccion;
     this.deuda = deuda;
 }
   
// Métodos set y get
   
    /**
    * setNombre()
    * @return nombre
    * Nos permite establecer el nombre del cliente. Verifica que el nombre
    * introducido es correcto siempre y cuando la longitud del String nombre
    * se halle entre 3 y 40 caracteres.
    */
   public static String setNombre(){
       String nombre = "x";
       do{
           System.out.println("Introduce el nombre del cliente (3-40 caracteres):");
           nombre = teclado.nextLine();
           if ((nombre.length() < 3) || (nombre.length() > 40))
               System.out.println("El nombre debe tener entre 3 y 40 caracteres");
           }
       while ((nombre.length() < 3) || (nombre.length() > 40));
       return nombre;
       }
   
    /**
    * setNif()
    * @return nif
    * Nos permite establecer el nif del cliente. Voy a dar por correcto una
    * cadena de 9 caracteres
    */
   public static String setNif(){
       String nif = "x";
       do{
           System.out.println("Introduce el nif del cliente (9 caracteres):");
           nif = teclado.nextLine();
           if ((nif.length() < 9) || (nif.length() > 9))
               System.out.println("El nif debe tener 9 caracteres");
           }
       while ((nif.length() < 9) || (nif.length() > 9));
       return nif;
       }
   
   /**
    * setTlf()
    * @return tlf
    * Nos permite establecer el teléfono del cliente. Voy a dar por correcto una
    * cadena de 9 caracteres
    */
   public static String setTlf(){
       String tlf = "x";
       do{
           System.out.println("Introduce el teléfono del cliente (9 caracteres):");
           tlf = teclado.nextLine();
           if ((tlf.length() < 9) || (tlf.length() > 9))
               System.out.println("El teléfono debe tener 9 caracteres");
           }
       while ((tlf.length() < 9) || (tlf.length() > 9));
       return tlf;
       }
   
        /**
    * setDireccion()
    * @return dir
    * Nos permite establecer la dirección del cliente. Asume que la dirección
    * introducida es correcta siempre y cuando la longitud del String dir
    * se halle entre 3 y 40 caracteres.
    */
   public static String setDireccion(){
       String dir = "x";
       do{
           System.out.println("Introduce la dirección cliente (10-50 caracteres):");
           dir = teclado.nextLine();
           if ((dir.length() < 3) || (dir.length() > 40))
               System.out.println("El nombre debe tener entre 10 y 50 caracteres");
           }
       while ((dir.length() < 10) || (dir.length() > 50));
       return dir;
       }
   
   /**
    * setDeuda
    * Nos permite establecer la cantidad que debe el cliente
    * @return deuda
    */
   public static String setDeuda() {
   String deuda;
   System.out.println("Indique la cantidad adeudada por el cliente: ");
   deuda = teclado.next();
   return deuda;
       
 }
   
   /**
    * getNif
    * Nos devuelve el nif del cliente
    * @return nif
    */
   public String getNif() {
       return nif;
   }

   /**
    * getNombre
    * Nos devuelve el nombre del cliente
    * @return nombre
    */
   public String getNombre() {
       return nombre;
   }

   /**
    * getTlf
    * Nos devuelve el teléfono del cliente
    * @return teléfono
    */
   public String getTlf() {
       return telefono;
   }

   /**
    * getDireccion
    * Nos devuelve la dirección del cliente
    * @return direccion
    */
   public String getDireccion() {
       return direccion;
   }

   /**
    * getDeuda
    * Nos devuelve la deuda que tiene el cliente
    * @return deuda
    */
   public String getDeuda() {
       return deuda;
   }
   
   /**
    * menu()
    * Menú de selección. Presenta el menú de opciones
    * @return opcion
    */
   public String Menu(){
   System.out.println("Menú");
   System.out.println("-------------------------------");
   System.out.println("1 - Añadir cliente");
   System.out.println("2 - Listar clientes");
   System.out.println("3 - Buscar cliente");
   System.out.println("4 - Borrar cliente");
   System.out.println("5 - Borrar fichero clientes.dat");
   System.out.println("0 - Salir");
   System.out.println("-------------------------------");
   String opcion = teclado.next();
   return opcion;
 }
   
   /**
    * escribeFichero()
    * Nos permite escribir datos en el fichero clientes.dat
    * @param ruta - La ruta del fichero
    * @param nombre
    * @param nif
    * @param telefono
    */
   public static void EscribeFichero(String ruta, String nombre, String nif, String telefono,
                         String direccion, String deuda){
       //Inicializamos los objetos fichero y registro que usaremos más adelante
       // para crear un fichero o añadirle datos  en la ruta definida en los
       // atributos de la clase
        FileWriter fichero;
        PrintWriter registro;
       
        try{
            //Creo un ofjeto fichero. El true detrás de ruta es para poder añadir
            //contenido al fichero si existe, si no existe se crea.
           fichero = new FileWriter(ruta, true);
           registro = new PrintWriter(fichero);
           registro.println();

            } catch (IOException e) {
            System.out.println("Error de entrada/salida."+e);
                             
            }catch (Exception ex){//Es la excepción más general y se refiere a cualquier error de entrada y salida
            System.out.println("Error genérico"+ex);
            }
   }

   /**
    * LeerFichero()
    * Nos permite leer del fichero clientes.dat
    * @param ruta
    * @return
    * @throws FileNotFoundException
    */
   public static String LeerFichero (String ruta) throws FileNotFoundException{
       try{
           File fichero;
           FileReader registro;
           //Creo el objeto del archivo a leer
           fichero=new File(ruta);
           //Creo un objeto FileReader que abrirá el flujo de datos a leer
           registro=new FileReader(fichero);
           //Creo un lector en buffer para recopilar los datos de registro
           BufferedReader br= new BufferedReader(registro);
           //Creo una variable lectura que usaré más adelante para almacenar
           //la lectura del archivo y una variable de comprobación
           String lectura="";
           String check=" ";
           //Con este while leemos el archivo linea a linea hasta que se acaba
           // el fichero. Si la variable check tiene datos, se acumulan en la
           //variable lectura. Si check es nula ya se ha leido todo el archivo
           while (true){
               check = br.readLine();
               if (check != null) lectura=lectura+check+"n";
               else
               break;
       }
           br.close();
           registro.close();
           return lectura;
       }
           catch (IOException e){
                   System.out.println("Error:"+e.getMessage());
                   }
           return null;
           
       }

       
                 
   }

Bueno, pues aquí está.
Un saludo a todos.
Rodri.