New 2 Java: Construir una Aplicación: 4.- Leer y Escribir Ficheros y Manejar Excepciones

En New2Java1, creamos la clase Divelog.java con un constructor que creaba un frame para la aplicación Dive Log, un JMenu, e inicializa un objeto JTabbedPane con seis pestañas con títulos. Cada pestaña creaba un objeto de una clase contenedora. En New2Java2, diseñamos la clase Welcome.java, que aparece en el panel Welcome. En New2Java3, la clase Diver.java presentó la encapsulación, que ilustra como recolectamos datos del usuario y los mostramos la entrada en la pantalla a través del manejo de eventos básico.

Esta parte 4 refuerza estos conceptos, presenta el panel Log Dives, y nos enseña como:

  • Preparar para manejar errores.
  • Leer y escribir desde ficheros (Java I/O).
  • Usar la distribución Box.
  • Usar la clase JFileChooser para nombrar nuevos ficheros.
  • Usar la clase JOptionPane para crear cajas desplegables que impriman avisos o proporcionen información.

. Empezando

Para esta parte del tutorial, necesitamos una imagen y la clase Dives.java que crea el panel Log Dives. Podemos usar una imagen diferente a la proporcionada aquí, pero para evitar problemas con la distribución, la imagen debe tener el mismo tamaño que ésta.

Sigue estos pasos...
  1. Graba la siguiente imagen en el directorio divelog/images: gwhite.gif
    Tamaño de la imagen 299x970pixels.

O crea una imagen tu mismo, pero usa el mismo tamaño de pixels que ves arriba.

El panel Log Dives consta de varias clases:

  • Dives.java
    Crea el panel principal, que usa el controlador de distribución BorderLayout e inicializa otras tres clases:
    • NorthPanel.java
      Lee un fichero en un área de texto. Esta clase se añade a la región norte de Dives.java
    • CenterPanel.java
      Crea un áre de texto texto con barras de desplazamiento en la region central de Dives.java
      El botón Save crea una caja de diálogo JFileChooser y escribe los datos en un fichero cuyo nombre especifica el usuario.
    • WestPanel.java
      Inicializa varias clases adocionales que crean el GUI para este panel, construye un objeto dive y graba el objeto y lo lee desde un fichero.

Por ahora, crearemos clases vacías para las tres últimas clases listadas arriba.

Sigue estos pasos...
  1. En tu editor de texto, crea tres ficheros, cada una con el siguiente nombre y contenido:
    • NorthPanel.java
      package divelog;
      import java.awt.*;
      import javax.swing.*;
      public class NorthPanel extends JPanel { // Opens class
      
      } // Closes class
      
    • CenterPanel.java
      package divelog;
      import java.awt.*;
      import javax.swing.*;
      public class CenterPanel extends JPanel { // Opens class
      } // Closes class
      
    • WestPanel.java
      package divelog;
      import java.awt.*;
      import javax.swing.*;
      public class WestPanel extends JPanel { // Opens class
      } // Closes class
      
  2. Graba todas las clases.
  3. Compila todas las clases, usando:
    javac NorthPanel.java
    javac WestPanel.java
    javac CenterPanel
    

En este momento, ninguna de estas clases tiene un constructor. Más adelante definiremos constructores para ellas.

Luego, inicializamos las clases dentro del constructor de la clase Dives.java.

Sigue estos pasos...
  1. Abre Dives.java en tu editor de texto, iniciliza las clases que has creado, y luego añade sus identificadores al BorderLayout:
    public class Dives extends JPanel { // Opens class
    
        public Dives()    {// Opens constructor
        // Sets the layout for the page and the
        // background to white.
        setLayout(new BorderLayout());
        setBackground(Color.white);
    
         // Initializes the placeholder classes.
         NorthPanel northPanel = new NorthPanel();
         CenterPanel centerPanel = new CenterPanel();
         WestPanel westPanel = new WestPanel();
    
         // Adds class objects to panel regions.
         add("North", northPanel);
         add("West", westPanel);
         add("Center", centerPanel);
       } // Closes constructor
     }// Closes class
    
  2. Graba el fichero.

Crear una clase para inicializar otros objetos demuestra una forma de organizar un panel complejo. Esto es especialmente útil si necesitamos usar varias distribuciones diferentes. Podríamos crear una clase enorme para todo esto, pero dividiendo el panel en varias clases podemos hacer cambios a secciones individuales sin afectar al código de las otras.

El panel Log Dives está organizado con las siguientes clases que nos enseñan especificadades de la I/O en Java:

  • NorthPanel: demuestra como leer un fichero.
  • CenterPanel: demuestra como escribir un fichero.
  • WestPanel: demuestra como leer y escribir objetos desde y hacia un fichero.

El proceso para leer y escribir desde un fichero es propenso a errores. La aplicación podría intentar abrir un fichero que no existe, o intentar escribir un fichero que es de sólo lectura. Pueden ir mal muchas cosas.

Antes de aprender a leer y escribir ficheros, necesitamos entender cómo prepararnos para manejar los errores y los problemas que podrían ocurrir.

. Prepararnos para los Problemas

Cuando una aplicación encuentra un error o una condición no esperada, algunas veces termina, mostrando un mensaje en la consola. En algunos casos, la aplicación no arranca.

Por ejemplo, si tecleamos los siguiente en la línea de comandos:

javac DisplayError.java

Obtendriamos este mensaje de error, asumiento que no tenemos un fichero llamado DisplayError.java:

javac DisplayError.java
error: cannot read: DisplayError.java
1 error

El compilador no pudo encontrar el fichero nombrado e imprimió este mensaje en la pantalla. Estos tipos de mensajes de consola no son siempre útiles, y normalmente no querremos que la aplicación termine, sino que continúe con otro trozo de código que hemos escrito. Para forzar a que una aplicación haga algo en el caso de un problema, primero debemos capturar y manejar la condición problemática. El lenguaje Java tienes unas clases y una sintaxis especial para tratar con errores y problemas potenciales.

Las aplicaciones pueden generar muchos tipos de condiciones inesperadas. Por ejemplo, podríamos querer que el usuario introdujera un int, pero él introduce un String. El usuario podría solicitar el nombre de un fichero que no existe, o nuestra lógica de programa podría intentar dividir por cero. Las condiciones inesperadas en una aplicación son referidas como excepciones en el lenguaje Java. En otras palabras, una excepción es la forma de indicar una condición anormal en una aplicación.

Los pasos para manejar dichas excepciones son los siguientes:

  1. Nuestra aplicación prueba (try) un bloque de código, y ocurre una condición inexperada o un error.
  2. El control del program es transferido o lanzado (throw) a una sección de código específica.
  3. Este bloque de código especifico captura (catch) y maneja el problema.

Existen dos tipos de condiciones:

  • Errores
  • Excepciones

Los errorres indican algo fatal, como un error de fallo de memoria. Estos son difíciles de recuperar. Un error indica un problema serio que una aplicación razonable no debería intentar capturar. La mayoría de dichos errores son condiciones anormales.

Por otro lado, las excepciones indican condiciones no-fatales que normalmente podemos capturar y manejar.

Las excepciones y errores son objetos. Las clases usadas para crear los objetos son subclases de la clase Throwable. No usamos directamente la clase Throwable, sino que utilizamos una de sus subclases como Exception.

Un objeto Exception lo crea el código en el punto en que ocurrió el error o condición. Este objeto contiene información necesaria para describir la condición. El objeto Exception se pasa al bloque de código manejador, donde escribimos las instrucción que queremos que sucedan en el caso de que se produzca esta condición.

Por ejemplo, supongamos que creamos un fomulario para que lo rellene el usuario. Solicitamos que el ususario teclee un nombre de fichero para leerlo. Como sabemos que es posible que no exista ese nombre del fichero en el sistema de ficheros del usuario, necesitamos escribir un código que capture y maneje esta condición. Cuando el usuario teclea un nombre de fichero que no existe, en vez de terminar el programa, escribimos código que nos muestre un diálogo, diciéndole al usuario que el fichero no existe y preguntándole si se debería crear. Luego necesitamos escribir código para manejar una respuesta Si o No. O quizás, queramos crear un aviso de algún tipo. De cualquier forma, estámos preparados para una condición posible y hemos escrito código para manejarla.

Hay clases más específicas que se derivan de las clases Exception y Error. Las clases Throwable y sus subclases tienen dos constructores, uno que no toma argumentos y otro que toma un argumento String que puede utilizarse para producir un mensaje de error.

¿Para prepararte para posibles condiciones, dónde deberías escribir el código para abrir un fichero para su lectura?
 A  En una clausula catch
 B  En el método main
 C  En su propia clase
 D  En una clausula try

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
ARTÍCULO ANTERIOR

SIGUIENTE ARTÍCULO

¡SÉ EL PRIMERO EN COMENTAR!
Conéctate o Regístrate para dejar tu comentario.