UNIVERSIDAD TECNOLÓGICA DE LOS ANDES

FACULTAD DE INGENIERÍA

DEPARTAMENTO ACADÉMICO DE INGENIERÍAS

E.P. DE ING. DE SISTEMAS E INFORMÁTICA

Título del Trabajo: Proyecto de Sistema de Gestión de Hospital (Herencia, Agregación y

Composición)

Curso: Programación Orientada a Objetos

Tipo de trabajo: Investigación – Proyecto de laboratorio

Integrantes Grupo N° 7:

 Ocampo Torres Ricardo Salvador

 Alarcon Otazu Alexander Gabriel
 Zapata Salas María Esther

Docente: Ing. Godofredo Poccori Umeres

Semestre académico: 2025-II
Contenido
III. Introducción............................................................................................................................3
IIV. Planteamiento del Problema..................................................................................................3
V. Objetivos..................................................................................................................................4
Objetivo Específico (Agregación y Composición)............................................................4
VI. Marco Teórico.........................................................................................................................5
VII. Desarrollo del Proyecto..........................................................................................................9
VIII. Resultados...........................................................................................................................15
IX. Conclusiones.........................................................................................................................16
X. Recomendaciones..................................................................................................................16
XI. Referencias Bibliográficas......................................................................................................16
XII. Anexos..................................................................................................................................16
III. Introducción

La Programación Orientada a Objetos (POO) constituye una base esencial en el desarrollo de

soluciones informáticas. El presente trabajo plantea la creación de un sistema que, mediante
la aplicación de sus principios, busca mejorar la organización, el control y la eficiencia de los
procesos de un producto o servicio.

En este caso, se propone el desarrollo de un Sistema de Gestión Hospitalaria (SGH), un

entorno donde la administración adecuada de información es fundamental para garantizar una
atención eficiente y segura. La complejidad operativa de un hospital —que abarca el registro
de pacientes, la gestión del personal médico, el control de historiales clínicos y la
organización de recursos internos— exige un enfoque estructurado que permita modelar de
manera clara las relaciones entre las distintas entidades del sistema.

La POO ofrece herramientas idóneas para este propósito, ya que facilita la construcción de
modelos que representan fielmente las entidades reales del hospital mediante el uso de clases,
objetos y relaciones como la herencia, la agregación y la composición. Estas características
permiten reutilizar código, organizar mejor la información y crear un sistema modular,
escalable y fácil de mantener.

Así, este trabajo no solo se centra en aplicar los conceptos teóricos de la POO, sino también
en demostrar cómo estos permiten resolver problemas reales: evitar duplicidad de datos,
asegurar la integridad del historial médico, estructurar correctamente las relaciones entre
personal, pacientes y recursos, y optimizar los procesos internos de la institución. El sistema
desarrollado integra estos principios para ofrecer una solución funcional que mejora la
eficiencia operativa del hospital y sirve como ejemplo práctico del uso adecuado del
paradigma orientado a objetos.

IIV. Planteamiento del Problema

Se requiere desarrollar un sistema orientado a objetos que permita gestionar

información de diferentes tipos de entidades, aplicando reglas específicas para cada
una y centralizando las operaciones en un componente gestor que administre los
procesos del sistema.

(Empresa).
V. Objetivos

• Objetivo General:

Desarrollar un Sistema de Gestión Hospitalaria (SGH) robusto e intuitivo utilizando

Python que implemente los principios de Herencia, Agregación y Composición de la
Programación Orientada a Objetos (POO), con el fin de optimizar y automatizar los
procesos clave de administración de personal, pacientes y recursos.

Identificar el problema general.

La gestión manual o descentralizada de los datos y procesos en el hospital (registro de

pacientes, asignación de médicos, seguimiento de historial, administración de
inventario de equipos), lo cual genera ineficiencia, errores de datos, pérdida de tiempo
administrativo y dificultad para generar informes y tomar decisiones operativas
rápidas.

• Objetivos Específicos:

Objetivo Específico (Herencia)

 Implementar una jerarquía de clases de Personal Hospitalario (ej: Médico, Enfermero,

Administrativo) que hereden de una clase base Persona o Empleado, para asegurar la
reutilización de código y el manejo polimórfico de la información personal común
(nombre, ID, fecha de nacimiento), resolviendo la duplicidad y la inconsistencia en el
registro del personal.
1. Identificar el Problema específico 1.

El sistema actual o el proceso manual exige la reescritura repetitiva de atributos y

métodos comunes (como obtener_nombre()) para cada tipo de empleado, lo que
aumenta la complejidad del código y el riesgo de errores al modificar datos básicos de
empleados.
Objetivo Específico (Agregación y Composición)

 Diseñar la estructura del sistema utilizando Composición para la relación crítica entre
Historial Médico y Paciente (donde el historial existe por el paciente) y Agregación
para la relación entre Hospital y Médico o Equipo (donde el médico o equipo existe
independientemente del hospital), garantizando la integridad referencial de los datos y
la modularidad del sistema.

2. Identificar el Problema específico 2.

Existe dificultad para modelar las relaciones de ciclo de vida entre las entidades
(ejemplo: el historial depende del paciente, mientras que el médico solo está asociado
al hospital), lo que lleva a estructuras de datos rígidas o a la pérdida accidental de
información vital (como el historial del paciente) si la entidad contenedora (el
paciente) se maneja incorrectamente.

VI. Marco Teórico

• Programación Orientada a Objetos: conceptos, características y ventajas.

Concepto.

La programación orientada a objetos se basa en el concepto de crear un modelo del problema

de destino en sus programas. La programación orientada a objetos disminuye los errores y
promociona la reutilización del código. Python es un lenguaje orientado a objetos. Los
objetos definidos en Python tienen las características siguientes:

 Identidad. Cada objeto debe ser distinguido y ello debe poder demostrarse mediante
pruebas. Las pruebas is e is not existen para este fin.
 Estado Cada objeto debe ser capaz de almacenar el estado. Para este fin, existen
atributos, tales como variables de instancias y campos.
 Comportamiento. Cada objeto debe ser capaz de manipular su estado. Para este fin
existen métodos. (IMB, 2021)

Características principales

Abstracción: Permite modelar entidades del mundo real seleccionando solo los detalles
relevantes para la solución del problema. En POO, una clase representa el modelo abstracto,
definiendo los atributos (datos) y métodos (comportamientos) comunes a un conjunto de
objetos.

Encapsulación: Oculta los detalles internos de un objeto y expone solo lo necesario para
interactuar con él a través de una interfaz pública. Esto protege la información y aumenta la
seguridad y fiabilidad del código.

Herencia: Permite que una clase (clase hija) herede propiedades y comportamientos de otra
clase (clase padre). Esto facilita la reutilización de código y la creación de jerarquías de
clases, mejorando la organización del código.

Polimorfismo: Significa "múltiples formas". Permite que objetos de diferentes clases

respondan al mismo mensaje (método) de maneras específicas a su propia clase. Esto se logra
comúnmente con la herencia y la sobrescritura de métodos, lo que hace que el software sea
más flexible y adaptable. (carlemany, 2023)

Ventajas de la POO

Reutilización del código: La herencia permite que las nuevas clases hereden propiedades y
métodos de clases existentes. Esto reduce la necesidad de escribir código repetitivo y acelera
el desarrollo.

Modularidad: La organización del código en objetos y clases facilita la comprensión del

programa y la localización de errores, ya que las responsabilidades están concentradas en
lugares específicos.

Facilidad de mantenimiento y depuración: Al ser modular, es más sencillo modificar o

corregir partes del código sin afectar el funcionamiento del resto. Esto también simplifica la
resolución de problemas, pues se puede diagnosticar el error dentro del objeto o clase
afectada.

Flexibilidad: El polimorfismo permite que objetos de diferentes clases respondan a la misma

función de manera distinta, adaptándose a diferentes contextos y haciendo el software más
adaptable.

Seguridad y control de datos: La encapsulación es un principio que protege los datos

confidenciales y limita el acceso a ciertas partes del código, mejorando la seguridad.
Modelado del mundo real: Permite modelar problemas complejos del mundo real de una
forma más natural, ya que se basa en la idea de objetos que interactúan entre sí. (Unir
Formacion Profesional, 2023)

• Clases y Objetos: definición, atributos, métodos y encapsulamiento.

Clases y objetos

 Clase: Es el plano o molde para crear objetos. Define la estructura y el

comportamiento compartido por todos los objetos de ese tipo.

o Ejemplo: Una clase llamada Coche.

 Objeto: Es una instancia individual de una clase, con su propio estado. Se crea a
partir de la clase.

o Ejemplo: Un Coche específico con marca "Toyota", modelo "Corolla" y color

"rojo".

Atributos

Son las características o datos que describen a un objeto.

Definen el estado del objeto en un momento dado.

Ejemplo: En la clase Coche, los atributos podrían ser marca, modelo y color.

Métodos

Son las acciones o comportamientos que un objeto puede realizar.

Pueden interactuar con los atributos del objeto o con otros objetos.

Ejemplo: En la clase Coche, los métodos podrían ser arrancar() y parar().

Encapsulamiento

Es el principio de agrupar los datos (atributos) y los métodos que operan sobre ellos,
dentro de una única unidad llamada clase.

Restringe el acceso directo a los atributos internos de un objeto, haciéndolos privados.

Se accede a estos atributos y se modifican a través de métodos públicos controlados (como
los getters y setters).

Protege la integridad del objeto, asegurando que los cambios solo se realicen de manera
segura y consistente.

Ejemplo: En la clase Coche, los atributos marca, modelo y color podrían ser privados, y se
utilizarían métodos públicos como setMarca() para modificarlos y getMarca() para
leerlos. (cev, 2020)

• Herencia: reutilización de código y jerarquía de clases.

Herencia: reutilización y extensión

La herencia es un mecanismo que permite a una nueva clase heredar propiedades y métodos
de una clase existente. Facilita la reutilización de código y la creación de jerarquías de clases.

 Reutilización de código: La herencia permite a las clases hijas reutilizar código de

las clases padres, lo que minimiza la redundancia.

 Jerarquía de clases: Establece una relación de tipo «es un/a» entre la clase padre y la
clase hija, facilitando la organización y estructuración del código.

 Sobrescritura y extensión: Las clases hijas pueden sobrescribir o extender las

funcionalidades de la clase padre, lo que ofrece flexibilidad en el desarrollo. (cev,
2020)

• Polimorfismo: comportamiento diferente según el tipo de objeto.

Polimorfismo: flexibilidad e interoperabilidad

El polimorfismo permite que los objetos sean tratados como instancias de sus clases padres o
interfaces, lo que facilita la escritura de código más limpio y flexible.

 Múltiples formas: Significa «muchas formas»; en POO, permite que una interfaz
tenga múltiples implementaciones.

 Interoperabilidad de objetos: Permite que los objetos de diferentes clases sean

tratados como objetos de una clase común.
  Sobrecarga y sobreescritura de métodos: La habilidad de definir métodos con el
mismo nombre pero diferentes implementaciones en clases relacionadas. (cev, 2020)

• Ejemplo aplicado: diseño de la clase base (Clase Padre) y sus derivadas.

VII. Desarrollo del Proyecto

3. 1. Diseño del Sistema:
El diseño se basa en un diagrama de clases que muestra las relaciones entre las clases.

3. 2. Implementación:
Se describen las clases con sus atributos y métodos, aplicando herencia y
polimorfismo.

La clase Padre centraliza la gestión de las clases.

1. MODULARIDAD

“El modularidad consiste en dividir el programa en archivos separados para mantener el

código ordenado y fácil de mantener.

En mi proyecto, cada clase está en su propio módulo.”

Estructura de carpetas:

[Link]
[Link]
 [Link]
historia_clinica.py
[Link]
[Link]
2. ENCAPSULAMIENTO

“El encapsulamiento protege los datos internos de una clase.

En mi proyecto, la Historia Clínica solo puede modificarse mediante métodos autorizados.”

class HistoriaClinica:
def agregar_tratamiento(self, tratamiento: str):
[Link](tratamiento)

Aquí, nadie modifica directamente la lista de tratamientos.

Todos deben usar el método agregar_tratamiento().

Esto evita errores y asegura que la información siga reglas.

3. REUTILIZACIÓN DE CÓDIGO

“La reutilización se logra cuando varias clases usan código heredado de una sola base.
En este proyecto lo hago heredando de Persona.”

class Persona:
def __init__(self, nombre, dni, edad):
[Link] = nombre
[Link] = dni
[Link] = edad

Clases que lo reutilizan:

class Medico(Persona):
...

class Paciente(Persona):
...

Gracias a esto NO repito los atributos ni los métodos básicos.

4. HERENCIA

“La herencia permite crear clases hijas basadas en una clase padre.
En este caso, Médico y Paciente heredan de Persona.”

5. AGREGACIÓN

“La agregación es cuando una clase usa otras que existen independientemente.
El Hospital tiene una lista de médicos, pero los médicos pueden existir sin el hospital.”

class Hospital:
 def __init__(self, nombreHospital):
[Link]: List[Medico] = []

El hospital no crea médicos, solo los agrega con:

hospital.registrar_medico(medico1)

Si el hospital desaparece, el médico puede seguir existiendo → agregación.

class Medico(Persona):
def __init__(self, nombre, dni, edad, especialidad, codigo):
super().__init__(nombre, dni, edad)

Así se aprovechan nombre, dni y edad sin volver a escribirlos.

6. COMPOSICIÓN

“La composición es una relación más fuerte: un objeto depende totalmente del otro.
En mi proyecto, un Paciente crea internamente su Historia Clínica.”

Ejemplo real

class Paciente(Persona):
def __init__(..., codigoHistorial, diagnostico):
[Link] = HistoriaClinica(
codigoHistorial,
diagnostico,
tratamientos=[],
fechaRegistro=[Link]()
)

Sin paciente, esa historia clínica no existe → composición real.

7. FUNCIONES Y MÉTODOS

“Cada clase tiene funciones específicas que cumplen roles organizados.”

Asignar pacientes a un médico

def asignar_paciente(self, paciente):

[Link](paciente)

Agregar tratamiento

[Link].agregar_tratamiento("Paracetamol 500mg cada 8h")

Reporte general

def reporte_general(self):
total_pacientes = sum(len([Link]) for m in [Link])
Mostrar historial

paciente1.mostrar_historial()

Cada función hace exactamente una tarea → esto mejora la claridad y mantenimiento del
sistema.

3. 3. Ejemplo de Ejecución:
Se muestran los casos prácticos de registro y prueba de los métodos identificados
VIII. Resultados
Presentar las salidas del sistema, los cálculos de operciones encontradas y la
validación del

comportamiento polimórfico (silo require).

IX. Conclusiones
• El uso de POO permite crear sistemas modulares, escalables y fáciles de mantener.

• La herencia y el polimorfismo simplifican la gestión de las clases.

• El diseño orientado a objetos mejora la organización y comprensión del código.

X. Recomendaciones (Desarrollo solicitado para la segunda unidad)

• Extender el sistema para incluir persistencia de datos (uso de archivos o bases de

datos).

• Incorporar una interfaz gráfica para una mejor interacción.

• Integrar un módulo de reportes o estadísticas del personal.

XI. Referencias Bibliográficas (Bibliografia usada)

• Deitel, H. & Deitel, P. (2019). Java: How to Program. Pearson Education.

• Sweigart, A. (2020). Automate the Boring Stuff with Python. No Starch Press.

• Pressman, R. (2015). Ingeniería del Software: Un enfoque práctico. McGraw-Hill.

XII. Anexos
Incluir: Informe, código fuente, capturas de pantalla de ejecución y diagrama UML de
clases,

enlace de la publicación.