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;
    }
}

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());
        }
    }
}

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;
    }
}

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;
    }
}

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
    {
    }

}

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);
        
    }
    
}