MÓDULO

Área: TECNOLOGÍA

4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA)
Módulo: Conceptos básicos
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA)

Conceptos básicos
Índice

Tabla de contenido
Índice .....................................................................................................................................................................2
Mapa de Contenido ................................................................................................................................................3
Introducción ...........................................................................................................................................................4
1. Colecciones en Java .....................................................................................................................................5
1.1 ¿Qué son las Colecciones en Java? ..............................................................................................................5
1.1.1 List …………………………………………………………………………………………………………………………………………………………5
1.1.2 Set …………………………………………………………………………………………………………………………………………………………7
1.1.3 Map ..............................................................................................................................................................9
2. Manejo de excepciones .............................................................................................................................15
2.1 Try-Catch ....................................................................................................................................................16
2.1.1 Try ……………………………………………………………………………………………………………………………………………………….16
2.1.2 Catch ..........................................................................................................................................................17
2.2 finally..........................................................................................................................................................18
2.3 throw y throws .........................................................................................................................................20
2.4 Excepciones personalizadas .......................................................................................................................22
3. Cierre ................................................................................................................................................................28
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA)

Conceptos básicos
Mapa de Contenido
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 4

Conceptos básicos
Al finalizar el módulo, habrás ganado una comprensión intermedia de las
estructuras de datos en Java, diferenciando entre List, Set, y Map para el
RESULTADO DE
almacenamiento y manipulación eficiente de datos. Aprenderás a
APRENDIZAJE DEL
implementar un manejo de excepciones robusto, incluyendo la creación y uso
MODULO
de excepciones personalizadas, y a aplicar estos conceptos en un contexto
práctico mediante el desarrollo de un catálogo de libros, reforzando así los
fundamentos de la programación orientada a objetos en Java.

Introducción

El desarrollo de software es un viaje técnico y creativo que combina principios de ingeniería y diseño para
solucionar problemas y mejorar procesos. En este viaje, exploramos los aspectos fundamentales de la
programación en Java, uno de los lenguajes más utilizados y robustos en el mundo del desarrollo. Centramos
nuestra atención en el uso eficiente de las colecciones Java a través de List, Set y Map, descubriendo cómo
cada uno de estos tipos de colección se adapta a distintos escenarios de datos y requisitos de rendimiento.
Posteriormente, nos adentramos en el manejo de excepciones, un mecanismo esencial para construir
aplicaciones resilientes y confiables. Aprendimos a personalizar este mecanismo mediante la creación de
nuestras propias excepciones, lo que nos permite responder a situaciones específicas de una manera
controlada. Además, pusimos en práctica estos conceptos mediante el diseño y la implementación de un
catálogo de libros, enfrentando desafíos comunes como la gestión de duplicados y la necesidad de ofrecer
retroalimentación significativa al usuario cuando ocurren errores.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 5

1. Colecciones en Java
Las colecciones en Java son una de las características más poderosas y utilizadas del lenguaje. Te permiten
agrupar y manejar objetos de manera eficiente, lo que es fundamental para prácticamente cualquier tipo de
programa. Imagina las colecciones como cajas donde puedes almacenar, encontrar y organizar objetos, como
si fueran juguetes. Cada tipo de colección en Java es como una caja especializada: algunas están diseñadas para
permitirte acceder rápidamente a tus juguetes, mientras que otras se aseguran de que no tengas juguetes
repetidos.

1.1 ¿Qué son las Colecciones en Java?

En Java, el framework de colecciones es un conjunto de clases e interfaces que implementan estructuras de
datos dinámicas. Puedes pensar en estas estructuras como contenedores que almacenan grupos de objetos.
Diferentes tipos de colecciones son adecuados para diferentes tipos de tareas, y elegir el correcto puede
afectar significativamente la eficiencia de tu programa.

Principales Interfaces del Framework de Colecciones

El framework de colecciones gira en torno a unas pocas interfaces principales, cada una con sus propias
características y usos:

1.1.1 List
La interfaz List en Java es una parte fundamental de las colecciones Java Framework y proporciona una forma
de almacenar elementos de forma secuencial. List es una interfaz genérica, lo que significa que puedes usarla
con cualquier tipo de objetos. En el contexto de la Programación Orientada a Objetos (POO), una List es un
ejemplo de la abstracción, ya que define un conjunto de operaciones que se pueden realizar en una colección
de objetos sin necesidad de preocuparse por los detalles de su implementación.

Características principales de la interfaz List:

• Ordenada: Los elementos en una lista se mantienen en el orden en que se insertaron. Esto permite el
acceso posicional a los elementos.

• Indexada: Cada elemento en una lista tiene un índice basado en su posición, empezando desde 0. Esto
permite operaciones como obtener o establecer elementos en posiciones específicas.

• Permite duplicados: Una lista puede contener duplicados de elementos, es decir, elementos que son
iguales entre sí.

• Flexibilidad: Las listas pueden crecer y encogerse dinámicamente a medida que se agregan o eliminan
elementos.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 6

Implementaciones comunes de List en Java:

• ArrayList: Esta es probablemente la implementación más utilizada. Proporciona acceso aleatorio

rápido a sus elementos, es decir, obtener un elemento por su índice es muy eficiente. No es tan
eficiente para operaciones en medio de la lista, como insertar o eliminar elementos, ya que puede
requerir desplazar elementos.

• LinkedList: A diferencia de ArrayList, LinkedList es eficiente para agregar y eliminar elementos en

cualquier parte de la lista, pero el acceso a elementos específicos por índice es más lento porque
requiere una iteración secuencial desde el inicio o el final de la lista.

• Vector: Similar a ArrayList, pero es sincronizado. Esto significa que es seguro usarlo en contextos
multihilo, pero esto también lo hace menos eficiente en entornos de hilo único debido al overhead de
la sincronización.

Este código demuestra

operaciones básicas con una
lista, como agregar, acceder y
eliminar elementos, así como
iterar sobre la lista. Recuerda,
las listas son una herramienta
extremadamente versátil en la
programación en Java, capaces
de manejar una amplia
variedad de necesidades en el
manejo de colecciones de
datos.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 7

1.1.2 Set
La interfaz Set en Java es otra componente crucial del Java Collections Framework diseñada para almacenar
elementos únicos, es decir, no permite duplicados. Al igual que List, Set es una interfaz genérica, lo que permite
trabajar con diferentes tipos de objetos. Desde la perspectiva de la Programación Orientada a Objetos (POO),
un Set representa un conjunto en el sentido matemático, proporcionando operaciones para agregar, eliminar
y verificar la presencia de elementos, entre otras.

Características principales de la interfaz Set:

• No permite duplicados: Cada elemento puede existir una sola vez en un Set.

• No garantiza el orden: La mayoría de las implementaciones de Set no mantienen los elementos en el

orden en que se insertaron y no garantizan ningún orden al iterar sobre ellos.

• Operaciones básicas: Incluyen añadir, eliminar, y comprobar si un elemento está presente.

Implementaciones comunes de Set en Java:

• HashSet: Es la implementación más utilizada de Set. Utiliza una tabla hash para almacenar los
elementos, lo que significa que no mantiene ningún orden de los elementos. Ofrece buenas
prestaciones para las operaciones de añadir, eliminar y contiene, ya que tienen una complejidad
temporal constante, asumiendo una buena función hash.

• LinkedHashSet: Es una variante de HashSet que mantiene una lista doblemente enlazada de todos los
elementos. Esto significa que itera sobre los elementos en el orden en que fueron insertados, aunque
la inserción, eliminación y consulta siguen siendo eficientes.

• TreeSet: Implementa la interfaz SortedSet, lo que significa que itera sobre los elementos en un orden
ascendente específico. Para ordenar los elementos, TreeSet puede utilizar su orden natural (si
implementan Comparable) o un Comparator proporcionado en el momento de la creación del
conjunto. TreeSet es implementado como un árbol de búsqueda binaria balanceado, por lo que tiene
una complejidad de tiempo logarítmica para las operaciones de añadir, eliminar y contiene.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 8

Ejemplo de uso de la interfaz Set con HashSet:

Este ejemplo ilustra cómo HashSet maneja los

elementos únicos, y cómo se pueden realizar
operaciones comunes como agregar, verificar la
existencia y eliminar elementos. Los Set son
particularmente útiles cuando necesitas
asegurarte de que no hay duplicados en tu
colección de elementos.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 9

1.1.3 Map
La interfaz Map en Java es parte esencial del Java Collections Framework, pero a diferencia de List y Set, no
extiende la interfaz Collection. Un Map en Java es una estructura de datos que asocia claves únicas con valores.
Es una abstracción que representa una relación de correspondencia entre un conjunto de claves y un conjunto
de valores, de manera que a cada clave se le asigna exactamente un valor.

Características principales de la interfaz Map:

• Claves únicas: No se pueden tener claves duplicadas en un Map. Cada clave puede asociarse a
exactamente un valor.

• Valores duplicados permitidos: Mientras que las claves deben ser únicas, los valores pueden
duplicarse. Diferentes claves pueden apuntar al mismo valor.

• No garantiza el orden: Al igual que con Set, la mayoría de las implementaciones de Map no mantienen
un orden específico de sus elementos.

Implementaciones comunes de Map en Java:

• HashMap: Es la implementación de hash de la interfaz Map. No mantiene ningún orden en las claves
o valores. Ofrece un rendimiento constante para las operaciones básicas (get y put), asumiendo una
buena función de dispersión hash.

• LinkedHashMap: Extiende HashMap, pero además mantiene una lista doblemente enlazada a través
de sus entradas. Esto permite iterar sobre el conjunto de entradas, claves o valores, en el orden en que
fueron insertados.

• TreeMap: Implementa la interfaz SortedMap, lo que significa que las claves están ordenadas en un
orden ascendente natural, o por un Comparator proporcionado en el momento de la creación del
mapa. Esto afecta el orden de iteración sobre las claves, valores o entradas del mapa.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 10

Ejemplo de uso de la interfaz Map con HashMap:

 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 11

Este código muestra cómo se pueden realizar operaciones básicas con un Map, como insertar elementos,
acceder a ellos mediante sus claves, iterar sobre el conjunto de entradas, y verificar la presencia de claves o
valores. Los Map son extremadamente útiles cuando necesitas asociar pares clave-valor de manera eficiente,
siendo indispensables en una amplia gama de aplicaciones de programación.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 12

Otros Ejemplos prácticos de implementación de List, Set y Map

Ejemplo de uso de List:

Contexto: Supongamos que estás desarrollando una aplicación para una librería que necesita mantener un
registro de todos los libros que un usuario quiere leer en orden. Los usuarios pueden añadir el mismo libro más
de una vez si deciden leerlo en el futuro nuevamente.

List es ideal cuando necesitas mantener un orden específico de elementos y permitir duplicados.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 13

Ejemplo de uso de Set:

Contexto: Estás desarrollando una aplicación para un evento y necesitas asegurarte de que cada participante
solo esté registrado una vez, independientemente de cuántas veces intenten registrarse.

Set es perfecto para evitar duplicados y cuando el orden de los elementos no importa.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 14

Ejemplo de uso de Map:

Contexto: Estás creando una aplicación para una biblioteca que necesita rastrear quién ha tomado prestado
cada libro. Cada libro es único y solo puede ser prestado a una persona a la vez.

Map es ideal cuando necesitas asociar pares de clave-valor, especialmente cuando cada clave es única y
quieres buscar, insertar o eliminar elementos basándote en claves.

Estos ejemplos ilustran situaciones comunes en el desarrollo de software donde podrías elegir una List, un Set,
o un Map en función de tus necesidades específicas: orden y duplicados para List, unicidad para Set, y
asociaciones clave-valor para Map.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 15

2. Manejo de excepciones
El manejo de excepciones en Java es un mecanismo fundamental para lidiar con errores y condiciones
inesperadas que pueden ocurrir durante la ejecución de un programa. Una "excepción" es un evento (o
problema) que altera el flujo normal de instrucciones en un programa. El manejo adecuado de las excepciones
permite a tu programa reaccionar a estos problemas de manera controlada, realizando acciones como
recuperarse del error, solicitar datos adicionales al usuario o cerrar recursos antes de terminar, en lugar de
simplemente fallar abruptamente.

El manejo de excepciones en Java está profundamente entrelazado con los principios de la Programación
Orientada a Objetos (POO) debido a las siguientes razones:

Encapsulamiento y Abstracción

• Encapsulamiento: El manejo de excepciones fomenta el encapsulamiento al permitir que los métodos

manejen los errores internamente sin exponer los detalles de implementación a los llamadores. Esto
se logra atrapando y manejando las excepciones dentro del mismo bloque de código que podría
lanzarlas, o bien lanzando una excepción más genérica o personalizada que puede ser manejada por el
código que invoca al método.

• Abstracción: Las excepciones permiten a los desarrolladores abstraerse de los detalles de los errores
específicos al trabajar con operaciones de alto nivel. Por ejemplo, un método de lectura de archivos
puede lanzar una IOException sin necesidad de que el llamador conozca todos los posibles errores de
entrada/salida que podrían ocurrir, manteniendo así la abstracción.

Herencia y Polimorfismo

• Herencia: Java utiliza la herencia para organizar las excepciones en una jerarquía de clases. Por
ejemplo, IOException y SQLException heredan de la clase Exception. Esto permite a los
desarrolladores usar polimorfismo para manejar grupos de excepciones de manera más generalizada
utilizando su clase base. Además, permite a los desarrolladores crear sus propias excepciones
personalizadas extendiendo las clases de excepciones existentes.

• Polimorfismo: El manejo de excepciones se beneficia del polimorfismo, permitiendo que un bloque

catch maneje diferentes tipos de excepciones de una manera general. Por ejemplo, un único bloque
catch puede capturar todas las excepciones que son subclases de Exception. Esto también permite que
el código sea más flexible y reutilizable, ya que un método puede lanzar una excepción específica
mientras que el código que lo llama puede elegir capturar una clase de excepción más genérica.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 16

Principios de diseño sólido

El manejo de excepciones también se relaciona con principios de diseño sólido en POO, especialmente el
Principio de Responsabilidad Única (SRP) y el Principio de Sustitución de Liskov (LSP):

• Principio de Responsabilidad Única (SRP): Este principio establece que una clase debe tener una sola
razón para cambiar. Manejar las excepciones de manera apropiada ayuda a adherirse a este principio
al separar la lógica de manejo de errores de la lógica de negocio principal del programa.

• Principio de Sustitución de Liskov (LSP): Según este principio, los objetos de una clase base deben
poder ser reemplazados con objetos de sus subclases sin alterar el correcto funcionamiento del
programa. El sistema de excepciones en Java permite esto al permitir que las excepciones derivadas
sean tratadas como su clase base, promoviendo así la reutilización de código y el diseño flexible.

2.1 Try-Catch
El mecanismo try-catch en Java es fundamental para el manejo de excepciones, permitiendo a los programas
manejar errores de manera controlada y elegante. Este mecanismo se basa en dos bloques principales: el
bloque try y uno o más bloques catch.

2.1.1 Try
Bloque Try

El bloque try es donde colocas el código que podría lanzar una excepción. Este bloque actúa como una especie
de "zona de prueba" para el código que es potencialmente problemático. Al ejecutarse el código dentro del
bloque try, si ocurre una excepción, la ejecución del bloque se detiene inmediatamente y Java busca un bloque
catch correspondiente que pueda manejar esa excepción específica.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 17

2.1.2 Catch
Bloque Catch

Después del bloque try, debes proporcionar al menos un bloque catch si esperas manejar excepciones. El
bloque catch define el tipo de excepción que puede manejar y proporciona un nombre de variable para acceder
a la instancia de la excepción capturada. Dentro de este bloque, defines cómo manejar la excepción, lo que
podría incluir la recuperación del error, el registro de la excepción, la presentación de un mensaje al usuario,
entre otras acciones.

Puedes tener múltiples bloques catch después de un único bloque try para manejar diferentes tipos de
excepciones de manera diferente. Java revisa los bloques catch en el orden en que aparecen y utiliza el primero
que es compatible con el tipo de excepción lanzada.

Ejemplo Completo

Vamos a ver un ejemplo para ilustrar cómo funciona:

 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 18

En el ejemplo anterior, intentamos dividir un número por cero, lo que normalmente resultaría en una
ArithmeticException. El bloque try contiene el código que lanza esta excepción. Inmediatamente después de
que se lanza la excepción, el control se transfiere al primer bloque catch compatible, que en este caso es el
que maneja ArithmeticException. Si hubiera otro tipo de excepción, el segundo bloque catch podría manejarlo.

Consideraciones Importantes

• Orden de los bloques catch: Si tienes múltiples bloques catch, deben ir de lo más específico a lo más
general. Si colocas un bloque catch que captura Exception (la clase base para muchas excepciones en
Java) antes que uno para una excepción más específica, el bloque más general capturaría la excepción
primero, lo que podría impedir que el bloque específico se ejecute.

• Bloque finally: Además de try y catch, puedes utilizar un bloque finally que se ejecutará siempre,
independientemente de si se lanzó una excepción y se capturó o no. Esto es útil para limpiar recursos,
como cerrar archivos o conexiones a bases de datos.

2.2 finally
El bloque finally en Java es una parte del mecanismo de manejo de excepciones que se ejecuta después de los
bloques try y catch. La característica principal del bloque finally es que se ejecuta siempre,
independientemente de si ocurrió una excepción en el bloque try y de si esa excepción fue capturada o no por
un bloque catch. Esto lo hace ideal para realizar operaciones de limpieza que deben ejecutarse no importa qué,
como cerrar recursos (archivos, conexiones de red, etc.) que fueron abiertos en el bloque try.

Características del bloque finally:

• Ejecución Garantizada: Se ejecuta siempre después de los bloques try y catch, incluso si se lanza una
excepción no capturada en el try o en un catch.

• Para Limpieza de Recursos: Es ideal para cerrar o liberar recursos que se abrieron o se reservaron en
el bloque try, asegurando que estos recursos no queden "colgados" y que el sistema los libere
apropiadamente.

• Funciona con o sin catch: Puede usarse después de un bloque try sin necesidad de que haya un bloque
catch entre ambos. Esto significa que puedes utilizar try con finally incluso si no necesitas capturar
excepciones específicas.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 19

Ejemplo de uso de finally

Vamos a ver un ejemplo que ilustra el uso de finally para cerrar un recurso, independientemente de si se
produjo una excepción o no:

En este ejemplo, el bloque finally se utiliza para cerrar un FileReader y asegurarse de que el recurso se libere
correctamente, independientemente de si ocurrió una excepción al intentar abrir el archivo o durante su
procesamiento.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 20

Casos en los que finally no se ejecuta

Aunque el bloque finally está diseñado para ejecutarse casi siempre, existen situaciones muy específicas y raras
en las que no se ejecutará, como:

• Si se llama a System.exit() antes de que se alcance el bloque finally.

• Si el hilo que está ejecutando el bloque try es interrumpido o muere antes de entrar al bloque finally.

• Si ocurre un error fatal en la JVM que impide la continuación de la ejecución.

Buenas prácticas

• Evita cambiar el flujo de ejecución desde finally: Por ejemplo, evita usar return, continue, o break
dentro de un bloque finally, ya que puede hacer que el código sea difícil de entender y mantener.

• Utiliza finally para limpiar recursos: Siempre que adquieras recursos que necesiten ser liberados,
asegúrate de liberarlos en un bloque finally para evitar fugas de recursos.

2.3 throw y throws

Los conceptos de throw y throws en Java son fundamentales para el manejo de excepciones, permitiendo a
los programas señalar problemas y delegar la responsabilidad de manejar estas situaciones. Aunque ambos
están relacionados con las excepciones, se utilizan en diferentes contextos y tienen propósitos distintos.

Uso de throw

La palabra clave throw se utiliza para lanzar explícitamente una excepción en Java. Esto puede ser útil cuando
quieres crear una excepción personalizada o lanzar una excepción existente bajo ciertas condiciones. Usar
throw te permite simular una situación de error o validar argumentos y estados de objetos antes de proceder
con la ejecución del programa.

Ejemplo de uso de throw:

En este ejemplo, si el argumento num es menor que 1, se lanza una IllegalArgumentException con un mensaje
específico. Esto interrumpe el flujo normal del programa y la excepción debe ser capturada y manejada en
algún punto del código que invoque este método.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 21

Uso de throws

La palabra clave throws se utiliza en la firma de un método para declarar que dicho método puede lanzar una
o más excepciones durante su ejecución. No lanza la excepción por sí misma, sino que indica al compilador y a
otros desarrolladores que ciertas excepciones pueden necesitar ser manejadas cuando el método es invocado.

Ejemplo de uso de throws:

En este caso, el método leerArchivo declara que puede lanzar una FileNotFoundException. Cualquier código
que llame a leerArchivo debe manejar esta excepción, ya sea con un bloque try-catch o propagándola más
arriba en la pila de llamadas con throws.

Diferencias Clave

• throw es para lanzar una excepción específica en un punto específico del código. Es una acción.

• throws se usa en la declaración de un método para indicar que puede lanzar ciertas excepciones,
dejando la responsabilidad de manejar esas excepciones al código que invoca el método. Es una
declaración.

Buenas Prácticas

• Utiliza throw para controlar el flujo de tu programa lanzando excepciones en situaciones específicas donde
se violan las condiciones esperadas.

• Emplea throws para comunicar los riesgos de excepción de tus métodos a los desarrolladores que utilizan
tu código, asegurando que las excepciones sean manejadas adecuadamente.

• Maneja las excepciones lo más cerca posible del punto donde ocurren, a menos que una propagación sea
necesaria para una gestión más centralizada de errores.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 22

2.4 Excepciones personalizadas

La creación de excepciones personalizadas en Java te permite definir tipos de excepciones específicos para tu
aplicación, lo que puede mejorar la claridad del código y facilitar el manejo de errores. Las excepciones
personalizadas son útiles cuando las excepciones estándar de Java no proporcionan suficiente información
sobre el error ocurrido o cuando deseas capturar y manejar condiciones específicas de error en tu aplicación.

Pasos para definir una excepción personalizada:

1. Definir una nueva clase que extienda Exception o RuntimeException.

2. Proporcionar constructores que permitan crear instancias de tu excepción con mensajes de error
personalizados o causas encapsuladas.

Ejemplo de una excepción personalizada

Supongamos que estás construyendo una aplicación para gestionar una librería y quieres lanzar una excepción
específica cuando se intenta añadir un libro que ya existe en el catálogo.

1. Identificación de Entidades Principales

Empieza por identificar las entidades principales de tu aplicación basándote en los requisitos. En el caso del
catálogo de libros, las entidades principales podrían ser:

• Libro: Representa los datos de un libro.

• CatalogoLibros: Maneja una colección de libros, incluyendo operaciones como añadir o buscar libros.

2. Definición de Responsabilidades

Para cada entidad identificada, define sus responsabilidades principales. Esto te ayudará a entender qué
métodos y atributos cada clase debería tener.

• Libro:

• Atributos: ISBN, título, autor, etc.

• Métodos: posiblemente getters y setters para los atributos, y cualquier otro método relevante
para la lógica de negocio relacionada con un libro individual.

• CatalogoLibros:

• Atributos: Una colección que almacena los libros.

• Métodos: añadirLibro(), buscarLibro(), eliminarLibro(), etc.

 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 23

3. Identificación de Necesidades Especiales

Considera si necesitas clases o mecanismos especiales para manejar situaciones particulares, como
excepciones personalizadas.

• LibroYaExisteException: Una excepción personalizada que se lanza cuando se intenta añadir un libro
que ya existe en el catálogo.

4. Planificación de Interacciones

Piensa en cómo interactuarán tus clases entre sí y con el usuario o el sistema. Esto puede ayudarte a identificar
clases adicionales o servicios que necesites.

• PruebaCatalogoLibros: Un programa de prueba o clase main que demuestre el uso de CatalogoLibros

y maneje LibroYaExisteException.

Lista Detallada de Clases Necesarias

1. Libro

• Atributos: isbn, titulo, autor.

• Métodos: Constructor, getters.

2. LibroYaExisteException

• Extiende de Exception o RuntimeException.

• Métodos: Constructores que permiten especificar el mensaje de error y/o la causa.

3. CatalogoLibros

• Atributos: colección de libros (p.ej., HashMap<String, Libro> donde la clave podría ser
el ISBN).

• Métodos: añadirLibro(), buscarLibro() (opcional), eliminarLibro() (opcional), etc.

4. PruebaCatalogoLibros (opcional)

• Métodos: main(), donde se crean instancias de Libro, se intenta añadirlos a

CatalogoLibros, y se manejan las excepciones.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 24

Paso 1: Vamos a definir una clase básica Libro. Esta clase representará los libros que quieres añadir al catálogo.
Incluirá algunos campos comunes como el ISBN, título y autor, y proporcionará un constructor para inicializar
esos campos.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 25

Paso 2: Crear la Excepción Personalizada

Paso 3: Usar la Excepción Personalizada

Ejemplo de cómo podríamos usar esta excepción personalizada en tu aplicación:

En este ejemplo, el método añadirLibro lanza una LibroYaExisteException si se intenta añadir un libro que ya
está en el catálogo, proporcionando un mensaje de error específico que incluye el ISBN del libro duplicado.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 26

Buenas Prácticas

• Utiliza excepciones personalizadas con moderación: No todas las situaciones de error requieren la
creación de excepciones personalizadas. En muchos casos, las excepciones estándar de Java son
suficientes.

• Nombra tus excepciones de manera clara: El nombre de la excepción debe indicar claramente la
naturaleza del error, como ArchivoNoEncontradoException o ConexionFallidaException.

• Documenta tus excepciones personalizadas: Asegúrate de documentar cuándo y por qué se lanza una
excepción personalizada, para que otros desarrolladores entiendan cómo y cuándo manejarla.

*El ISBN, que significa "International Standard Book Number" (Número Estándar Internacional de Libros), es un
identificador único para libros, previsto para uso comercial.

Paso 4 (opcional): Finalmente, después de haber definido todas las clases necesarias para la lógica de tu
aplicación, puedes crear un programa de prueba para demostrar cómo funcionan juntas. Este programa creará
instancias de Libro, intentará añadirlas al CatalogoLibros y manejará cualquier excepción
LibroYaExisteException que se lance en el proceso.

Este programa de prueba intenta añadir dos libros al catálogo, donde el segundo libro tiene el mismo ISBN que
el primero, lo que debería causar que CatalogoLibros.añadirLibro lance una LibroYaExisteException.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 27

Paso 5: Resultado.

La salida del programa de prueba está mostrando exactamente lo que esperaríamos dada la lógica que hemos
discutido:

1. Agregamos el primer libro y el programa indica que se ha añadido exitosamente.

2. Intentamos agregar un segundo libro con el mismo ISBN, lo que desencadena la excepción
LibroYaExisteException que hemos definido.

3. La excepción se captura y se maneja adecuadamente, mostrando un mensaje de error en la consola.

Esto significa que la excepción personalizada está funcionando como se esperaba, y el flujo de manejo de
errores está correctamente implementado. La ejecución del programa no se detuvo abruptamente, sino que
proporcionó un mensaje de error significativo y terminó normalmente con el código de salida 0, lo que indica
que no hubo errores en tiempo de ejecución que el sistema operativo detectara como anormales.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 28

3. Cierre
Habiendo navegado a través de la implementación de estructuras de datos clave y el manejo sofisticado de
excepciones en Java, hemos adquirido no solo conocimiento, sino también práctica en la aplicación de estos
conceptos esenciales. El ejercicio de construir un catálogo de libros sirvió como un microcosmos del proceso
de desarrollo de software, en el que definimos entidades, gestionamos errores y garantizamos la integridad de
los datos. Este proceso reafirmó la importancia de un diseño cuidadoso y de seguir buenas prácticas, como la
definición clara de responsabilidades de clase y el manejo prudente de excepciones. Además, ilustró la
naturaleza iterativa del desarrollo de software, en la cual la revisión y la mejora continuas son vitales para el
éxito del proyecto. Con estas herramientas y enfoques, estamos bien equipados para enfrentar desafíos más
grandes y construir aplicaciones robustas y eficientes en Java, manteniendo siempre en mente que el
aprendizaje y la adaptación son tan constantes como el cambio mismo en el mundo del desarrollo de software.