Fecha y hora actual: Jueves 17 Ene 2019 04:53
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Curso VB .NET - Tema 1.36 - Captura de errores, Java

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.36 - Captura de errores, Java

Autor Mensaje
Tesis
Administrador


Registrado: 04 Mar 2007
Mensajes: 3200
Ubicación: Valencia - España

Mensaje Publicado: Domingo 25 Oct 2009 08:18

Título del mensaje: Curso VB .NET - Tema 1.36 - Captura de errores, Java

Responder citando

Curso de programación en .NET - Tema 1.36 - Captura de errores, Java


1. Captura de errores Try Catch, Java. Ejercicios pendiente.
1.1 Objetivos del tema.

Entrar en la captura de errores en Java.

1.2 Introducción.
Todo programa tiene un nivel de calidad.
La calidad vendrá marcada por distintos factores, un buen análisis, una buena depuración, etc..., y un adecuado control y captura de errores.

Un programa no debe finalizar nunca de forma brusca, siempre debe tener una salida ante cualquier contingencia, por varios motivos, calidad, por elegancia en la programación, y otro, el más importante, porque de esa forma se consigue la posibilidad, si se desea, de dejar un histórico de fallos, que después permitirá obtener datos para la solución de los mismos.

En la captura de errores, hay que tener presente que no siempre son errores de ejecución, si no que en muchas ocasiones la única forma de poder tomar la decisión adecuada en un momento determinado, es la de forzar un fallo en el programa, para su captura posterior.

En Java el control de errores podemos hacerlo por dos caminos distintos.
Código:
public ClaseArchivos(String Ruta, String Nombre)
{
   try
   {
      FileWriter Salida = null;
      File Archivo = new File(Ruta + Nombre);
      Salida = new FileWriter(Archivo);
   }
   catch (IOException ex)
   {
      Logger.getLogger(ClaseArchivos.class.getName()).log(Level.SEVERE, null, ex);
   }
}


La sintaxis anterior dará lugar a la siguiente declaración de un objeto al usar dicha clase.
Código:
public static void main(String[] args) throws FileNotFoundException
{
   try
   {
      ClaseArchivos Archivo = new ClaseArchivos("", "Pruebas.txt");
   }
   catch (IOException ex)
   {
      Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
   }
}


O podemos utilizar este otro sistema de captura de errores.
Código:
public ClaseArchivos(String Ruta, String Nombre) throws IOException
{
   FileWriter Salida = null;
   File Archivo = new File(Ruta + Nombre);
   Salida = new FileWriter(Archivo);
}


Que más que una captura, es una inhibición hacía el que ha llamado al método.
En ambos casos solucionamos un problema, la posible aparición de un error y su captura.
Veamos ahora sus características.

1.3 Errores.
En cualquier caso, para poder hacer una gestión de dichos errores, es necesario siempre tener prevista la clase adecuada para su gestión o dicho de otro modo:
Código:
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;


De ésta forma se puede llevar a cabo la gestión de los errores a capturar.
En el ejemplo se importan la gestión de los errores porque no existe un archivo.

Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del argumento, excepciones semejantes. Por ejemplo:
Código:
class Limites extends Exception {}
class demasiadoCalor extends Limites {}
class demasiadoFrio extends Limites {}
class demasiadoRapido extends Limites {}
class demasiadoCansado extends Limites {}
   .
   .
   .
   try
   {
      if( temp > 40 )
         throw( new demasiadoCalor() );
      if( dormir < 8 )
         throw( new demasiadoCansado() );
   }
   Catch ( Limites lim )
   {
      if (lim instanceof demasiadoCalor)
      {
         System.out.println( "Capturada excesivo calor!" );
         return;
      }
      if (lim instanceof demasiadoCansado)
      {
         System.out.println( "Capturada excesivo cansancio!" );
         return;
      }
   }
   finally
      System.out.println( "En la clausula finally" );


1.4 Try Catch.
Esta estructura de captura de errores, puede ser anidada una dentro de otra, con el fin de realizar la captura adecuada de los errores.
Tiene tres zonas.
Código:
try
   Ejecución normal del programa.
catch
   Ejecución por excepción del programa.
finally


Ejecución que siempre se hará, pase lo que pase.
En la zona de try, escribiremos siempre el código que deseamos ejecutar.

En la zona de catch, la primera fase es la de saber que tipo de error deseamos capturar para el uso adecuado del tipo de excepción.
Código:
catch (IOException ex)


La parte de catch puede existir con distintas situaciones de error.
Código:
try
   Ejecución normal del programa.
catch (IOException ex)
{
   Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
catch (ArithmeticException ex)
{
   Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}


En la zona de finally escribiremos el código que deseamos que se ejecute siempre, independientemente de que se produzca o no una situación de error.

1.5 Throws.
La palabra clave throws se utiliza para identificar la lista posible de excepciones que un método puede lanzar.

Hay acciones en un método que pueden o no generar excepciones, errores, pero Java no te deja decidir si es o no oportuno el capturar un error y obliga a realizar esa captura.
Por ejemplo en el procedimiento
Código:
private void GrabaCampoString(String Dato)
{
   Salida.write(34);
   Salida.write(Dato);
   Salida.write(34);
}


No tiene porque generar un error, o el error se puede generar una de cada cien veces, sin embargo en la escritura del código Java lo marca como error,
Unreported exception java.io.IOException; must caught or declared to be throw
Excepción de entrada salida, no controlada, debe ser capturada o declararse con throw.


y obliga a la captura del mismo mediante un try, o el throws.
Código:
private void GrabaCampoString(String Dato)
{
   try
   {
      Salida.write(34);
      Salida.write(Dato);
      Salida.write(34);
   }
   catch (IOException ex)
   {
      Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
      System.out.println("Error");
   }
}


Pero en realidad eso es excesivo, por lo que la salida más adecuada es el uso de la “inhibición”, propagación o desvío del error hacia otro método, el que lo llama.
Por lo que el procedimiento acaba quedando como sigue:
Código:
private void GrabaCampoString(String Dato) throws IOException
{
   Salida.write(34);
   Salida.write(Dato);
   Salida.write(34);
}


Que es mucho más apropiado, por el ejemplo expuesto, después en cada caso se dará la solución más apropiada, y se reduce el volumen de código.

Pero no acaba aquí, cuando éste procedimiento genera el mencionado error, o el aviso de error, más correcto, el procedimiento que lo llama también queda marcado con errores, si no se realiza la captura del error, siguiendo el mismo sistema del try
Código:
try
{
   GrabaCampoString(Campo);
   Separador();
}
catch (IOException ex)
{
}


o el de colocar en la definición del método throws.
Código:
public void GrabaDelimitado(List Campos) throws IOException


Que es lo más socorrido, quedando el método al final como sigue:
Código:
public void GrabaDelimitado(List Campos) throws IOException
{
   int x=0;
   String Campo;
   while (x < Campos.size()-1)
   {
      Campo = Campos.get(x).toString();
      GrabaCampoString(Campo);
      Separador();
      ++x;
   }
   Campo = Campos.get(x).toString();
   GrabaCampoString(Campo);
   GrabaFinRegistro();
}


Para la mayoría de las subclase de la clase Exception, el compilador Java obliga a declarar qué tipos podrá lanzar un método. Si el tipo de excepción es Error o RuntimeException, o cualquiera de sus subclases, no se aplica esta regla, dado que no se espera que se produzcan como resultado del funcionamiento normal del programa.
Si un método lanza explícitamente una instancia de Exception o de sus subclases, a excepción de la excepción de runtime, se debe declarar su tipo con la sentencia throws.

Java requiere que los métodos capturen o especifiquen todas las excepciones chequeadas que puedan ser lanzadas dentro de su ámbito.
La declaración del método sigue ahora la sintaxis siguiente:
Código:
type NombreMetodo( argumentos ) throws excepciones { }


1.6 Conclusiones.
Con el desvío de excepciones se obtienen varias ventajas, e inconvenientes.
Se reduce el volumen de código, por lo que es más sencillo de releer y seguir. También se obtiene de esa forma la posibilidad, de que cuando se crea código para terceros, se deja la forma o la interface de los mensajes de error, en manos de quien la usa, lo cual en la mayoría de los casos es una buena alternativa, ya que el código queda completamente integrado en el programa donde se incrusta la clase.
Evidentemente tiene como inconveniente, que no responsabilidad, de que eso genere una ejecución inadecuada, pero lo será por quien la usa, no por quien la escribió.


Autor del curso: casiopea


Normas del foro
Aprende a postear correctamente usando las etiquetas
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Imagen referencial De creación de jtable en apl...

Jensel S.G Java 6 Miércoles 13 Sep 2017 20:06 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

EMPLEO ANALISTA PROGRAMADOR/A BACK-END JAVA EE

GRUPOARESTORA Bolsa de trabajo 0 Viernes 23 Jun 2017 14:33 Ver último mensaje
El foro no contiene ningún mensaje nuevo

captura datos

Marta85 C, C#, Visual C++ 1 Miércoles 22 Feb 2017 14:02 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,