UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

FACULTAD DE INGENIERIA DE SISTEMAS E INFORMATICA

ESCUELA DE INGENIERIA DE SISTEMAS

PRACTICA DE ALGORITMICA II

EXCEPCIONES.

Ejercicio 1: Cree una clase con un método main() que genere un objeto de la claseException dentro de un
bloque try. Proporcione al constructor de Exception un argumentoString. 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í. (*)

Ejercicio 2: 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. (*)

Ejercicio 3: Escriba código para generar y capturar una excepción

ArrayIndexOutOfBoundsException (Índice de matriz fuera de límites). (*)

Ejercicio 4: 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. (*)

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

Ejercicio 6 : División por cero.

Escribe una clase llamada DividePorCero que pruebe a dividir un entero entre otro recogiendo la excepción de
división por cero y mostrando el mensaje "Error: división por cero" si se produce.

Ejercicio 7: Clase fracción.

Diseña e implementa una clase Fracción que permita crear fracciones (numerador y denominador enteros), con
métodos para sumar, restar, multiplicar y dividirlas.
Crea una excepción FraccionException (declárala como una excepción explícita) que se lance siempre que en
una operación de fracción se produzca un error, a saber:
· Creación de una fracción con denominador cero.
· Si el resultado de una división es una fracción con denominador cero (se dará si alguna de las fracciones a
dividir tiene como numerador un cero).
Hacer que las operaciones críticas lancen esta excepción si se da el caso, con un mensaje indicativo del tipo de
error (mensaje incluido en la excepción, no salida a pantalla!).
Construir un programa que pruebe el funcionamiento de la clase Fracción y sus operaciones.

Ejercicio 8: Suma de números

Construir un programa que reciba una serie de números (enteros) introducidos como parámetros desde la línea
de comandos, los sume y visualice el resultado de la suma. En caso de que alguno de los números introducidos
no sea un entero, el programa lo ignorará, mostrará un mensaje de error y continuará con la suma del resto de
los números.
Ayuda: Para resolver este ejercicio puede ser interesante que hagas uso de la clase Integer.
3693742
(*)http://aprendizyestudiante.wordpress.com/2010/11/13/soluciones-a-ejercicios-excepciones/
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: }

// 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: }

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

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:

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

Vamos a ver un ejemplo de polimorfismo en Java con el uso de interfaces. En la definición de Polimorfismotenemos:

El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general, en
lugar de hacerlo en forma específica. En general nos sirve para programar objetos con características comunes y que todos
estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la superclase. Esto nos
simplifica la programación.

No nos vamos a enfocar mucho en la teoría sino en la parte práctica. Vamos a usar una interfaz para aplicar el concepto de
polimorfismo.

Primero creamos un proyecto Java en Eclipse. y vamos a crear en el src el package llamado com.practica.polimorfismo.

Ahora vamos a crear la clase Figura.java que contendrá el siguiente código:

publicclass Figura {

private String nombre;

private String color;

public Figura(String nombre) {

super();

this.nombre = nombre;
}

public Figura(String nombre, String color) {

super();

this.nombre = nombre;

this.color = color;

public String getNombre() {

return nombre;

publicvoid setNombre(String nombre) {

this.nombre = nombre;

public String getColor() {

return color;

publicvoid setColor(String color) {

this.color = color;

Esta va a ser nuestra super clase de la cual heredarán otro tipo de figuras. Esta clase es simplemente un POJO que tiene el
nombre y el colo de la figura y sus getters y setters y dos constructores, aunque solo usaremos uno.

Ahora vamos a crear una interfaz. En Eclipse nos vamos a File -> New -> Other -> Interface. La interfaz se llamara
OperacionesFigura.java Esta interfaz contendrá el siguiente código:

package com.practica.polimorfismo;

publicinterface OperacionesFigura {

double calcularArea();

Figura figura();

Básicamente la interfaz tendrá dos métodos. Uno es el método calcularArea() que devolverá un double con el valor del área
de la figura, y otro método que nos devolverá todo el objeto Figura. Como sabemos cada figura tiene diferente forma de
calcular el área, pero todas tienen esta característica por eso las figuras que implementen esta interfaz deberán implementar
estos dos métodos.
Ahora vamos a crear la clase Triángulo.java. Esta clase va a extender o heredar de Figura y a implementar la interfaz
OperacionesFigura.

package com.practica.polimorfismo;

publicclass Triangulo extends Figura implements OperacionesFigura {

privatedouble base;

private Double altura;

public Triangulo(String nombre, String color, double base, Double altura) {

super(nombre, color);

this.base = base;

this.altura = altura;

@Override

publicdouble calcularArea() {

return (base * altura) / 2;

publicdouble getBase() {

return base;

publicvoid setBase(double base) {

this.base = base;

public Double getAltura() {

return altura;

publicvoid setAltura(Double altura) {

this.altura = altura;

@Override

public Figura figura() {

return new Figura(getNombre(), getColor());

}

Triangulo.java tendrá los atributos propios de un triángulo que son base y altura y además los atributos de la super clase
Figura, es decir el nombre y el color. Aquí al implementar la interfaz tenemos el método calcularArea() que es base * altura
dividido para 2, en el método figura retornamos una nueva Figura obteniendo el nombre y el color de la super clase. Además
tenemos un constructor con todos los atributos de Triangulo y de la super clase Figura.

Ahora aplicamos lo mismo a otra figura. Creamos la clase Circulo.java:

package com.practica.polimorfismo;

importstatic java.lang.Math.*;

publicclass Circulo extends Figura implements OperacionesFigura {

privatedouble radio;

public Circulo(String nombre, String color, double radio) {

super(nombre, color);

this.radio = radio;

/*

* (non-Javadoc)

* @see com.practica.polimorfismo.OperacionesFigura#calcularArea()

*/

@Override

publicdouble calcularArea() {

returnPI * pow(radio, 2);

publicdouble getRadio() {

return radio;

publicvoid setRadio(double radio) {

this.radio = radio;

@Override
public Figura figura() {

returnnew Figura(getNombre(), getColor());

Tiene la misma estructura que Triangulo. En este caso tiene como atributo el radio del círculo y en calcularArea() aplicamos
la fórmula del área del círculo.

Una vez realizado esto vamos a ver cómo ejecutar estos procedimientos. Para ello creamos la clase
CalcularOperacionesFigura.java que contendrá el siguiente código:

package com.practica.polimorfismo;

import java.util.ArrayList;
import java.util.List;

public class CalcularOperacionesFigura {

/**
* @param args
*/

public static void main(String[] args) {

OperacionesFigura of = new Triangulo(“Triangulo”, “Azul”, 15.0, 3.0);
OperacionesFigura of2 = new Circulo(“Circulo”, “Verde”, 12.3);
List<OperacionesFigura> lista = new ArrayList<OperacionesFigura>();
lista.add(of);
lista.add(of2);

calcularArea(lista);
}

public static void calcularArea(List<OperacionesFigura> listaOperacionesFiguras) {

for (OperacionesFigura of : listaOperacionesFiguras) {
System.out.println(“Area es: ” + of.calcularArea());
System.out.println(“Nombre es: ” + of.figura().getNombre());
System.out.println(“Color es: ” + of.figura().getColor());
}
}

Analicemos un poco el código.

En el método main creamos una instancia de la interfaz OperacionesFigura y le decimos que es igual a new Triángulo y
llenamos los valores del constructor: nombre, color, base, altura. Podemos hacer esto porque Triángulo implementa
OperacionesFigura. Luego hacemos lo propio para Circulo.java y le instanciamos desde la interfaz.

Hecho esto creamos una lista genérica de la interfaz List<OperacionesFigura> lista, como es genérica solo se puede agregar
a la lista objetos de tipo OperacionesFigura. Hecho eso agregamos a la lista las dos interfaces que instanciamos
anteriormente

Ahora creamos un método que se llama calcularArea que recibe como parámetro una lista de interfaz de tipo
OperacionesFigura. Luego con un foreach recorremos nuestra lista y accedemos a los métodos de la interfaz que son
calcularArea() y figura() y de esa manera podemos obtener el área de la Figura que creamos en la instancia. Nótese que se
accede a los métodos de la interfaz y no de Triangulo o Circulo. De esta manera la interfaz sabrá qué calculo debe hacer para
obtener el área gracias a la implementación de la interfaz.