Soluciones a ejercicios (Excepciones)

En esta ocasión después de tanto sin postear nada, quiero compartir con ustedes las posibles soluciones a unos ejercicios que vienen en el libro de Piensa en Java de Bruce Eckel edición 4ta. edición, pues ojala le pueda servir a alguién más. Espero estén correctas, sino estaré agradecido por sus correcciones, u otras soluciones:

Ejercicio 1: (2) Cree una clase con un método main() que genere un objeto de la clase Exception dentro de un bloque try. Proporcione al constructor de Exception un argumento String. Capture la excepción dentro de una cláusula catch e imprima el argumento String. Añada una clausula finally e imprima un mensaje para demostrar que pasó por allí.

   1: public class ClaseGeneraExcepciones  {

   2:     public static void main(String[] args){

   3:         try {

   4:             throw new Exception("Esto es una Excepción");

   5:         } catch(Exception e) {

   6:             System.out.println("Se produjo un excepción: " + e.getMessage());

   7:         } finally {

   8:             System.out.println("Esto se ejecuta sin importar si se presentan errores");

   9:         }

  10:     }

  11: }

salida del programa:

Se produjo una excepción: Esto es una Excepción
Esto se ejecuta sin importar si se presentan errores

Después, iré actualizando el post con las demás soluciones de los restantes ejercicios del tema de Excepciones, hasta pronto.

Actualización [15/11/2010]

Aquí están las siguientes soluciones:

Ejercicio 2: (1) Defina una referencia a un objeto e inicializela a null. Trate de invocar un método a través de esta referencia. Ahora rodee el código con una clausula try-catch para probar la nueva excepción.

   1: // Ejercicio 2

   2:  

   3: class ExcepcionNull {

   4:     String s = "ejercico 2 sobre Excepciones";

   5:     String getString() {

   6:         return s;

   7:     }

   8:     

   9:     public static void main(String[] args) {

  10:         ExcepcionNull en = null;

  11:         try {

  12:             en.getString();

  13:         } catch (Exception e){

  14:             System.out.println("Se produjo una expción. " + e.getMessage());

  15:         }

  16:     }

  17: }

<!–[if gte mso 9]> 800×600 <![endif]–><!–[if gte mso 9]> Normal 0 21 false false false ES-MX X-NONE X-NONE MicrosoftInternetExplorer4 <![endif]–><!–[if gte mso 9]> <![endif]–> <!–[endif]–>

 

-AMBITO ADMINISTRATIVO

Salida: Se produjo una expción. null

Ejercicio 3: Escriba código para generar y capturar una excepción ArrayIndexOutOfBoundsException (Índice de matriz fuera de límites).

   1: public class ExcepcionEnArray {

   2:     int[] array = {0, 1, 2, 3, 4, 5};

   3:     int getValor(int indice) {

   4:         return array[indice];

   5:     }

   6:     

   7:     public static void main(String[] args) {

   8:         ExcepcionEnArray ea = new ExcepcionEnArray();

   9:         try {

  10:             ea.getValor(6);

  11:         } catch (ArrayIndexOutOfBoundsException e) {

  12:             System.out.println("Excepción: indice de array fuera de limites" + e.getMessage());

  13:         }

  14:     }

  15: }

salida: Excepción: indice de array fuera de limites 6

Actualización [16/11/2010]

Continuó con las soluciones a los ejercicios, si detectarán alguna barbaridad, les agradecería corregirme.

Ejercicio 4: (2) Cree su propia clase de excepción utilizando la palabra clave extends. Escriba un constructor para dicha clase que tome un argumento String y lo almacene dentro del objeto como una referencia de tipo String. Escriba un método que muestre la cadena de caracteres almacenada. Cree una cláusula try-catch para probar la nueva excepción.

   1: class MiExcepcion extends Exception {

   2:     String mensaje;

   3:     public MiExcepcion(String mensaje) {

   4:         this.mensaje = mensaje;

   5:     }

   6:     public String getMensaje() {

   7:         return mensaje;

   8:     }

   9: }

  10:  

  11: public class PropiaClaseExcepcion {

  12:     public static void main(String[] args) {

  13:         try {

  14:             throw new MiExcepcion("mi propia Excepción");

  15:         } catch(MiExcepcion e) {

  16:             System.out.println("excepción: " + e.getMensaje());

  17:         }        

  18:     }

  19: }

  20:  

Salida: Excepción generada: mi propia Excepción

Ejercicio 5: (3) Defina un comportamiento de tipo reanudación utilizando un bucle while que se repita hasta que se deje de generar una excepción.

   1: import java.io.*;

   2:  

   3: public class ExcepcionConReanudacion {

   4:    

   5:    public static void main(String[] args) {

   6:         boolean continuar = true; 

   7:         while(continuar) {        

   8:             try {                

   9:                 System.out.print("Introduce un número entero: ");

  10:                 InputStreamReader datosInsertados = new InputStreamReader(System.in);

  11:                 BufferedReader datos = new BufferedReader(datosInsertados);

  12:                 String cadenaDatos = datos.readLine();

  13:                 int numero = Integer.parseInt(cadenaDatos);

  14:                 int cuadrado = numero * numero;

  15:                 System.out.println("El cuadrado de " + numero + " = " + cuadrado);

  16:                 continuar = false;

  17:             } catch(Exception e) {

  18:                 System.out.println(e.getMessage());                

  19:             }            

  20:         };           

  21:     }

  22: }

Salida:

Introduce un número entero: r
For input string: “r”
Introduce un número entero: t
For input string: “t”
Introduce un número entero: 3
El cuadrado de 3 = 9

Este ejercicio lo pude terminar gracias al apoyo de un tutorial en  la parte de la entrada de datos por el teclado.

Advertisement