Módulo 6 - Programación Orientada A Objetos

Programación
Orientada a
Objetos
Módulo 6
Laura Villena
FUNDACIÓN SOCIEDADES DIGITALES
CURSO DESARROLLADOR WEB
CONTENIDO
Introducción al módulo 5 .......................................................................................... 1
Introducción a POO .................................................................................................. 1
Nociones básicas UML ................................................................................................................................ 3
Objetos......................................................................................................................................................... 9
Clases ......................................................................................................................................................... 14
Mensajes, método, variables e instancias ............................................................................................... 19
Constructores, Destructores y Garbage Collector ................................................................................... 23
Relación entre clases y objetos ................................................................................................................ 25
Abstracción ................................................................................................................................................ 28
Encapsulamiento ....................................................................................................................................... 31
Modularidad .............................................................................................................................................. 31
Herencia ..................................................................................................................................................... 33
Polimorfismo ............................................................................................................................................. 36
Tipificación, concurrencia y persistencia ................................................................................................. 38
Laura Villena
POO
Introducción al módulo 5
¡Hola, bienvenido al módulo 6!
En el módulo 6 nos vamos a introducir en los conceptos de Paradigmas de la Programación

y nos centrarnos en entender la Programación Orientada a Objetos, como así también, en
los elementos que la componen.
¡Comencemos!
INTRODUCCIÓN A POO
La Programación Orientada a Objetos, que se abrevia como POO, consiste en un

conjunto de reglas y principios en la programación, conocido como un paradigma de
programación. Su objetivo principal es representar las entidades u objetos del dominio
o enunciado del problema de una manera que se asemeje de manera natural en el
programa.
En un sentido amplio, un paradigma se refiere a una teoría o conjunto de teorías que

sirve de modelo a seguir para resolver situaciones determinadas que se planteen.
“Un paradigma es todo aquel modelo, patrón o ejemplo que debe seguirse en
determinadas situaciones.”
En el paradigma de programación tradicional o estructurada, que era ampliamente

utilizado en el pasado, los programadores solían buscar procesos, en forma de
subproblemas, que al aplicarse a los datos generaban los resultados deseados. Esta
metodología no es incorrecta en absoluto; la estrategia de descomponer un problema
en subproblemas es una técnica básica de resolución de problemas que los
programadores orientados a objetos todavía emplean en el nuevo paradigma. Pero
entonces, ¿cuál es la innovación que trae consigo la Programación Orientada a Objetos
(POO)?
La mera orientación hacia la descomposición de subproblemas resulta insuficiente

cuando se trata de sistemas altamente complejos. Visualizar la estructura general del
sistema se convierte en un desafío y realizar incluso las modificaciones más pequeñas
puede afectar la lógica de un gran número de otras rutinas. Además, se vuelve casi
1
Laura Villena
imposible reconfigurar el sistema para incorporar nuevas funcionalidades complejas que
lo mantengan útil frente a las cambiantes demandas.
La POO introdujo una nueva perspectiva en la forma de programar, buscando aportar

claridad y naturalidad a la manera en que se aborda la creación de programas. Ahora, el
objetivo principal no es identificar procesos, sino identificar actores: las entidades u
objetos que forman parte del escenario o dominio del problema. Estos objetos no solo
poseen datos asociados, sino que también tienen comportamientos que pueden
ejecutar.
Pensemos en un objeto como si fuera un robot virtual: el programa contendrá

numerosos robots virtuales (objetos de software) que son expertos en realizar tareas
específicas de manera eficiente y ordenada. Estos objetos pueden interactuar con otros
robots virtuales (objetos) para resolver el problema planteado por el programador.
En resumen, podemos afirmar que la Programación Orientada a Objetos es una

metodología que estructura los programas en torno a los objetos, en lugar de centrarse
únicamente en procesos, con el objetivo de hacer que el diseño del programa sea más
claro y adaptable a medida que se enfrenta a desafíos complejos y cambiantes.
Los lenguajes de Programación Orientada a Objetos (POO) proporcionan medios y

herramientas para describir los objetos que un programa manipula. En lugar de describir
cada objeto de manera individual, estos lenguajes ofrecen una construcción llamada
"Clase" que define un conjunto de objetos que comparten las mismas propiedades y
comportamientos.
Existen varias ventajas destacadas en el paradigma orientado a objetos:
1. Es una forma más natural de modelar los problemas: La POO se asemeja a cómo
pensamos y conceptualizamos el mundo real. Permite representar objetos y sus
relaciones de una manera intuitiva.
2. Permite manejar mejor la complejidad: Al organizar el código en objetos y clases,

se puede dividir un sistema complejo en componentes más pequeños y
manejables. Esto facilita la comprensión y el mantenimiento del código.
3. Facilita el mantenimiento y la extensión de los sistemas: Los cambios y mejoras

en un sistema pueden ser implementados de manera más eficiente y segura, ya
que las modificaciones se limitan a objetos y clases específicos, en lugar de
afectar a todo el programa.
2
Laura Villena
4. Es más adecuado para la construcción de entornos GUI: La POO se integra de
manera natural con la creación de interfaces gráficas de usuario (GUI), lo que
facilita el desarrollo de aplicaciones con interfaces interactivas y visuales.
5. Fomenta el reuso, con un gran impacto en la productividad y la confiabilidad: La

reutilización de clases y objetos previamente desarrollados es una característica
fundamental de la POO. Esto permite ahorrar tiempo y esfuerzo al aprovechar
código existente, lo que contribuye a la productividad y reduce la posibilidad de
errores.
Nociones básicas UML
Antes de profundizar la lectura en los aspectos más importantes de la Programación

Orientada a Objetos (POO), hablaremos de (UML), Lenguaje Unificado de Modelado.
El UML, que significa "Unified Modeling Language" en inglés, se basa en la idea de que
una imagen vale más que mil palabras. Por lo tanto, nos permite crear y generar
diagramas con el propósito de establecer un lenguaje visual común en el complejo
mundo del análisis y desarrollo de software. Estos diagramas son comprensibles tanto
para los desarrolladores como para los usuarios y cualquier persona interesada en
comprender un sistema.
Es importante destacar que el UML no es en sí un lenguaje de programación, pero

existen herramientas que permiten generar código en diversos lenguajes a partir de los
diagramas UML. Además, el UML guarda una estrecha relación con el análisis y el diseño
orientados a objetos.
En resumen, el UML no constituye una metodología por sí mismo, sino más bien una
notación que se utiliza para desarrollar modelos. Es el estándar para visualizar,
especificar, construir y documentar los componentes de un sistema de software, lo que
lo convierte en una herramienta esencial en el proceso de desarrollo de software
orientado a objetos.
Vamos a explorar algunos conceptos de modelado especificados por UML. El desarrollo

de sistemas se enfoca en tres modelos generales de sistemas diferentes:
1. Modelado Funcional: Este tipo de modelado se basa en diagramas de casos de

uso que describen la funcionalidad del sistema desde la perspectiva del usuario.
Los casos de uso representan las interacciones entre el sistema y sus usuarios o
3
Laura Villena
actores externos. Estos diagramas ayudan a comprender cómo los usuarios
interactúan con el sistema y qué funcionalidades están disponibles para ellos.
2. Modelado de Objetos: En este caso, utilizamos diagramas de clases para describir

la estructura del sistema en términos de objetos, atributos, asociaciones y
operaciones. Los diagramas de clases muestran cómo se organizan y relacionan
las clases (objetos) en el sistema, lo que facilita la comprensión de la estructura
de los datos y las relaciones entre ellos.
3. Modelado Dinámico: En este enfoque, se utilizan diferentes tipos de diagramas,

como los diagramas de interacción, los diagramas de máquina de estados y los
diagramas de actividades, para describir el comportamiento interno del sistema.
Los diagramas de interacción se centran en las interacciones entre objetos, los
diagramas de máquina de estados muestran cómo cambian los objetos de un
estado a otro, y los diagramas de actividades representan procesos o flujos de
trabajo dentro del sistema.
Nos centraremos en dos tipos de diagramas para comprender la Programación

Orientada a Objetos: los Diagramas de Clases y los Diagramas de Secuencias.
Diagrama de clases
El diagrama de clases es el tipo más frecuentemente utilizado en UML y constituye la

base fundamental de cualquier solución basada en la Programación Orientada a Objetos
(POO). Este diagrama presenta las clases dentro de un sistema, así como sus atributos y
operaciones, y muestra las relaciones entre cada una de las clases. En situaciones en las
que se trabajan con sistemas extensos, las clases se agrupan para crear diagramas de
clases que simplifican la representación del sistema en su conjunto.
Los elementos básicos de un diagrama de clases incluyen:
1. Sección superior: En esta sección se encuentra el nombre de la clase, y esta

información es esencial tanto si se está describiendo el clasificador en sí como si
se trata de una instancia u objeto de la clase.
2. Sección central: En esta parte se detallan los atributos de la clase, lo que permite
describir las características o propiedades que posee la clase.
4
Laura Villena
3. Sección inferior: Aquí se presentan las operaciones de la clase, que
corresponden a los métodos que la clase puede realizar. Estas operaciones se
organizan en formato de lista, y cada una de ellas se describe en una línea
individual. Las operaciones proporcionan información sobre cómo la clase
interactúa con los datos y ejecuta funciones específicas.
Todas las clases pueden tener diferentes niveles de visibilidad, lo que significa que
pueden establecer distintos niveles de acceso. Los niveles de visibilidad más comunes
son los siguientes:
• Privados (-): Indican que solo los miembros dentro de la misma clase pueden
acceder a esos atributos o métodos.
• Protegidos (#): Significan que los miembros son accesibles dentro de la misma
clase y también por las subclases.
Además, algunas clases pueden ser abstractas, lo que implica que no se crearía una
instancia de ellas en nuestro sistema. El nombre de una clase abstracta puede
representarse en cursiva o entre dobles ángulos, como <<nombre>>.
Existen diversas relaciones posibles entre clases:
1. Herencia: Este proceso implica que una subclase o clase derivada hereda la
funcionalidad de una superclase o clase base, también conocido como
5
Laura Villena
"generalización". Se representa mediante una línea de conexión recta con una
punta de flecha cerrada que apunta hacia la superclase.
2. Asociación: Es la relación predeterminada entre dos clases, donde ambas clases

están conscientes una de la otra y de la relación que tienen entre sí. Esta
asociación se muestra mediante una línea recta que conecta ambas clases.
3. Agregación: Se refiere a una relación en la que un objeto derivado puede existir

sin su objeto principal.
4. Composición: Es una relación en la que un objeto derivado no puede existir sin

su objeto principal. La vida del objeto derivado está fuertemente ligada a la
existencia del objeto principal.
5. Multiplicidad: Permite definir las relaciones numéricas entre las clases. Por
ejemplo, se puede especificar cuántas instancias de una clase están relacionadas
con cuántas instancias de otra clase (por ejemplo, 0..1, n, 0.., 1.., m..n). Esto
ayuda a precisar cuántas instancias se esperan en una relación particular.
6
Laura Villena
Diagrama de objetos
El diagrama de objetos es una representación que muestra las relaciones entre objetos
mediante ejemplos del mundo real, lo que permite visualizar cómo se verá un sistema
en un momento específico. Este tipo de diagrama se centra en la instancia de clases y
objetos en un punto concreto de la ejecución del programa, mostrando cómo
interactúan y se comunican entre sí en ese momento particular. En resumen, el
diagrama de objetos proporciona una instantánea de la configuración y el estado de los
objetos en un sistema en un momento dado.
El diagrama de objetos representa un objeto que ha sido instanciado o creado durante

la ejecución de un programa, y muestra cómo se establecen los valores de sus atributos.
Este tipo de diagrama es útil para aclarar las relaciones entre objetos y proporciona
información sobre la configuración y el estado de los objetos en un momento específico.
Los componentes clave de un diagrama de objetos son los siguientes:
1. Objetos: Los objetos son instancias concretas de una clase. Por ejemplo, si
"Auto" es una clase, un "Peugeot 208 compacto" sería un objeto de esa clase.
2. Títulos de clase: Los títulos de clase representan los atributos específicos de una
clase particular. Estos títulos de clase pueden aparecer como elementos dentro
del objeto o incluso como propiedades del objeto en sí, como el color de un
automóvil.
3. Atributos: Los atributos de las clases se representan mediante rectángulos con

dos pestañas, indicando un elemento de software.
4. Enlaces: Los enlaces son líneas que conectan dos figuras en un diagrama de
objetos, y se deben nombrar para indicar la interacción que ocurre entre los
objetos conectados.
Además, similar al diagrama de clases, se puede incluir una tercera sección donde se
describan los métodos u operaciones asociados a los objetos. Esta información completa
la representación de la configuración y el comportamiento de los objetos en un sistema
en un punto específico de su ejecución.
"El diagrama de objetos también es conocido como diagrama de instancias".
7
Laura Villena
Diagrama de secuencias
El diagrama de secuencia es una representación visual que permite describir el

comportamiento de un sistema. Este tipo de diagrama muestra cómo los objetos
interactúan entre sí y el orden en que ocurren esas interacciones. Se utilizan para
representar interacciones específicas en un escenario concreto. Los componentes
básicos de un diagrama de secuencia son los siguientes:
1. Objetos: Se representan de manera similar a como se hace en el diagrama de

objetos. Cada objeto participante en la interacción se muestra con su nombre y
puede incluir detalles sobre su estado o atributos.
2. Líneas de Vida: Estas líneas representan a los participantes individuales en un

diagrama de secuencia. Cada línea de vida corresponde a un objeto o entidad y
muestra su existencia a lo largo del tiempo durante la secuencia de
interacciones.
3. Mensajes: Los mensajes representan las interacciones entre los objetos. Un

mensaje es una comunicación que va de un objeto a otro, y se muestra pasando
de la línea de vida de un objeto a la línea de vida de otro. Hay diferentes tipos de
mensajes, como mensajes simples, mensajes síncronos (que esperan una
8
Laura Villena
respuesta inmediata) y mensajes asíncronos (que no esperan una respuesta
inmediata).
4. Dimensiones: Los diagramas de secuencia tienen dos dimensiones principales.

La dimensión horizontal se utiliza para disponer los objetos y mostrar las
interacciones entre ellos. La dimensión vertical representa el paso del tiempo, lo
que permite visualizar el orden en que ocurren las interacciones a medida que
avanza el tiempo.
Objetos
Hemos presentado el funcionamiento básico de UML, que nos será de gran utilidad para
representar de manera más efectiva algunos conceptos fundamentales de la
Programación Orientada a Objetos (POO). Antes de adentrarnos en una exploración
detallada de estos conceptos, es importante entender algunas de las características
clave de los Lenguajes Orientados a Objetos, tal como las describe Alan Kay en 1993.
Estas características son las siguientes:
1. Todo es un objeto: En un lenguaje orientado a objetos, todo en el sistema es

considerado un objeto. Los objetos son las unidades fundamentales que
encapsulan datos y comportamiento.
2. Cada objeto es construido a partir de otros objetos: Los objetos se construyen

utilizando otros objetos como componentes. Esto fomenta la reutilización de
código y la composición de funcionalidades.
3. Todo objeto es instancia de una clase: Cada objeto es una instancia de una clase
específica que define su estructura y comportamiento. Las clases sirven como
plantillas para la creación de objetos.
4. Todos los objetos de la misma clase pueden recibir los mismos mensajes: Los
objetos de la misma clase comparten un conjunto común de comportamientos y
pueden recibir los mismos mensajes para realizar acciones específicas. La clase
define tanto el comportamiento como la estructura interna de los objetos.
5. Las clases se organizan en una estructura arbórea de raíz única, llamada

jerarquía de herencia: Las clases se organizan en una jerarquía de herencia,
donde las subclases heredan comportamientos y atributos de sus superclases.
Esto promueve la reutilización de código y la creación de relaciones de "es un/a"
entre las clases.
9
Laura Villena
6. Un programa es un conjunto de objetos que se comunican mediante el paso de
mensajes: En un programa orientado a objetos, la comunicación entre objetos
se realiza a través del envío de mensajes. Los objetos interactúan enviando
mensajes para solicitar servicios o realizar acciones.
Ahora analicemos en profundidad cada término mencionado con más detalle…
Objetos
Los objetos pueden definirse como las unidades básicas de construcción en la

conceptualización, diseño o programación. Son instancias que pertenecen a clases y
comparten características comunes, que incluyen atributos (propiedades) y
procedimientos, conocidos como operaciones o métodos. En otras palabras, un objeto
representa una abstracción encapsulada de datos y las operaciones o funciones
necesarias para manipular esos datos.
En términos más simples, un objeto es una entidad que contiene tanto los datos que
describen su estado como las funciones o métodos que definen su comportamiento.
Estos objetos se utilizan para modelar y representar entidades del mundo real en el
contexto de la Programación Orientada a Objetos (POO), lo que facilita la creación de
sistemas de software más organizados y estructurados.
"Un objeto es una cosa o entidad, que tiene atributos (propiedades) y de formas de
operar sobre ellos que se conocen como métodos."
10
Laura Villena
De manera más sencilla, un objeto se puede describir como algo que tiene
características y comportamiento. Los objetos pueden representar una amplia variedad
de cosas, como dispositivos, roles, organizaciones, eventos, ventanas de Windows,
iconos, y mucho más.
Aquí hay algunas características generales que definen a los objetos:
• Tienen un nombre o identificador único: Cada objeto se identifica por un

nombre o un identificador único que lo distingue de otros objetos.
• Poseen estados: Los objetos pueden estar en diferentes estados que

representan su situación o condición actual.
• Tienen un conjunto de métodos: Los objetos pueden realizar acciones o

responder a solicitudes a través de métodos, que son funciones o
procedimientos asociados a ellos.
• Tienen un conjunto de atributos: Los objetos tienen atributos que almacenan

información sobre sus características o propiedades.
• Soportan el encapsulamiento: El encapsulamiento significa que los detalles

internos de un objeto, como sus atributos y métodos, se mantienen ocultos y
solo se accede a ellos a través de interfaces específicas.
11
Laura Villena
• Tienen un tiempo de vida: Los objetos existen durante un período de tiempo
determinado, y pueden ser creados y destruidos según sea necesario.
• Son instancias de una clase: Los objetos se crean a partir de clases, que son
plantillas que definen su estructura y comportamiento. Cada objeto es una
instancia de una clase específica.
Organización de los objetos
Los objetos en programación orientada a objetos pueden organizarse de manera

jerárquica, y existen varios tipos de jerarquías. Dos de los tipos más comunes de
jerarquía son los siguientes:
1. Jerarquía Simple: En este tipo de jerarquía, los objetos se organizan de manera

estructurada, similar a un árbol. Esto significa que cada objeto puede tener un
objeto principal o un "padre", y a su vez, puede tener varios objetos secundarios
o "hijos". Esta estructura de árbol se utiliza comúnmente en estructuras de datos
jerárquicas, como los árboles de búsqueda binaria.
2. Jerarquía Compleja: En contraste, una jerarquía compleja es cualquier otra

organización que no sigue la estructura de árbol típica. En este caso, los objetos
pueden estar relacionados de manera más diversa y no necesariamente siguen
una estructura jerárquica simple. Esto puede incluir relaciones más complicadas
entre objetos, como redes o grafos, donde un objeto puede estar conectado con
varios otros objetos en formas no lineales.
Independientemente de la estructura jerárquica, en la Programación Orientada a

Objetos (POO) se pueden identificar tres niveles de objetos:
1. La raíz de la jerarquía: Este nivel corresponde a un objeto único que se encuentra

en el nivel más alto de la estructura jerárquica. Este objeto se conoce como
objeto padre, objeto raíz o entidad principal. En muchos casos, este objeto
centraliza ciertas funcionalidades o características comunes que se comparten
con todos los objetos que descienden de él en la jerarquía.
2. Los objetos intermedios: Estos objetos se encuentran un nivel debajo de la raíz

y tienen descendientes directos. Además, tienen la característica de ser objetos
que tienen tanto ascendencia como descendencia en la jerarquía. Representan
conjuntos de objetos que pueden ser bastante generales o especializados,
12
Laura Villena
dependiendo de los requisitos de la aplicación. Los objetos intermedios pueden
heredar características del objeto raíz y proporcionar características adicionales
que se heredan a sus objetos descendientes.
3. Los objetos terminales: Estos objetos también tienen ascendencia, pero no

tienen objetos descendientes en la jerarquía. Son objetos que se encuentran en
el nivel más bajo de la jerarquía y generalmente representan objetos específicos
y concretos. Los objetos terminales heredan características de los objetos
intermedios de los que descienden, pero no tienen otros objetos que hereden
sus características.
Atributos de los Objetos
Los atributos son las características de un objeto que definen su estado o propiedades.
Estos atributos se pueden definir mediante tipos de datos o variables, los cuales se
dividen en dos categorías principales:
1. Tipos de Datos Primitivos (TDP): Estos tipos de datos se utilizan para representar
valores simples y básicos, como números enteros, caracteres, números reales
(punto flotante), valores booleanos (verdadero/falso), entre otros. Una variable
de tipo primitivo puede contener un solo valor de uno de estos tipos, por
ejemplo, una variable entera puede almacenar un valor numérico entero. Estos
tipos de datos primitivos son esenciales en la programación para manejar
información fundamental.
2. Tipos de Datos por Referencia: Estos tipos de datos indican que trabajaremos
con instancias de clases en lugar de tipos primitivos. En otras palabras, una
variable de tipo por referencia establece una conexión hacia un objeto de una
clase y, a través de esta conexión, podemos acceder a los métodos y atributos
del objeto. En lugar de almacenar un valor simple, estas variables almacenan una
referencia a un objeto en memoria. Esto permite modelar objetos más complejos
y representar estructuras de datos personalizadas.
En resumen, los atributos de un objeto se definen utilizando tipos de datos, que pueden
ser tipos de datos primitivos para valores simples o tipos de datos por referencia para
objetos más complejos. La elección del tipo de datos depende de la naturaleza de la
información que se desea representar en un objeto y de los requisitos del programa.
13
Laura Villena
Se seguirá la convención de utilizar siempre letras minúsculas para nombrar estos
atributos. Si se compone de más de una palabra, se empleará la notación CamelCase,
donde cada primera letra de cada palabra adicional será en mayúscula y sin espacios en
blanco, como por ejemplo "colorDelPelo".
Clases
Una clase es una representación generalizada y una plantilla que define un tipo
específico de objeto. Incluye las características o atributos comunes a todos los objetos
de esa clase y los comportamientos o métodos que todos los objetos de esa clase
pueden realizar. Las clases sirven como modelos abstractos que se utilizan para crear
14
Laura Villena
objetos concretos. En esencia, una clase proporciona las especificaciones de cómo
deben ser los objetos que se crearán a partir de ella.
Por otro lado, un objeto es una instancia específica de una clase. Un objeto se crea a
partir de una clase y hereda todas las características y comportamientos definidos en
esa clase. Cada objeto es único en sí mismo, aunque comparta las mismas características
y métodos que otros objetos de la misma clase.
Ejemplo: Si tienes una clase llamada "Persona" que define las características y
comportamientos comunes a todas las personas, como nombre, edad y la capacidad de
hablar, puedes crear objetos específicos a partir de esta clase. Por ejemplo, puedes crear
un objeto llamado "Pedro" y otro llamado "María", ambos serían instancias de la clase
"Persona". Cada uno tendría su propia información única, pero compartiría las
características y acciones definidas en la clase "Persona".
15
Laura Villena
¿Qué diferencia existe entre instancia y objeto?, veamos una comparativa en la
siguiente imagen:
Cuando se define una clase, se establece cómo serán los objetos creados a partir de esa
clase. Es como diseñar un molde o plantilla para objetos específicos. Puedes pensar en
ello como un molde para hacer helados: los objetos son los helados individuales y el
molde define sus características, como el color, el tamaño y el sabor, así como las
acciones que pueden realizar, como congelarse o derretirse.
Las clases tienen ciertas características generales:
• Poseen un nivel de abstracción alto: Esto significa que representan conceptos

generales y abstractos en lugar de objetos específicos.
16
Laura Villena
• Se relacionan entre sí mediante jerarquías: Las clases pueden organizarse en
jerarquías donde una clase puede heredar características y comportamientos de
otra clase. Esto se conoce como herencia y permite la reutilización de código.
• Los nombres de las clases suelen estar en singular: Para seguir una convención
de nomenclatura común, los nombres de las clases suelen estar en singular para
representar un tipo de objeto.
Existen tres tipos principales de clases:
• Clase Abstracta: Es muy general y abstracta, a menudo representa un concepto

amplio. Por ejemplo, "Animal" podría ser una clase abstracta.
• Clase Común: Es intermedia en la jerarquía y representa un conjunto más

específico de objetos. Por ejemplo, "Mamíferos" podría ser una clase común que
hereda de la clase abstracta "Animal".
• Clase Final: Es muy específica y representa objetos concretos. Por ejemplo,

"GatoSiames" podría ser una clase final que hereda de la clase "Mamíferos".
La representación gráfica de una o varias clases se realiza mediante Diagramas de Clase.

Estos diagramas utilizan una notación específica proporcionada por el Lenguaje de
Modelación Unificado (UML), que divide los rectángulos en tres partes. La primera parte
contiene el nombre de la clase, la segunda parte contiene los atributos o características
y la tercera parte contiene los métodos o acciones que la clase puede realizar. Esto
permite una representación visual clara de la estructura y el comportamiento de las
clases en un sistema de software.
Los modificadores de acceso en UML, que determinan quién puede acceder a los
atributos y métodos de una clase, se representan de la siguiente manera:
• "Público" se indica con el símbolo + y permite que los atributos y métodos sean
accesibles desde cualquier parte del programa, incluyendo otras clases.
• "Protegido" se indica con el símbolo # y permite que los atributos y métodos

sean accesibles dentro de la misma clase y por clases que heredan de esta.
• "Privado" se indica con el símbolo - y limita el acceso a los atributos y métodos

solo a la misma clase, sin permitir acceso externo o herencia por otras clases.
17
Laura Villena
Relaciones entre clases
Las clases en la programación orientada a objetos no están diseñadas para trabajar de

forma aislada. La idea principal es que estas clases puedan relacionarse entre sí, de
modo que puedan compartir atributos y métodos sin necesidad de duplicarlos cada vez
que se necesiten.
Una característica esencial de la programación orientada a objetos es la capacidad de

establecer relaciones entre clases. Estas relaciones permiten extender y reutilizar el
código existente sin tener que reescribirlo desde cero en cada ocasión. Existen varios
tipos de relaciones entre clases que exploraremos:
• Herencia (generalización / especialización o "Es-un"): Establece una estructura

jerárquica de clases en forma de árbol, donde cada clase tiene una única clase
padre, conocida como superclase, y las clases hijas se denominan subclases. La
herencia permite que las subclases hereden atributos y métodos de su
superclase.
• Agregación (todo / parte o "Forma-parte-de"): Representa una relación donde

un objeto puede contener o estar compuesto por otros objetos. Esta relación se
utiliza para modelar componentes más grandes construidos a partir de partes
más pequeñas.
• Composición ("Es parte elemental de"): Similar a la agregación, pero con una
relación más fuerte. En este caso, un objeto no puede existir sin sus
componentes, y la vida de los componentes está vinculada a la del objeto
principal.
• Asociación (incluyendo "Tiene-un"): Representa una relación más general

donde los objetos pueden estar relacionados entre sí, pero no tienen una
dependencia fuerte. Puede ser una relación simple entre dos objetos o una
relación más compleja entre múltiples objetos.
• Dependencia ("Usa un"): Indica que una clase utiliza otra clase en algún aspecto,
pero no implica una relación fuerte. Por ejemplo, una clase puede depender de
otra para realizar ciertas operaciones.
La herencia implica la organización de clases en una estructura jerárquica o un árbol de

estructura de datos. En esta jerarquía, cada clase tiene exactamente una clase principal,
que se conoce como su superclase. Las clases que heredan de una superclase específica
se denominan subclases.
18
Laura Villena
• Superclase: Puede definirse de manera simple como la clase padre de una clase
específica y puede tener cualquier cantidad de subclases que hereden sus
atributos y métodos.
• Subclase: Es la clase hija de una clase específica que hereda atributos y métodos
de su superclase.
Mensajes, método, variables e instancias
Mensajes
En la programación orientada a objetos, los objetos, como los que se describieron

anteriormente, se comunican entre sí mediante señales o mensajes. Estos mensajes son
los que provocan que los objetos respondan de diversas maneras. Por ejemplo, en una
aplicación de Windows, un objeto como una ventana puede cerrarse, maximizarse o
restaurarse, y estas acciones se desencadenan mediante mensajes que se envían a la
ventana. En resumen, un mensaje es una forma de comunicación dirigida a un objeto,
que le indica que ejecute uno de sus métodos específicos, y este mensaje puede o no
llevar algunos parámetros que proporcionan información adicional.
19
Laura Villena
Métodos
Los métodos, también conocidos como funciones o procedimientos en otros lenguajes

de programación, desempeñan un papel fundamental en la programación orientada a
objetos. Estos métodos permiten al programador dividir un programa en módulos
separados, cada uno con una tarea autónoma.
Las instrucciones dentro de los cuerpos de los métodos se definen una sola vez y se
pueden reutilizar desde diferentes partes del programa. Además, están encapsuladas y
ocultas de otros métodos. La división de un programa en módulos mediante métodos
sigue la metodología "divide y vencerás", lo que facilita la administración del desarrollo
de programas al construirlos a partir de componentes más pequeños y simples.
Otra ventaja de los métodos es la reutilización de software, ya que se pueden utilizar

métodos existentes como bloques de construcción para crear nuevos programas en
lugar de escribir código personalizado desde cero. También evitan la repetición de
código, lo que hace que el programa sea más fácil de depurar y mantener.
Un método se invoca mediante una llamada, y cuando completa su tarea, devuelve un

resultado o simplemente devuelve el control al método que lo llamó. Esto se asemeja a
la estructura jerárquica de la administración, donde un jefe (el método llamante) asigna
tareas a un trabajador (el método llamado) y espera los resultados después de que se
complete la tarea. El jefe no necesita conocer los detalles de cómo el trabajador realiza
la tarea, y el trabajador puede llamar a otros trabajadores sin que el jefe esté al tanto
de ello. Este "ocultamiento" de los detalles de implementación fomenta buenas
prácticas de ingeniería de software.
Los métodos son unidades autónomas que interactúan con los mensajes y determinan
qué mensajes puede recibir un objeto. Pueden compararse con las funciones o
subrutinas en la programación procedural.
En el gráfico siguiente se muestra al método jefe comunicándose con varios métodos

trabajadores en forma jerárquica. El método jefe divide las responsabilidades entre los
diversos métodos trabajadores. Observe que trabajador 1 actúa como “método jefe” de
trabajador 4 y trabajador 5
20
Laura Villena
Un método cuenta con las siguientes partes:
• Nombre del método.
• Valor que regresa.
• Argumentos opcionales.
• Modificadores en la declaración del método (como los de visibilidad)
• Cuerpo del método.
Variables
Las variables son espacios de memoria donde se almacenan datos, y cada una de ellas
tiene su propio nombre, tipo y valor. En la programación orientada a objetos, existen
varios tipos de variables que desempeñan funciones específicas:
• Variables de Instancia: Se utilizan para definir los atributos de un objeto

específico. Cada instancia u objeto de una clase tiene su propio conjunto de
variables de instancia que almacenan datos específicos para esa instancia.
• Variables de Clase: Estas variables son compartidas por todas las instancias de
una clase. Tienen el mismo valor para todas las instancias de la clase y se utilizan
para almacenar datos que deben ser compartidos entre todos los objetos de esa
clase.
21
Laura Villena
• Variables Locales: Son variables que se declaran y utilizan dentro de los
métodos. Su alcance está limitado al método en el que se declaran y no pueden
ser accedidas desde fuera de ese método.
Instancia
Hasta este punto, hemos discutido cómo implementar clases y cómo expresar sus
atributos y métodos. Aunque todos los tipos de datos en la programación orientada a
objetos son clases, nos referiremos a las instancias de clases que excluyen los tipos de
datos básicos del lenguaje como "objetos". Es importante recordar que, en el caso de
los tipos de datos básicos, sus valores pueden asignarse directamente a variables y luego
modificarse mediante el operador de asignación.
¿Es posible aplicar la misma idea para manejar objetos? En la manipulación de objetos
o instancias de tipos de datos que no son básicos, también se utilizan variables, pero hay
una diferencia con respecto a los tipos básicos. Los objetos deben crearse
explícitamente, lo que implica reservar memoria para almacenar los valores de todos
sus campos, o al menos contener una referencia a otro objeto que haya sido creado
previamente.
22
Laura Villena
Declaración de variables de instancia
El estado de un objeto se define a través de sus variables, que son conocidas como
variables de instancia. Estas variables se declaran dentro del cuerpo de la clase a la que
pertenece el objeto. Un objeto se conoce como una instancia de una clase, y para
crearlo, se invoca a un conjunto de líneas de código llamadas constructor de la clase,
que generalmente tiene el mismo nombre que la clase. Una vez que un objeto ya no se
necesita, puede ser gestionado por el recolector de basura (garbage collector), que se
encarga de liberar la memoria ocupada por objetos no utilizados.
Constructores, Destructores y Garbage Collector
Constructores y Destructores
Los objetos utilizados en la programación tienen un ciclo de vida definido, similar a los
objetos físicos. Este ciclo comienza con la creación (instanciación) del objeto y finaliza
con su destrucción y limpieza, que es realizada por el Garbage Collector. El Garbage
Collector es un proceso que se encarga de liberar el espacio de memoria ocupado por
un objeto cuando ya no hay referencias a dicho objeto.
Como mencionamos anteriormente, la creación de objetos se realiza mediante un

método especial llamado constructor, que tiene el mismo nombre que la clase a la que
pertenece el objeto. Este constructor se ejecuta al crear e iniciar el objeto. Es posible
tener más de un constructor en una clase, y pueden tener parámetros o no. En caso de
que no se defina un constructor en la clase, se proporciona uno por omisión que
inicializa las variables del objeto con valores predeterminados.
Por otro lado, la destrucción de un objeto también puede ser una operación automática,
y para este propósito, se utiliza otro método especial llamado destructor. El nombre del
destructor es el mismo que el de la clase, pero precedido por el carácter "~". Los
destructores no reciben parámetros y no tienen un tipo de retorno definido.
Ambos, el constructor y el destructor, son métodos particulares que se utilizan para

realizar acciones específicas durante la creación y destrucción de objetos.
23
Laura Villena
Es posible crear instancias de la clase Persona incluso si no se ha definido explícitamente
un constructor. En este caso, se proporcionará automáticamente un constructor sin
parámetros y con un cuerpo vacío, que se conoce como constructor por defecto. Este
constructor por defecto se encarga de asignar valores por defecto a los campos de la
clase.
Cuando los parámetros del constructor tienen el mismo nombre que los campos de la
clase, se produce una ambigüedad en el ámbito de las variables dentro del cuerpo del
constructor. En este caso, se utiliza la notación "this" para hacer referencia explícita al
campo de la clase. Por ejemplo, si tenemos un campo "nombre" y un parámetro
"nombre" en el constructor, podemos usar "this.nombre" para referirnos al campo de
la clase y "nombre" para referirnos al parámetro del constructor.
El concepto de alcance (ámbito) y tiempo de vida de las variables es fundamental para

comprender cómo se resuelven estos casos de ambigüedad en la referencia a las
variables en un constructor.
1. El tiempo de vida de las variables: se refiere al período durante el cual una

variable existe y se puede acceder a ella. En el caso de los campos de los objetos,
como los atributos de una clase, existen durante toda la vida de los objetos a los
que pertenecen. Por otro lado, las variables locales, como los parámetros de un
método, tienen un tiempo de vida más limitado y dejan de existir después de
que finaliza el bloque de instrucciones al que pertenecen.
2. El alcance o ámbito de una variable: se relaciona con la visibilidad de esa
variable y especifica desde qué parte del código se puede hacer referencia a ella.
Las variables tienen un alcance que está determinado por su contexto de
declaración. Por ejemplo, una variable local declarada dentro de un método solo
es visible y accesible dentro de ese método, mientras que un campo de clase es
visible y accesible en todos los métodos de esa clase.
Garbage Collector (GC)
Su función principal es supervisar todas las instancias de objetos creadas durante la

ejecución de la aplicación y marcar como "huérfanos" a aquellos objetos que ya no se
utilizan o que no tienen referencias a ellos. Cuando el sistema necesita liberar memoria,
el GC se encarga de destruir estos objetos huérfanos.
El proceso de destrucción de objetos puede implicar la invocación de destructores si

están definidos para esos objetos. Sin embargo, no todos los lenguajes de programación
24
Laura Villena
utilizan destructores de la misma manera. Por ejemplo, en Java, no se permite definir
destructores personalizados para objetos, ya que el GC se encarga de la gestión de la
memoria de forma automática y transparente para el programador. En otros lenguajes,
como C++, los destructores pueden ser definidos por el programador para realizar tareas
específicas de limpieza cuando un objeto es destruido.
Relación entre clases y objetos
Un objeto es una instancia de una clase y, por lo tanto, hereda los atributos y métodos
definidos en su clase correspondiente. Esto significa que los objetos pueden acceder y
utilizar los atributos (variables) y métodos (funciones y procedimientos) definidos en su
clase.
Puedes pensar en un objeto como una variable de tipo clase. Por ejemplo, si tienes una
clase llamada "Persona", un objeto llamado "Cesar" sería una instancia de la clase
"Persona". En este sentido, los objetos se componen de dos partes principales: atributos
o estados y métodos que definen su comportamiento basado en esos atributos. Los
atributos suelen ocultarse al exterior, mientras que algunos métodos pueden quedar
visibles para interactuar con el objeto (esto se llama encapsulamiento).
Desde una perspectiva algorítmica, las clases son descripciones estáticas o plantillas que
definen la estructura de los objetos. Las clases actúan como moldes de fábrica, a partir
de los cuales se crean instancias de objetos. Durante la ejecución de un programa, solo
existen objetos, no clases.
Es importante destacar que la declaración de una variable de una clase no crea

automáticamente un objeto. La creación de un objeto debe ser realizada explícitamente
por el programador, generalmente a través de un método constructor que se encarga
de inicializar el objeto.
Clases objetos métodos y variables de instancia
El concepto de clases y objetos en la programación se puede entender a través de una

analogía simple con la construcción y conducción de un automóvil:
Imagina que deseas conducir un automóvil y, para aumentar su velocidad, debes

presionar el pedal del acelerador. Antes de poder conducirlo, alguien debe diseñarlo, y
ese diseño incluye componentes como el pedal del acelerador, que oculta los
25
Laura Villena
mecanismos internos complejos que hacen que el automóvil acelere. De manera similar,
el pedal del freno oculta los mecanismos que detienen el automóvil, y el volante oculta
los mecanismos que permiten que el automóvil gire. Esta ocultación de complejidad
permite que personas sin conocimientos profundos de mecánica automotriz puedan
conducir un automóvil con facilidad.
Sin embargo, los diseños de ingeniería (los dibujos) no se pueden conducir. Para
conducir un automóvil, primero se debe construir basándose en esos diseños. Un
automóvil real tendrá un pedal de acelerador funcional que puedes presionar para
aumentar la velocidad, pero el automóvil en sí no acelerará por sí mismo; el conductor
debe tomar el control.
Esta analogía se traslada a la programación de la siguiente manera:
• Una clase en programación es como los diseños de ingeniería de un automóvil.

Define la estructura y el comportamiento de un objeto.
• Los objetos son como los automóviles reales construidos a partir de esos diseños.
Pueden realizar tareas específicas y tienen atributos.
• Los métodos en una clase son como los mecanismos en un automóvil que
permiten realizar tareas específicas. Ocultan la complejidad interna y
proporcionan una interfaz para interactuar con el objeto.
• Para utilizar un objeto en un programa, primero debes crear una instancia (un
objeto) de la clase correspondiente, al igual que construir un automóvil a partir
de los diseños. Luego, puedes usar los métodos y atributos del objeto para
realizar acciones específicas.
Esta es una de las características clave de la programación orientada a objetos: organizar

el código en clases y objetos para encapsular la funcionalidad y facilitar su uso, de
manera similar a cómo un automóvil oculta su complejidad interna para que los
conductores puedan utilizarlo con facilidad.
En la programación orientada a objetos, los objetos se comunican entre sí enviando

mensajes, que son llamadas a métodos. Esta comunicación se puede comparar con la
acción de conducir un automóvil y operar sus componentes.
Cuando conduces un automóvil y presionas el pedal del acelerador, estás enviando un

mensaje al automóvil para que realice una tarea específica, que en este caso es
aumentar su velocidad. De manera similar, en la programación, se envían mensajes a un
objeto para que ejecute un método específico. Cada mensaje representa una llamada a
un método en el objeto, y este método realiza una tarea particular.
26
Laura Villena
Además de las capacidades de un automóvil, como acelerar o frenar, los automóviles
tienen atributos, como su color, número de puertas, cantidad de gasolina en el tanque,
velocidad actual y la distancia total recorrida (odómetro). Estos atributos se definen en
el diseño del automóvil y están asociados al automóvil en todo momento. Cada
automóvil mantiene su propio conjunto de atributos, y, por ejemplo, cada conductor
sabe cuánta gasolina tiene en su propio tanque, pero no en el de otros automóviles.
En la programación orientada a objetos, los objetos también tienen atributos que

definen su estado, y estos atributos son específicos de cada objeto. Los objetos pueden
interactuar entre sí enviándose mensajes (llamando a métodos) y accediendo a los
atributos de otros objetos cuando sea necesario. La analogía del automóvil ayuda a
comprender cómo los objetos se comunican y cómo sus atributos y métodos pueden ser
utilizados en un programa.
27
Laura Villena
De manera análoga, un objeto posee características que lo acompañan cuando se
emplea en un programa. Estas características se definen como parte de la estructura de
la clase a la que pertenece el objeto. Por ejemplo, en el caso de un objeto que representa
una cuenta bancaria, se puede identificar un atributo denominado "saldo" que
almacena la cantidad de dinero presente en esa cuenta específica. Cada objeto que
representa una cuenta bancaria conoce su propio saldo, pero no tiene acceso a los
saldos de otras cuentas bancarias en el sistema. Estos atributos se establecen a través
de las variables de instancia que se definen en la clase correspondiente.
Abstracción
El Enfoque Orientado a Objetos se fundamenta en cuatro principios fundamentales que

sirven como cimiento para todo desarrollo orientado a objetos. Estos principios son:
1. Abstracción
2. Encapsulamiento
3. Modularidad
4. Herencia
Además, existen otros elementos que son destacables en la programación orientada a

objetos, aunque no sean fundamentales en el mismo sentido que los cuatro principios
anteriores. Estos elementos incluyen:
1. Polimorfismo
2. Tipificación
3. Concurrencia
4. Persistencia
A continuación, profundicemos en estos elementos con más detalle.
28
Laura Villena
Abstracción
¿Qué implica la abstracción? La abstracción se refiere a la representación de las

características fundamentales de un objeto, incluyendo sus datos y operaciones, que lo
diferencian de otros objetos dentro de un mismo dominio. En el diseño orientado a
objetos, determinar el conjunto adecuado de abstracciones para un dominio particular
es un aspecto esencial.
Una forma de entender la abstracción es considerarla como la eliminación intencional u

ocultamiento de ciertos detalles de un proceso o artefacto, con el propósito de resaltar
con mayor claridad otros aspectos, detalles o estructuras importantes. En cada nivel de
detalle, se muestra cierta información mientras que se omite otra. Un ejemplo común
es la representación de diferentes escalas en mapas cartográficos.
Mediante la abstracción creamos MODELOS de la realidad.
La abstracción implica representar entidades del mundo real como componentes

internos de un programa. En esta abstracción, se considera tanto la representación de
datos a través de atributos como la definición de métodos asociados a objetos. Este
enfoque permite obtener una visión general y simplificada de un tema o concepto.
Los niveles de abstracción disponibles en un lenguaje de programación dependen de las

capacidades que dicho lenguaje ofrece:
29
Laura Villena
1. Perspectiva funcional: Este nivel abarca desde el nivel más bajo de
programación, como el ensamblador, hasta niveles más altos que involucran
procedimientos y módulos para organizar y estructurar el código.
2. Perspectiva de datos: Aquí se encuentran conceptos como paquetes y tipos

abstractos de datos (TAD), que permiten encapsular datos y operaciones
relacionadas en estructuras más complejas.
3. Perspectiva de servicios: En este nivel, se introduce la programación orientada a

objetos (EOO), donde los objetos son los protagonistas. Además de los TAD, se
incorporan conceptos como el paso de mensajes, la herencia y el polimorfismo
para modelar el comportamiento de los objetos.
La abstracción se enfoca en las características esenciales de un objeto desde la

perspectiva del observador. En el EOO, se utilizan varios mecanismos de abstracción
para definir y extraer características y comportamientos del entorno a modelar. Algunos
de estos mecanismos incluyen:
• Generalización: Agrupa clases de objetos en una clase superior (superclase),

resaltando las similitudes entre las clases subyacentes (subclases) y omitiendo
las diferencias. La superclase almacena datos generales, mientras que las
subclases almacenan datos específicos.
• Especialización: Es el proceso inverso de la generalización, donde una clase,

como "Médico", es una especialización de otra clase, como "Persona". A su vez,
"Pediatra" puede ser una especialización de "Médico".
• Agregación: Permite definir una clase de objetos a partir de sus partes

constituyentes, como un "computador" formado por la "CPU", la "memoria" y
los "dispositivos periféricos". La descomposición es el proceso contrario a la
agregación.
• Clasificación: Implica definir una clase basada en objetos con comportamientos

similares, mientras que la ejemplificación consiste en crear instancias de una
clase utilizando ejemplos específicos.
• Ocultación de información: Este principio se refiere a la omisión intencional de

detalles de implementación detrás de una interfaz simple, permitiendo a los
usuarios interactuar con un objeto sin necesidad de conocer todos los detalles
internos de su funcionamiento.
Las clases y objetos deberían estar al nivel de abstracción adecuado: ni demasiado alto
ni demasiado bajo
30
Laura Villena
Encapsulamiento
El encapsulamiento, en un sistema orientado a objetos, se refleja en cada clase u objeto

mediante la definición de sus atributos y métodos, utilizando diferentes niveles de
visibilidad a través de modificadores de acceso:
• Público (+): Atributos o métodos accesibles desde fuera de la clase, lo que

significa que pueden ser invocados por cualquier otra clase, incluso si no está
relacionada directamente con ella.
• Privado (-): Atributos o métodos que solo son accesibles dentro de la

implementación de la propia clase. El acceso desde fuera está restringido.
• Protegido (#): Atributos o métodos que son accesibles tanto para la propia clase
como para sus clases derivadas (subclases).
El encapsulamiento tiene como objetivo principal ocultar los detalles de

implementación de un objeto. Cada objeto se presenta como una entidad aislada del
entorno exterior, similar a una "caja negra" que contiene toda la información
relacionada con ese objeto. Este aislamiento protege los datos asociados al objeto,
evitando que sean modificados por partes no autorizadas. El encapsulamiento permite
tratar a los objetos como unidades básicas, manteniendo su estructura interna oculta.
El encapsulamiento da lugar al principio de ocultamiento, que implica que solo los

métodos de una clase deberían tener acceso directo a los atributos de esa clase. Esto se
hace para evitar que un atributo sea modificado de manera insegura o sin control por
partes externas a la clase, garantizando así la integridad y coherencia de los datos.
Modularidad
La modularidad es una característica que facilita la independencia entre las distintas

secciones de un sistema. Este concepto implica dividir un programa en módulos o
componentes que pueden ser desarrollados y mantenidos por separado, al tiempo que
mantienen la capacidad de interactuar con otros módulos. Por lo general, dentro de un
mismo módulo se agrupan clases y objetos que tienen una estrecha relación entre sí. La
modularidad se relaciona estrechamente con el principio de ocultamiento de
información.
31
Laura Villena
A continuación, podemos enumerar los principios clave de la modularidad:
1. Descomposición de sistemas complejos: La capacidad de dividir un sistema

complejo en partes más pequeñas es fundamental. Este enfoque sigue el
principio del "divide y vencerás", donde un problema general se divide en
problemas más manejables y pequeños.
2. Composición a través de módulos: La modularidad implica la posibilidad de

componer un programa utilizando los módulos como bloques de construcción.
En la práctica, esto significa que podemos utilizar módulos existentes y diseñados
para ser reutilizables para construir nuevas aplicaciones, lo que ahorra tiempo y
esfuerzo en el desarrollo.
3. Comprensión por partes del sistema: Trabajar con partes separadas del sistema
facilita la comprensión del código y del sistema en su conjunto. Además, esta
división en módulos facilita la tarea de realizar modificaciones y actualizaciones
en el software. En situaciones donde se requieren cambios, tener un sistema
32
Laura Villena
modular puede evitar que los cambios tengan un impacto catastrófico en todo
el programa.
Una de las razones fundamentales para modularizar un programa es la capacidad de

establecer límites bien definidos, lo cual resulta extremadamente valioso al momento
de leer el código. Vale la pena recordar que una buena práctica en programación implica
diseñar y escribir código pensando en las personas que lo mantendrán en el futuro.
Herencia
Vamos a explorar con más detalle otra característica fundamental de la programación

orientada a objetos: la herencia. La herencia es una técnica que permite la reutilización
de software mediante la creación de una nueva clase que incorpora los miembros de
una clase existente, ya sea mejorándolos con nuevas capacidades o realizando
modificaciones en las capacidades ya existentes.
La herencia ofrece a los programadores la ventaja de ahorrar tiempo durante el

desarrollo al aprovechar software probado y depurado de alta calidad. Esto también
aumenta la probabilidad de que un sistema se implemente de manera efectiva. En lugar
de declarar miembros completamente nuevos al crear una clase, se puede especificar
que la nueva clase herede los miembros de una clase existente. La clase existente se
conoce como superclase (o clase base), mientras que la nueva clase se denomina
subclase (o clase derivada). Cada subclase tiene la capacidad de convertirse en la
superclase de futuras subclases. Por lo general, una subclase agrega sus propios campos
y métodos, lo que la hace más específica que su superclase y la representa como un
grupo más especializado de objetos.
En el contexto de la jerarquía y la herencia, se utilizan términos como superclase y

subclase. La jerarquía es una clasificación u ordenación de abstracciones, y las dos
jerarquías más importantes en un sistema complejo son: su estructura de clases (la
jerarquía "de clases") y su estructura de objetos (la jerarquía "de partes").
Las clases están relacionadas entre sí, formando una jerarquía de clasificación, y la
herencia es el mecanismo que permite compartir automáticamente los métodos y datos
entre las clases y subclases de los objetos. Los objetos heredan las propiedades y el
comportamiento de todas las clases a las que pertenecen.
33
Laura Villena
La herencia puede ser de dos tipos: herencia simple (una clase tiene una sola superclase,
y un objeto pertenece a una sola clase) y herencia múltiple (una clase tiene dos o más
superclases, y un objeto puede pertenecer a más de una clase).
34
Laura Villena
Entonces, la superclase directa es aquella de la cual la subclase hereda explícitamente.
Por otro lado, una superclase indirecta se refiere a cualquier clase que esté por encima
de la superclase directa en la jerarquía de clases y que establece las relaciones de
herencia entre las clases. En el contexto de la herencia simple, una clase se deriva
directamente de una superclase.
Cuando se busca reutilizar código, se crean nuevas clases utilizando las clases existentes
y la estructura jerárquica de clases mencionada anteriormente. Esto se logra
principalmente mediante dos métodos:
1. Composición: En este enfoque, se crean objetos utilizando clases ya existentes.

La nueva clase se compone de objetos de las clases existentes. En otras palabras,
se ensamblan objetos preexistentes para formar la nueva clase.
2. Herencia: La herencia en programación orientada a objetos se asemeja a la

herencia en la vida real. Una clase hija hereda atributos y métodos de su clase
padre, de manera que puede considerarse como una extensión de la clase padre.
35
Laura Villena
Sin embargo, la clase hija tiene la flexibilidad de modificar o personalizar estos
atributos y métodos heredados según sus necesidades, utilizando modificadores
de acceso. Esto permite agregar o eliminar atributos y métodos de manera
individual para una clase específica sin afectar a la clase padre ni a otras clases
hijas.
Polimorfismo
Continuemos nuestra exploración de la programación orientada a objetos, donde ahora

abordaremos el concepto de polimorfismo a través de ejemplos de jerarquías de
herencia.
El polimorfismo es una característica que nos permite "programar de manera general"

en lugar de hacerlo de manera específica. En particular, nos permite escribir programas
que manejen objetos pertenecientes a una jerarquía de clases compartiendo la misma
superclase, como si todos fueran simplemente objetos de esa superclase, lo que puede
simplificar la programación.
Para ilustrar el concepto de polimorfismo, consideremos el siguiente ejemplo:

Imaginemos que debemos crear un programa para simular el movimiento de varios tipos
de animales como parte de un estudio biológico. Tenemos las clases Pez, Rana y Ave,
que representan tres tipos de animales bajo investigación. Cada una de estas clases
extiende la superclase Animal, que contiene un método llamado "mover" y mantiene la
posición actual de un animal en coordenadas x-y. Cada subclase implementa este
método de "mover" de manera única.
Nuestro programa mantiene un arreglo de referencias a objetos de diferentes subclases

de Animal. Para simular los movimientos de los animales, el programa envía a cada
objeto el mismo mensaje "mover" una vez por segundo. Sin embargo, cada tipo
específico de Animal responde a este mensaje de "mover" de manera única: un Pez
podría nadar tres pies, una Rana podría saltar cinco pies y un Ave podría volar diez pies.
Lo fundamental del polimorfismo es que el programa envía el mismo mensaje (es decir,
"mover") a cada objeto animal de manera genérica, pero cada objeto sabe cómo
modificar sus coordenadas x-y de manera apropiada para su tipo específico de
movimiento. Confiamos en que cada objeto sepa cómo "hacer lo correcto" en respuesta
a la llamada al mismo método. El mismo mensaje (en este caso, "mover") enviado a
diferentes objetos puede tener "muchas formas" de resultados, lo que justifica el uso
del término "polimorfismo".
36
Laura Villena
Mediante el polimorfismo, tenemos la capacidad de diseñar e implementar sistemas
que pueden extenderse de manera sencilla. La adición de nuevas clases se vuelve una
tarea fácil, ya que a menudo solo se requiere una mínima o ninguna modificación en las
partes generales de la aplicación, siempre y cuando estas nuevas clases formen parte de
la jerarquía de herencia que la aplicación maneja de forma genérica.
El polimorfismo operacional, también conocido como sobrecarga operacional, permite

la aplicación de operaciones con el mismo nombre en diferentes clases o en clases
relacionadas en términos de herencia. En este tipo de polimorfismo, los métodos se
interpretan en el contexto de un objeto particular, ya que los métodos con nombres
comunes se implementan de manera diferente en función de la clase a la que
pertenecen.
Diferentes clases (polimórficas) pueden implementar métodos con el mismo nombre,

pero con comportamientos diferentes asociados a objetos distintos. Al llamar a estos
métodos por su nombre, se utilizará el comportamiento correspondiente al objeto que
se está utilizando en ese momento.
Esta característica facilita la implementación de múltiples versiones de un mismo

método, lo que permite acceder a varias implementaciones distintas que comparten el
mismo nombre. Hay dos tipos principales de polimorfismo operacional:
1. Polimorfismo por reemplazo: Se refiere a que dos o más clases diferentes tienen
métodos con el mismo nombre, pero cada una los implementa de manera
diferente.
2. Polimorfismo por sobrecarga: Implica el uso del mismo nombre de método

varias veces, ejecutándolo de manera diferente y diferenciándolo únicamente
por los argumentos o parámetros que recibe.
37
Laura Villena
Cuando hablamos de los tipos de polimorfismo, es importante tener en cuenta los
siguientes conceptos:
1. Los objetos tienen una forma específica asignada al ser construidos, pero pueden
ser referenciados de manera polimórfica. Esto significa que pueden referirse a
objetos de diferentes clases siempre que exista una relación de herencia entre
esas clases. El polimorfismo permite separar "qué" hace un objeto de "cómo" lo
hace, lo que permite distinguir entre tipos de objetos similares a través del
comportamiento de los métodos que heredan de la clase padre.
2. Las funciones (métodos) polimórficas no se preocupan por el tipo de variables

que reciben como argumento.
3. Polimorfismo por herencia: se utiliza la palabra clave "virtual" para modificar la

declaración de un método, propiedad (no estática) o evento, lo que permite que
cualquier clase que herede este método pueda reemplazarlo con su propia
implementación.
4. Polimorfismo por abstracción: implica el uso de clases abstractas que no se

pueden instanciar directamente. Estas clases suelen estar implementadas
parcialmente o no implementadas en absoluto y deben derivarse si se desea
crear objetos de ellas.
5. Polimorfismo por interfaces: una interfaz es un contrato que define propiedades

y métodos, pero no proporciona una implementación concreta. Las clases que
implementan una interfaz deben proporcionar su propia implementación de los
métodos definidos en la interfaz.
Tipificación, concurrencia y persistencia
Tipificación
Los tipos representan la categorización de los objetos, de modo que objetos de

diferentes tipos no pueden intercambiarse o, en el mejor de los casos, solo pueden
intercambiarse de manera muy limitada. Los tipos proporcionan una descripción precisa
de las propiedades estructurales o de comportamiento que comparten ciertas
entidades.
38
Laura Villena
En términos simples, la tipificación implica asignar una clase a un objeto, de manera que
objetos de diferentes tipos no puedan intercambiarse libremente o solo puedan hacerlo
de manera restringida.
Un tipo es una descripción precisa de las propiedades estructurales y de

comportamiento que comparten un grupo de entidades. En general, los términos "tipo"
y "clase" pueden considerarse sinónimos.
Los lenguajes de programación pueden ser fuertemente tipificados o débilmente

tipificados. Los lenguajes débilmente tipificados admiten el polimorfismo, mientras que
los fuertemente tipificados no lo hacen.
Concurrencia
La concurrencia es la característica que distingue a un objeto como activo en

contraposición a uno que no lo está. Esta propiedad permite que dos objetos realicen
acciones simultáneamente. En estos escenarios, a menudo es necesario gestionar
múltiples acciones de forma concurrente, y para ello se utilizan procesos que generan
acciones dinámicas independientes dentro de un sistema.
En el contexto de la concurrencia, se manejan dos tipos de procesos: procesos pesados

y procesos ligeros.
1. Proceso Pesado: Este tipo de proceso generalmente es gestionado de manera

autónoma por el sistema operativo y tiene su propio espacio de direcciones.
39
Laura Villena
2. Proceso Ligero: Los procesos ligeros existen dentro de un solo proceso del
sistema operativo en compañía de otros procesos ligeros, compartiendo el
mismo espacio de direcciones.
Es importante recordar que la programación orientada a objetos se enfoca en la

abstracción de datos, encapsulamiento y herencia, mientras que la concurrencia se
centra en la abstracción de procesos y la sincronización. Cuando se introduce la
concurrencia en un sistema, es crucial considerar cómo los objetos activos se sincronizan
con otros para evitar problemas y conflictos.
Persistencia
La persistencia se refiere a la propiedad de un objeto que le permite existir más allá del
tiempo en que fue creado (es decir, su existencia trasciende el tiempo) y/o más allá del
espacio en el que fue originalmente ubicado (lo que significa que su posición varía con
respecto al espacio de direcciones en el que se originó).
Esta característica asegura que un objeto conserve su estado a lo largo del tiempo y el
espacio. En otras palabras, la persistencia implica la capacidad de mantener la
información de un objeto de manera permanente, almacenándola de manera que pueda
ser recuperada y utilizada nuevamente en el futuro.
En el contexto de la persistencia, los objetos pueden clasificarse en dos categorías

principales: objetos transitorios y objetos persistentes.
40
Laura Villena
1. Objetos Transitorios: Estos objetos tienen un tiempo de vida limitado que
depende del espacio del proceso que los creó. Una vez que el proceso se
completa o finaliza, estos objetos dejan de existir.
2. Objetos Persistentes: En contraste, los objetos persistentes tienen la capacidad

de almacenar su estado en un medio de almacenamiento temporal, lo que les
permite ser reconstruidos y utilizados posteriormente. Esto significa que estos
objetos no dependen del proceso que los creó originalmente. Un ejemplo común
de persistencia es cuando un objeto se crea y luego se almacena en una base de
datos para su uso futuro.
41
Laura Villena
FIN
Laura Villena

Módulo 6 - Programación Orientada A Objetos

Cargado por

Copyright:

Formatos disponibles

Módulo 6 - Programación Orientada A Objetos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Módulo 6 - Programación Orientada A Objetos

Cargado por

Copyright:

Formatos disponibles

Programación

¡Hola, bienvenido al módulo 6!

En el módulo 6 nos vamos a introducir en los conceptos de Paradigmas de la Programación

La Programación Orientada a Objetos, que se abrevia como POO, consiste en un

En un sentido amplio, un paradigma se refiere a una teoría o conjunto de teorías que

En el paradigma de programación tradicional o estructurada, que era ampliamente

La mera orientación hacia la descomposición de subproblemas resulta insuficiente

La POO introdujo una nueva perspectiva en la forma de programar, buscando aportar

Pensemos en un objeto como si fuera un robot virtual: el programa contendrá

En resumen, podemos afirmar que la Programación Orientada a Objetos es una

Los lenguajes de Programación Orientada a Objetos (POO) proporcionan medios y

Existen varias ventajas destacadas en el paradigma orientado a objetos:

2. Permite manejar mejor la complejidad: Al organizar el código en objetos y clases,

3. Facilita el mantenimiento y la extensión de los sistemas: Los cambios y mejoras

5. Fomenta el reuso, con un gran impacto en la productividad y la confiabilidad: La

Nociones básicas UML

Antes de profundizar la lectura en los aspectos más importantes de la Programación

Es importante destacar que el UML no es en sí un lenguaje de programación, pero

Vamos a explorar algunos conceptos de modelado especificados por UML. El desarrollo

1. Modelado Funcional: Este tipo de modelado se basa en diagramas de casos de

2. Modelado de Objetos: En este caso, utilizamos diagramas de clases para describir

3. Modelado Dinámico: En este enfoque, se utilizan diferentes tipos de diagramas,

Nos centraremos en dos tipos de diagramas para comprender la Programación

El diagrama de clases es el tipo más frecuentemente utilizado en UML y constituye la

Los elementos básicos de un diagrama de clases incluyen:

1. Sección superior: En esta sección se encuentra el nombre de la clase, y esta

Existen diversas relaciones posibles entre clases:

2. Asociación: Es la relación predeterminada entre dos clases, donde ambas clases

3. Agregación: Se refiere a una relación en la que un objeto derivado puede existir

4. Composición: Es una relación en la que un objeto derivado no puede existir sin

El diagrama de objetos representa un objeto que ha sido instanciado o creado durante

3. Atributos: Los atributos de las clases se representan mediante rectángulos con

"El diagrama de objetos también es conocido como diagrama de instancias".

El diagrama de secuencia es una representación visual que permite describir el

1. Objetos: Se representan de manera similar a como se hace en el diagrama de

2. Líneas de Vida: Estas líneas representan a los participantes individuales en un

3. Mensajes: Los mensajes representan las interacciones entre los objetos. Un

4. Dimensiones: Los diagramas de secuencia tienen dos dimensiones principales.

1. Todo es un objeto: En un lenguaje orientado a objetos, todo en el sistema es

2. Cada objeto es construido a partir de otros objetos: Los objetos se construyen

5. Las clases se organizan en una estructura arbórea de raíz única, llamada

Ahora analicemos en profundidad cada término mencionado con más detalle…

Los objetos pueden definirse como las unidades básicas de construcción en la

Aquí hay algunas características generales que definen a los objetos:

• Tienen un nombre o identificador único: Cada objeto se identifica por un

• Poseen estados: Los objetos pueden estar en diferentes estados que

• Tienen un conjunto de métodos: Los objetos pueden realizar acciones o

• Tienen un conjunto de atributos: Los objetos tienen atributos que almacenan

• Soportan el encapsulamiento: El encapsulamiento significa que los detalles

Organización de los objetos

Los objetos en programación orientada a objetos pueden organizarse de manera

1. Jerarquía Simple: En este tipo de jerarquía, los objetos se organizan de manera

2. Jerarquía Compleja: En contraste, una jerarquía compleja es cualquier otra

Independientemente de la estructura jerárquica, en la Programación Orientada a

1. La raíz de la jerarquía: Este nivel corresponde a un objeto único que se encuentra

2. Los objetos intermedios: Estos objetos se encuentran un nivel debajo de la raíz

3. Los objetos terminales: Estos objetos también tienen ascendencia, pero no

Atributos de los Objetos