Práctica 10 V1

Vista previa del material en texto

Carátula para entrega de prácticas 
 
 
Facultad de Ingeniería 
 
 
Laboratorio de docencia 
 
 
Laboratorios de computación 
salas A y B 
 
 
Profesor: Saavedra Hernández Honorato Ing. 
 
Asignatura: Programación Orientada a Objetos 
 
Grupo: 1 
 
No de Práctica(s): 10 
 
Integrante(s): 
Ayala Trejo Albanya Yendalli Téllez González Jorge Luis 
Méndez Costales Luis Enrique Villamar Cortes Juan Antonio 
Santana Sánchez María Yvette Zecua Salinas Juan Carlos 
Téllez González Jorge Luis 
Villamar Cortes Juan Antonio 
Zecua Salinas Juan Carlos 
No. de Equipo de 
cómputo empleado: --- 
 
No. de Lista o Brigada: --- 
 
Semestre: 2020-2 
 
Fecha de entrega: 21/04/2020 
 
Observaciones: 
 
 
 
 
 CALIFICACIÓN: __________ 
Facultad de Ingenierı́a Programación Orientada a Objetos
Índice
1. Objetivo 2
2. Introducción 2
3. Excepciones 3
3.1. Manejo de Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2. Propagación de Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2.1. Throws . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2.2. Throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3. Excepciones propias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4. Conclusiones 10
1
Facultad de Ingenierı́a Programación Orientada a Objetos
1. Objetivo
Identificar bloques de código propensos a generar errores y aplicar técnicas adecuadas para el manejo
de situaciones excepcionales en tiempo de ejecución.
2. Introducción
Para ahondar mejor en este tema de errores, debemos mencionar la ley del Pareto, conocida como la regla
de 80/20 que explica que el 80% de las consecuencias vienen del 20% de las causas.
Una máxima en el desarrollo de software asegura que el 80% de esfuerzo produce el 20% de código,
pero en términos de calidad el 80% de las fallas de una aplicación son producidas por ese 20% de código,
por este motivo, detectar y manejar errores es la parte más importante de una aplicación extensa.
Figura 1: el 20% de los esfuerzos generan el 80% de los resultados.
Clasificaremos en tres tipos los errores más usuales:
Errores sintácticos: Son aquellos errores que se generan por infringir las normas de escritura de un
lenguaje (coma, punto y coma, dos puntos, palabras mal escritas), normalmente son detectados por el
compilador o el intérprete.
Errores semánticos o lógicos: Este tipo de errores son sutiles y se producen cuando la sintaxis del
código es correcta pero su semántica o significado no es la que se pretendı́a. Los compiladores o
intérpretes sólo se ocupan de la estructura del código que se escribe y no de su significado, por esto,
un error semántico puede hacer que el programa termine de forma incorrecta.
Los errores de este tipo no tienen por qué manifestarse de manera evidente, un programa puede
continuar su ejecución y tener este tipo de errores. Se puede notar el error con datos incorrectos o
haciendo cosas que no se pretendı́a con el programa, son los tipos de errores denominados lógicos
puesto que la falla está precisamente en su lógica.
2
Facultad de Ingenierı́a Programación Orientada a Objetos
Errores de ejecución: Son errores que se presentan cuando la aplicación se está ejecutando, se puede
producir por un uso incorrecto del programa por parte del usuario (al ingresar un valor incorrecto) o
pueden ser debido a errores de programación (acceder a localidades no reservadas o hacer divisiones
no permitidas) puede ser también debido al mal uso de algún recurso externo al programa (memoria
insuficiente o que no se puede acceder a un archivo).
Error en tiempo de ejecución: Los de este tipo ocurren cuando la aplicación termina abruptamente,
sin embargo, los lenguajes orientados a objetos proveen mecanismos para manejar errores de ejecu-
ción.
3. Excepciones
Las excepciones en Java hacen énfasis a los errores cuando se altera el flujo normal en tiempo de ejecución
(cuando el programa se está ejecutando), y esto ocurre cuando se producen errores en algunas de las ins-
trucciones o procedimientos del programa. Algunos ejemplos de excepciones son, por ejemplo, cuando se
hace una división entre cero, cuando un objeto es “null” y no puede serlo, cuando no se abre correctamente
un fichero, entre otras.
Las excepciones se dividen en dos Grandes grupos, los cuales son:
Excepciones marcadas: Son aquellas donde la captura es obligatoria.
Excepciones no marcadas: Son aquellas donde las excepciones son en tiempo de ejecución. No es
obligatorio capturarlas.
Aunque la mayorı́a de los lenguajes de programación actuales ofrecen o dan algún tipo de manejo
de excepciones, el soporte de Java es fácil de usar y muy flexible.
Figura 2: Diagrama que muestra los tipos de excepciones presentes en Java a partir de la clase Throwable.
3
Facultad de Ingenierı́a Programación Orientada a Objetos
3.1. Manejo de Excepciones
Para manejar una excepción se utilizan las palabras reservadas try y catch.
try: El bloque try es utilizado para definir el bloque de código en el cual una excepción pueda ocurrir.
catch: Los bloques catch son utilizados para definir un bloque de código que maneje la excepción.
Las excepciones son objetos que contienen información del error que se ha producido. Heredan de
la clase Exception que a su vez hereda de la clase Throwable.
Figura 3: Ejemplo de un programa con un bloque catch capaz de manejar una excepción que pueda pre-
sentarse.
Si no se captura la excepción interviene un manejador por defecto que normalmente imprime in-
formación que ayuda a encontrar dónde y cómo se produjo el error, sin embargo, como la excepción no es
controlada, ésta se propaga hasta llegar al método principal y termina abruptamente el programa.
Figura 4: Ejecución del programa sin el bloque catch.
4
Facultad de Ingenierı́a Programación Orientada a Objetos
Figura 5: Bloque catch aplicado.
La palabra reservada finally permite definir un tercer bloque de código dentro del manejador de
excepciones. Este bloque le indica al programa las instrucciones a ejecutar de manera independiente de los
bloques try-catch, es decir, si el código del bloque try se ejecuta de manera correcta, entra al bloque finally;
si se genera un error, después de ejecutar el código del bloque catch ejecuta el código del bloque finally.
Figura 6: Ejemplo de un bloque finally que se ejecuta independientemente si el bloque try se ejecutó o no.
Figura 7: Resultado obtenido.
Existe la posibilidad de tener más de un bloque catch dentro de un mismo programa, cuidando
de que las excepciones se encuentren acomodadas de las más especı́ficas a las más generales, como en el
siguiente ejemplo.
5
Facultad de Ingenierı́a Programación Orientada a Objetos
Figura 8: Ejemplo de múltiples bloques catch.
Si este orden no es respetado, es decir, se capturan las excepciones de las más generales a las más
especı́ficas, todas las excepciones caerı́an en la más general (Exception) y no habrı́a forma de enviar un error
a las excepciones más particulares (ArithmeticException); resultado en un error inevitable de compilación
a bytecodes.
Figura 9: Error de compilación por un orden incorrecto de captura de las excepciones.
6
Facultad de Ingenierı́a Programación Orientada a Objetos
3.2. Propagación de Excepciones
Para tratar una excepción no es completamente necesario hacerlo en un bloque manejador de excepciones:
es posible tratarlo dentro de cualquier método donde se debe indicar explı́citamente el cómo se va a tratar.
De esta forma la propagación de excepciones se da cuando tenemos varios métodos; si uno de estos
métodos no trata la respectiva excepción se pasa de método en método hasta llegar a uno donde contenga
los bloques try/catch respectivos. De no ser ası́, llega al último método al “main” y en caso de no tenerseun
bloque de captura, se produce un error de ejecución.
Figura 10: Ejemplo de propagación: una excepción enviada desde miMetodo al método principal.
Si el ejemplo anterior se ejecuta, el resultado es el siguiente:
Figura 11: Salida obtenida.
Es posible observar que en el código anterior que la excepción se dio en la lı́nea 5 dentro del método
miMetodo, pero como este no la trato, se propagó al main donde esta fue atrapada y tratada.
3.2.1. Throws
La palabra reservada throws sirve para indicar que un determinado método va a lanzar una o más excep-
ciones de un tipo en especifico o general.
7
Facultad de Ingenierı́a Programación Orientada a Objetos
Figura 12: Ejemplo del uso de throws en el ejemplo abordado en [10].
3.2.2. Throw
La palabra reservada throw sirve para lanzar explı́citamente una excepción. Solo se puede utilizar si es
dentro de un manejador de excepciones o de un método que garantice que lanzará una excepción de ese
tipo.
Figura 13: La excepción fue lanzada en la lı́nea 6 donde justamente se colocó la palabra reservada throw.
8
Facultad de Ingenierı́a Programación Orientada a Objetos
3.3. Excepciones propias
Es posible crear clases que se comporten como excepciones, para ello es necesario heredar de Exception o
de Throwable. Estas excepciones se invocan y se pueden arrojar de la misma manera en la que se utilizan
las excepciones del API.
Un posible ejemplo se presenta en esta situación: Para una aplicación bancaria se desea lanzar una
excepción propia cuando el saldo de una cuenta sea insuficiente para realizar una operación. La solución se
compone de 3 clases:
La clase Cuenta modela a una cuenta bancaria inicializada con un balance de $0. Ası́ mismo, imple-
menta métodos para depositar o retirar dinero y consultar el saldo.
Figura 14: Clase Cuenta.
La clase SaldoInsuficienteException que hereda de Exception permite definir una excepción propia
que será lanzada cuando se desee retirar más dinero del que se dispone en la cuenta.
Figura 15: Clase Cuenta.
En la clase Cajero se encuentra el método principal que crea un objeto de tipo de tipo Cuenta para,
después, hacer uso múltiple de los métodos definidos.
9
Facultad de Ingenierı́a Programación Orientada a Objetos
Figura 16: Clase Cajero.
Figura 17: Salida obtenida; nótese que el programa no ejecuta el resto del bloque tras ser lanzada la
excepción.
4. Conclusiones
Este acercamiento al manejo de excepciones resulta ser una experiencia valiosa para nuestra formación en
Java, ya que su uso resulta indispensable en diversas situaciones que requieran consideraciones adicionales
para evitar errores durante la ejecución.
Comprender la propagación de excepciones es importante para detectar bloques conflictivos de códi-
10
Facultad de Ingenierı́a Programación Orientada a Objetos
go y realizar las correcciones pertinentes en el mismo. De igual forma, su correcto tratamiento es importante
para el éxito del programa; un manejo inadecuado resultará incluso en errores de ejecución.
Finalmente, la experiencia obtenida resulta altamente aplicable a otros ámbitos donde se requiera su
uso. Por ejemplo, el manejo de archivos externos en Java requiere como condición indispensable el uso de
los bloques try-catch, ası́ como el manejo de diversas excepciones I/0 que puedan presentarse. Entre otras
aplicaciones, su importancia implica que cualquier programador de Java debe conocer su uso.
Referencias
[1] Excepciones y errores. Recuperado de: http://lcp02.fi-b.unam.mx/static/docs/PRACTICAS_
POO/poo_p10.pdf. Fecha de consulta: 18/04/2020.
Los créditos de las fotografı́as pertenecen a sus respectivos autores. c©
LATEX
11
http://lcp02.fi-b.unam.mx/static/docs/PRACTICAS_POO/poo_p10.pdf
http://lcp02.fi-b.unam.mx/static/docs/PRACTICAS_POO/poo_p10.pdf