lunes, 7 de marzo de 2011

Laboratorio sobre Archivos en Java (09.06.02)

Agregue un método a manager que cargue todos los parámetros en un HashMap.

Manager.java
import java.io.*;
public class Manager
{
// Método para leer todas las claves del archivo parametros.ini
public static HashMap leerParametros()...
}

TestManagerHashMap.java
public class TestManagerHashMap { public static void main (String[] args) {
HashMap parametros = Manager.leerParametro();
// Mostrar aqui todos los parametros
}
}
Compartir:

Laboratorio y ejercicios sobre Archivos en Java (09.06.01)

PARTE 1
Con el siguiente archivo parametros.ini; implemente el método en la clase Manager.java que lea una variable del archivo y la devuelva como String

parametros.ini
ip=190.200.3.45
url=www.uni.edu.pe
user=integrador
password=200SCAMOF
mail=salvor.hardin@enciclopedia.com
default=*.map
...
...(y mas parámetros)
...
ruta=/home/rafael/bin

Manager.java
import java.io.*;
public class Manager
{
// Método para leer una clave del archivo parámetros.ini
public static String leerParametro(String clave)...
}

Test.java
public class TestManager {
public static void main (String[] args) {
String parametro = Manager.leerParametro("user");
System.out.println(parametro );
}
}

C:\> java TestManager
integrador
Compartir:

la clase File para Directorios en Java (09.05.02)

- El método list() de la clase File muestra los archivos de un directorio. - La interfase FileNameFilter se usa para obtener un subconjunto de archivos

TestFilenameFilter.java
import java.io.*;
public class TestFilenameFilter{

public static void main( String args[] ) {

// Buscar en el raiz del disco C
// Se coloca doble slash puesto que es un caracter de escape.
// en literales cadenas en java se realiza:
// \n -> retorno de carro
// \t -> tabulador
// \\ -> slash
// \" -> comillas
String directorio = "c:\\";

// el directorio es un archivo del sistema operativo
// fileDirectorio es este archivo en el programa
File fileDirectorio = new File(directorio);

// se crea un filtro de archivos que contengan java.
FilenameFilter filtro = new FilterJava("java");

// se aplica el filtro al directorio.
String [] contenido = fileDirectorio.list(filtro);
for (int i=0; i < contenido.length; i++) {
System.out.println(contenido[i]);
}
}
}

FilterJava.java
import java.io.*;
public class FilterJava implements FilenameFilter {

// Esta clase implementa un filtro de archivos
// usando la interface FilenameFilter
// mediante el método accept
String mascara;
FilterJava(String mascara) {
this.mascara = mascara;
}
public boolean accept(File directorio, String nombre) {
return nombre.indexOf(mascara) != -1;
}
}

Ejercicio: Modifique y muestre todos los archivos java del disco duro y su ubicación.

TestFilenameFilterRecursivo.java
import java.io.*;
public class TestFilenameFilterRecursivo{

public static void main( String args[] ) {
String directorio = "c:\\";
filtrarDirectorio(directorio);
}
public static void filtrarDirectorio(String directorio) {

// el directorio es un archivo del sistema operativo
// fileDirectorio es este archivo en el programa
File fileDirectorio = new File(directorio);

// se crea un filtro de archivos que contengan java.
FilenameFilter filtro = new FilterJava("java");

// se aplica el filtro al directorio.
String [] contenido = fileDirectorio.list(filtro);

// en caso no tenga contenido no se procesara
if (contenido==null) return;

// se muestra todos los archivos con java
if ( contenido.length > 0 )
System.out.println(directorio);

for (int i=0; i < contenido.length; i++) {
System.out.println(" "+contenido[i]);
}
// se recorre todo el directorio para
// obtener sus subdirectorios
String [] lista = fileDirectorio.list();

for (int i=0; i < lista.length; i++) {
// se crea un objeto file del subdirectorio
File fileSubDirectorio = new File(fileDirectorio,
lista[i]);
if (fileSubDirectorio.isDirectory()) {
// se llama recursivamente la función
filtrarDirectorio(fileSubDirectorio.
getAbsolutePath());
}
}
}
}

Compartir:

La clase File para Archivos en Java (09.05.01)

- La clase File se usa para representar un archivo o un conjunto de archivos (directorio)
File f1 = new File ("/");
File f1 = new File ("/","etc/passwd");
File f1 = new File ("config.sys");
- Puede obtener atributos del archivo mediante la clase File.
Si existe, si se puede leer, si se puede escribir.
Cuando fue la ultima vez modificado, cual es su tamaño.
- Con File puede crear y borrar archivos.
- Otros métodos se encuentran en:

TestFile.java
import java.io.*;
public class TestFile {
public static void main( String args[] ) throws IOException
{
if( args.length > 0 )
{
for( int i=0; i < args.length; i++ )
{
File f = new File( args[i] );
System.out.println( "Nombre: "+f.getName() );
System.out.println( "Ruta : "+f.getPath() );
if( f.exists() )
{
System.out.print( "El archivo existe." );
System.out.print( (f.canRead() ?
" y se puede Leer" : "" ) );
System.out.print( (f.canWrite() ?
" y se puede Escribir" : "" ) );
System.out.println( "." );
System.out.println( "La longitud del archivo es "+
f.length()+" bytes" );
}
else  System.out.println( "El archivo no existe." );
}
}
else  System.out.println( "Debe indicar un archivo." );
}
}

Ejercicio: Modifique el programa y muestre la siguientes características del archivo.
boolean isDirectory() , boolean isHidden() , String getParent()
Compartir:

Escritura de objetos en Java Serializable (09.04.01)

Para escribir objetos en archivos se debe usar la clase ObjectOutputStream y ObjectInputStream usando objetos que implementan la interface java.io.Serializable.

Producto.java
public class Producto implements java.io.Serializable {

// La serialización de un objeto permite
// escribir el estado de un objeto a un flujo de bytes.
private String nombre;
private int cantidad;
private float precio;
public Producto(String nombre, int cantidad, float precio) {

this.nombre = nombre;
this.cantidad = cantidad;
this.precio = precio;

}
public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad+
" Precio: "+precio);
}
}

TestObjectStream.java
import java.io.*;
public class TestObjectStream {

public static void main(String[] args) {
try {
escribirProductos();
leerProductos();
}
catch (Exception e) {
e.printStackTrace(System.err);
}
}

public static void escribirProductos() throws Exception {

// Crear objectos productos
Producto pan = new Producto("Pan", 6, 1.2f);
Producto leche = new Producto("Leche", 2, 2.5f);
Producto manzanas = new Producto("Manzanas", 5, 3f);
Producto brocoli = new Producto("Brocoli", 2, 5f);
Producto carne = new Producto("Carne", 2, 20f);
// Definir archivo de productos
ObjectOutputStream archivoProductos =
new ObjectOutputStream(
new FileOutputStream("productos.obj"));
// Escribir los productos en el archivo
archivoProductos.writeObject(pan);
archivoProductos.writeObject(leche);
archivoProductos.writeObject(manzanas);
archivoProductos.writeObject(brocoli);
archivoProductos.writeObject(carne);
// Cerrar el archivo
archivoProductos.close();
}

public static void leerProductos() throws Exception {

// Definir archivo de productos
ObjectInputStream archivoProductos =
new ObjectInputStream(
new FileInputStream("productos.obj"));
// Leer los productos del archivo
try {
while (true) {
Producto producto =
(Producto)archivoProductos.readObject();
System.out.println(producto);
}
}
catch (EOFException e) {
// Cerrar el archivo
archivoProductos.close();
}
}
}

Compartir:

Escritura de archivos en java (09.04.01)

Ejemplo:
Este programa lee un archivo java y lo modifica para escribirlo en otro archivo.

import java.io.*;
public class TestWriter {
public static void main(String[] args) {
try {
// Se define el stream para leer codigo fuente
// de un archivo java
BufferedReader archivoEntrada;
archivoEntrada = new BufferedReader(
new FileReader("C:\\TestWriter.java"));

String lineaArchivo;
String fuenteArchivo = new String();

// El archivo se lee linea a linea y se agrega en una Cadena
// readLine() retorna nulo cuando no haya mas lineas.
// \n significa fin de linea, retorno de carro.
while ((lineaArchivo = archivoEntrada.readLine()) != null)
fuenteArchivo += lineaArchivo + "\n";

// Se cierra el stream de lectura.
archivoEntrada.close();

// Se define el stream en memoria (BufferedReader)
// para leer datos del teclado (InputStreamReader)
// que se digitan en la consola (System.in)
BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in));

// Se lee el teclado y se agrega a la Cadena
System.out.print("Introduzca algun dato: ");
fuenteArchivo += "Agrego \" " + teclado.readLine()
+ " \" en la consola";

// Para guardar datos en un archivo
// Se define el stream en memoria (BufferedReader)
// para leer datos de un String (StringReader)
// que se encuentra en una variable (fuenteArchivo)
BufferedReader fuenteSalida;
fuenteSalida = new BufferedReader(
new StringReader(fuenteArchivo));

// Se define un stream de salida (PrintWriter)
// que tomara los datos de memoria (BufferedWriter)
// y los escribira en un archivo (FileWriter)
PrintWriter archivoSalida;
archivoSalida = new PrintWriter(
new BufferedWriter(
new FileWriter("C:\\TestWriterNew.java")));

// Se lee linea a linea la Cadena (fuenteSalida)
// si no se tiene mas lineas, la lectura devuelve NULL
// Se escribe en el archivo el numero de linea
// y el texto de la Cadena
int lineaNo = 1;
while ((lineaArchivo = fuenteSalida.readLine()) != null)
archivoSalida.println(lineaNo++  + ": " + lineaArchivo);

// Se cierra el stream de salida
archivoSalida.close();

} catch (EOFException e) {
System.out.println("Final de Stream");
} catch (IOException e) {
System.out.println("Excepcion Entrada/Salida");
}
finally {
System.out.println("Revise C:\\TestWriterNew.java");
}
}
}

Ejercicio: 
Modifique el programa anterior para que el nuevo archivo java no tenga comentarios.

Compartir:

Lectura de archivos en Java (09.03.01)

Ejemplo:
Este programa pide el nombre del archivo para leer su contenido y finalmente indicar cuantas líneas tiene. Ingrese por teclado un archivo java.


import java.io.*;
public class TestStreamReader {

public static void main(String[] args) throws IOException {

String lineaJava;
int lineas = 1;
try {

System.out.print("Que archivo desea analizar?");

// Se define una variable del tipo BufferedReader que
// permite almacenar datos en memoria Buffer.
BufferedReader teclado;

// System.in es la entrada de la consola, el teclado
// InputStreamReader es un stream de lectura (de teclado)
// El constructor BufferedReader direcciona
// la lectura del teclado al buffer en memoria.

teclado = new BufferedReader(new
InputStreamReader(System.in));

// Se lee el stream hasta un ENTER.
// El nombre del archivo se encuentra la variable String.
String archivoJava = teclado.readLine();

// Se define una variable del tipo BufferedReader que
// permite almacenar datos en memoria Buffer. 
BufferedReader archivo;

// FileReader es un stream de lectura (de archivos)
// El constructor BufferedReader direcciona
// la lectura del archivo al buffer en memoria.
archivo = new BufferedReader( new FileReader(archivoJava));

// Este ciclo se realizara hasta que
// ya no existan lineas por leer.
while (( lineaJava = archivo.readLine()) != null)
lineas++;

System.out.println("El archivo " + archivoJava +
" contiene " + lineas + " lineas.");

} catch (IOException ex) {
System.err.println(ex);
System.out.println("Asegurese de haber proporcionado " +
" la extension del archivo (\".java\")");
} finally {
System.out.println("");
System.out.println("Asi funcionan los Streams!");
}
}
}

Ejercicio:
Modifique el programa anterior para que se muestre la cantidad de de llaves “{“ o “}” en el archivo.

Compartir:

System.in Entra estandar en Java (09.01.02)

- La entrada estandar de la consola se representa por System.in
- in es un objeto del tipo InputStream con limitaciones en la lectura por teclado.
- Su método read no permite leer una linea completa, ni un numero.
- Se usa el método read en caso requiera realizar una pausa en el programa.
try { System.in.read(); } catch ...
- Cuando requiera leer el teclado debe enmascarar System.in
- Requiere de las clases InputStreamReader y BufferedReader para realizar la mascara.
Compartir:

System.out. Salida estandar en Java (09.02.01)

- El metodo System.out.println tambien es un stream que muestra datos en consola.
- System es una clase
- out es un atributo de System
- out es una clase es del tipo java.io.PrintStream
- out es una variable de instancia, publica y estatica.
- java.io.PrintStream hereda de java.io.OutputStream.
- println es un método
- El atributo out de la clase System cuenta con el metodo println que conforman el conocido System.out.println
Compartir:

java.io.Writer y java.io.Reader (09.01.03)

- Con una variación las clases InputStream y OutputStream.
- Transmiten datos en forma de caracteres (16 bits)
- Las clases Writer y Reader fueron desarrolladas posteriormente y son más veloces que InputStream y OutputStream.
- Se cuenta con clases que permiten actualizar las clases antiguas.
- InputStreamReader convierte un InputStream a Reader
- OutputStreamWriter convierte un OutputStream a Writer

java.io.Reader
BufferedReader
InputStreamReader
FileReader
StringReader

java.io.Writer
BufferedWriter
PrintWriter
OutputStreamWriter
FileWriter
Compartir:

java.io.InputStream y java.io.OutputStream (09.01.02)

- Las clases java estan agrupadas según su funcionalidad
- Las que tratan de la lectura heredan de InputStream.java
- Las que tratan de la escritura heredan de OutputStream.java
- Un flujo de datos binarios pueden provenir de un file, un pipe o de un objeto java.
- FileInputStream.java por ejemplo es para el manejo de archivos.

java.io.InputStream
FileInputStream
AudioInputStream
ObjectInputStream
FilterInputStream
BufferedInputStream

java.io.OutputStream
FileOutputStream
ByteArrayOutputStream
ObjectOutputStream ...
FilterOutputStream
BufferedOutputStream

- Tanto java.io.InputStream y java.io.OutputStream transmiten datos en forma de bytes (8 bits)
Compartir:

Stream y Archivos en Java (09.01.01)

- Cualquier cosa que sea leida o escrita hacia un dispositivo es un stream.
- Ejemplos de dispositivos: Consola, File, Pipes, Red, Memoria.
- Ejemplos de cosas a leerse o escribirse: Caracteres, Objetos java, sonido, imágenes...
- Para la lectura siempre se ha usado este modelo de programación
- El modelo se asemeja al flujo de agua en un rio.



abrir stream
mientras existan datos
leer o escribir datos
cerrar strem

- Un stream es un flujo de datos y puede estar compuesto por archivos de texto, datos ingresados por teclado, datos descargados desde Internet.
Compartir:

Que se puede hacer con una Excepción en Java? (08.01.05)

Excepciones controladas
Se puede:
- Capturar la excepción y manipularla
- Pasar la excepción al método invocador.
- Capturar la excepción y lanzar una excepción diferente.

Excepciones no controladas
No necesitan ser controladas en el código.
El JVM terminara el programa cuando las encuentra.
Si no desea que el programa termine tendrá que manejarlas.
Compartir:

Throwable en Java (08.01.04)

Todos los errores y excepciones heredan de la clase Throwable


Errores.
Heredan de la clase Error; estos se generan cuando ocurren errores fatales para el programa como por ejemplo: cuando la memoria esta llena o cuando es imposible encontrar una clase requerida.

Excepciones no controladas
Heredan de la clase RuntimeException.
Estas ocurren cuando por ejemplo se divide entre cero o se intenta acceder a un elemento del arreglo fuera de sus limites.
Mediante código se puede capturar, manipular o ignorar estas excepciones.
Si no maneja el error, el java terminara el programa indicando el estado del error.

Excepciones controladas
Heredan de la clase Exception.
Estas deben ser capturadas y manejadas en algun lugar de la aplicación.
Las excepciones creadas por el programador seran heredadas de la clase Exception.
Compartir:

Ejercicios sobre excepciones en Java (08.04.01)

Agregue los siguientes métodos al programa TestExcepcionTeclado.java. Cree excepciones para su control.

// método que lea solo un carácter.
public static char readChar(String etiqueta)...

// método que lea un decimal con enteros y decimales.
public static float readNumber(String etiqueta, int enteros, int decimales)...

// método que lea una dirección IP xxx.xxx.xxx.xxx
// 0 <= xxx <= 255 public static String readIP(String etiqueta)... // método que lea una fecha valida // formato dd/mm/yyyy public static String readDate(String etiqueta)

TestExcepcionTeclado.java
import java.io.*;
public class TestExcepcionTeclado {

public static void main (String[] args) {
try {
String nombre = readString("Ingrese un nombre: ");
System.out.println("Su longitud es "+nombre.length());

int entero = readInt("Ingrese un entero: ");
System.out.println("El cuadrado es "+entero*entero);
}
catch (NumberFormatException e) {
System.out.println("Excepcion numerica");
e.printStackTrace(System.err);
}
catch (ArithmeticException e) {
System.out.println("Excepcion artimetica");
e.printStackTrace(System.err);
}
catch (IndexOutOfBoundsException e) {
System.out.println("Excepcion de arreglos");
e.printStackTrace(System.err);
}
catch (Exception e) {
System.out.println("Excepcion");
e.printStackTrace(System.err);
}

}

public static String readString(String etiqueta)
throws Exception
{
System.out.print(etiqueta);
String cadena="";
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
cadena = in.readLine();
return cadena;
}

public static int readInt(String etiqueta)
throws Exception
{
int entero = 0;
String cadena = readString(etiqueta);
Integer enteroInteger = new Integer( cadena.trim());
entero = enteroInteger.intValue();
return entero;
}
}
Compartir:

Laboratorio de Excepciones en Java (08.03.01)

Ensaye este ejemplo
public class CerradoException extends Exception {
       public CerradoException () {}
       public CerradoException (String msg) {
         super(msg);
       }
}

public class TestCerradoException {
    
    public static void main(String[] args) {
 try {
     abrirLaPuerta();
 } catch(CerradoException e) {
          // printStackTrace muestra la traza de la excepcion.
     e.printStackTrace(System.err);
 }
 try {
     abrirLaVentana();
 } catch(CerradoException e) {
          // System.err es el stream de salida de errores
          // similar a System.out.
     e.printStackTrace(System.err);
 }
    }

    public static void abrirLaPuerta() throws CerradoException {
 System.out.println("abrirLaPuerta()? tiene candado!");
 throw new CerradoException ("Originado en abrirLaPuerta()"); 
    }

    public static void abrirLaVentana() throws CerradoException {
 System.out.println("abrirLaVentana()? Esta con cerrojo!");
 throw new CerradoException ("Originado en abrirLaVentana()");
    }
    
}
Compartir:

Como crear una excepción en Java (08.02.07)

Para crear su propia excepción tiene que heredarla de la clase Exception.
Puede ser usado en caso quiera tratar cada problema en el código en forma diferente.
Por ejemplo el manejo del archivo1 puede tratarlo con una excepción1. El manejo de un archivo2 puede tratarlo con una excepcion2. Cada archivo tendria su propia excepción.

UserFileException.java
public class UserFileException extends Exception {
   public UserFileException (String mensaje) {
      super(mensaje);
   }
}
Compartir:

Como pasar la excepción al método invocado en Java (08.02.05)

Para pasar el método al invocador, se declara con la declaración throws.
La excepción se propaga al método que lo invoco.
En el ejemplo, las excepciones de los métodos se manejan en el método invocador.
public void metodoInvocador() {
    try {
        miMetodo();
        getResultado();
    }
    catch {
   }
   finally {
   }
}
public int miMetodo() throws Exception {
    // código que podria lanzar la Exception
}
public int getResultado() throws NumberFormatException {
    // código que podria lanzar la exception NumberFormatException 
}

TestThrows.java
public class TestThrows {

   public static void main (String[] args) {
      
  String cadena = "abcde";
  int    posicion = 6;
  char letra = ' ';
  try {
   letra = getLetra(cadena,posicion);
   System.out.println(letra );
  }
  catch (IndexOutOfBoundsException e) {
   System.err.println("Error en "+cadena+" "+posicion);
  }
   }
   public static char getLetra(String cadena, int posicion)
   throws IndexOutOfBoundsException
   {
  char c =  cadena.charAt(posicion);
      return c;
   }
}

Laboratorio. Cambie posición 6 por –1, 0, 1
Compartir:

Ejecución del bloque finally en Java (08.02.04)

El bloque finally siempre se ejecuta dependiendo como se termina el bloque try.
- Hasta terminar la ultima sentencia del bloque try.
- Debido a sentencias return o break en el bloque try.
- Debido a una excepción.

public class TestFinally {

   public static void main (String[] args) {
      
  int cantidad= 0;
  int divisor = 0;
  String cadena = "5";
  try {
   
   if (cadena.equals("5")) 
                        return;
   
   cantidad = Integer.parseInt(cadena);
                  System.out.println(cantidad);
   int resultado = cantidad / divisor;
                  System.out.println(resultado);
  }
  catch ( NumberFormatException e) {
   System.err.println(cadena + " no es un entero");
  }
  catch ( ArithmeticException e) {
   System.err.println("Error en "+cantidad+"/"+divisor);
  }
  finally {
   System.err.println("Se trabajo con "+cadena+" y 
                                     "+divisor); 
  }
   }
}

Laboratorio:
Pruebe este ejemplo, cambie la cadena por "cinco", "1.1", "5" y divisor cambie por 0, 1, 500
Compartir:

Capturando múltiples excepciones en Java (08.02.03)

Este ejemplo convierte una cadena en un entero y realiza una division.

public class TestMultiException {

   public static void main (String[] args) {
      
  int cantidad= 0;
  int divisor = 0;
  String cadena = "5";
  try {
   cantidad = Integer.parseInt(cadena);
                  System.out.println(cantidad);
   int resultado = cantidad / divisor;
                  System.out.println(resultado);
  }
  catch ( NumberFormatException e) {
   System.err.println(cadena + " no es un entero");
  }
  catch ( ArithmeticException e) {
   System.err.println("Error en "+cantidad+"/"+divisor);
  }
   }
}

Laboratorio:
Pruebe este ejemplo en un programa TestMultiException.java. Cambie la cadena por "cinco", "1.1", "5" y divisor cambie por 0, 1, 500
Compartir:

Capturando una excepción en Java (08.02.02)

Este ejemplo convierte una cadena en un entero

int cantidad;
String cadena = "5";
try {
    cantidad = Integer.parseInt(cadena);
}
catch ( NumberFormatException e) {
    System.err.println(cadena + " no es un entero");
}

Laboratorio:
Pruebe este ejemplo en un programa TestException.java. Cambie la cadena por "cinco", "1.1", "2f".
Compartir:

Como capturar y manejar una excepción en Java (08.02.01)

- Encierre el código del método en un bloque try
- Maneje cada exception en un bloque catch.
- Cualquier proceso final realícelo en un bloque finally. Este bloque siempre se ejecutara, ocurra o no una excepción.

try {
    // código del método
}
catch (exception1) {
   // manejar la excepción1
}
catch (exception2) {
   // manejar la excepción2
}
...
finally {
   // cualquier otro proceso final
}

La documentación del java indicara que excepciones lanza los métodos del java.

Clase : java.io.FileInputStream
Método: public FileInputStream(String name) throws FileNotFoundException
Método: public int read() throws IOException
Compartir:

Devolviendo excepciones en Java (08.01.03)

Devolviendo la excepción hasta el manejador de excepciones.
No se requiere que cada método invocado maneje la excepción, sino únicamente lo hará el primer manejador de excepciones de la lista de métodos invocados.

Maneo Tradicional de errores
El método4 retorna el código de error al método3.
El método3 retorna el código de error al método2
El método2 retorna el código de error al metodo1
El metodo1 maneja el error.

 



Excepciones en Java
El metodo4 lanza una excepción
El metodo1 captura la excepción y la maneja



Las excepciones no pueden ignorarse.

Una vez que un método lanza un error no puede ignorarse a diferencia de la programación tradicional donde se debe controlar en cada punto de invocación.



Compartir:

Separando el manejo de excepciones en Java (08.01.02)

1.2. Características del Java
Cuando ocurre una excepción en un método, Java lanza (throws) una excepcion (Exception).
El objeto Exception generado contiene el tipo de excepción, y el estado del programa cuando ocurrió el error.

Separando el manejo de errores
El manejo de excepciones en java permite separarlos del algoritmo principal.
El resultado es un código mas legible y menos propenso a errores de programación.

Manejo tradicional de errores.
int leerRegistroArchivo() {
   int errorCode = 0;
   abrirArchivo();
   if (errorAbrirArchivo) {
      errorCode = OPEN_ERROR;
   }
   else {
      leerArchivo();
      if (errorLeerArchivo) {
          errorCode = READ_ERROR;
      }
      cerrarArchivo();
      if (errorCerrarArchivo) {
          errorCode = CLOSE_ERROR;
      }
   }
   return errorCode;
} 

Manejo de excepciones en Java.

leerRegistroArchivo() {
   try {
      abrirArchivo();
      leerArchivo();
      cerrarArchivo();
   }
   catch (errorAbrirArchivo) {
      manejarErrorAbrirArchivo;
   }
   catch (errorLeerArchivo) {
      manejarErrorLeerArchivo;     
   }
   catch (errorCerrarArchivo) {
      manejarErrorCerrarArchivo;          
   }
}


Java separa los detalles del manejo de errores del código principal, obteniéndose un código mas legible y menos propenso a errores de codificación.
Compartir:

Excepciones en Java (08.01.01)

Que es una excepción? Es un evento que interrumpe la ejecución de un programa
- Usar un índice fuera de los limites de un arreglo
- Dividir entre cero
- Realizar métodos de objetos nulos.
Que es un error?
En java es cuando la situación es irrecuperable y termina el programa.
- No hay memoria para correr JVM
- Errores internos en JVM
Cual es la diferencia?
Una excepción se puede controlar en el programa. Un error no.
Compartir: