REPUBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA

EDUCACIÓN UNIVERSITARIA
INSTITUTO UNIVERSITARIO POLITECNICO
SANTIAGO MARIÑO
Internacional/Valencia

Actividad 1 Video, presentación y trabajo 10%

Autor (Sergio, Contreras)

30.889.539

Docente: José Luis Guzmán Hútton

Asignatura: LENGUAJE DE PROGRAMACION II

Ing. En sistemas, 23/04/24

Índice

I. ¿Qué es la POO? .............................................................................. 2

- Paradigma de programación basado en objetos ............................... 2
- Los objetos son instancias de clases .................................................... 2
- Representan entidades del mundo real con datos y comportamientos…. 2

II. Características de la POO ...................................................................... 3

1. Clases y Objetos ................................................................................... 3
- Clases: plantillas o modelos que definen propiedades y métodos …... 3
- Objetos: instancias de una clase con sus propios valores .......................3

2. Encapsulamiento .................................................................................. 4
- Ocultar datos y detalles internos ............................................................ 4
- Controlar el acceso a los datos mediante métodos públicos ...................... 4

3. Herencia ............................................................................................ 5
- Crear nuevas clases basadas en clases existentes ................................ 5
- Reutilizar código y extender funcionalidades .......................................... 5

4. Polimorfismo ................................................................................................... 6
- Objetos pueden tomar múltiples formas .......................................................... 6
- Métodos con el mismo nombre pueden comportarse diferente según la clase... 6

III. Ventajas de la POO ............................................................................. 7

- Reutilización de código ............................................................................ 7
- Modularidad y organización del código ............................................................... 7
- Encapsulamiento y ocultamiento de datos .......................................................... 7
- Mantenibilidad y escalabilidad ..................................................................... 7
- Abstracción de conceptos del mundo real ............................................................ 7

IV. Desventajas de la POO ......................................................................... 8

- Complejidad y curva de aprendizaje ........................................................ 8
- Sobrecarga de memoria por creación de objetos ........................................... 8
- Dificultad para diseñar y planificar la arquitectura ............................................. 8

V. Instancias y Objetos ............................................................................... 9

- Instanciar una clase significa crear un nuevo objeto a partir de ella .......... 9
- Cada objeto tiene sus propios valores de propiedades .................................... 9
- Pueden invocar métodos definidos en la clase .................................................... 9

VI. Herencia ............................................................................................ 10

- Clase hija hereda propiedades y métodos de la clase padre .................. 10
- Reutilizar código existente y agregar nuevas funcionalidades ................... 10
 - Tipos de herencia: simple, múltiple, jerárquica ............................................... 10

VII. Polimorfismo ...................................................................................... 11

- Objetos de diferentes clases pueden responder al mismo método ......... 11
- Sobreescritura de métodos en clases hijas ................................................... 11
- Polimorfismo permite tratar objetos de manera genérica ................................ 11

VIII. Encapsulamiento .............................................................................. 12

- Ocultar datos y lógica interna dentro de una clase ................................ 12
- Controlar el acceso a los datos mediante métodos públicos ....................... 12
- Proteger la integridad de los datos ................................................................. 12

Conclusión ............................................................................................ 13
- Resumen de los conceptos clave de la POO ..................................... 13
- Importancia en el desarrollo de software moderno ........................... 13
- Invitación a seguir aprendiendo y practicando la POO ..................... 13

I. ¿Qué es la POO?

- La Programación Orientada a Objetos (POO) es un paradigma de

programación que se basa en el concepto de "objetos", los cuales son entidades
que combinan datos (o propiedades) y comportamientos (o métodos). Este
enfoque se aleja del tradicional estilo de programación procedural, centrándose
en la representación más fiel posible de objetos del mundo real en el código.

II. Características de la POO

1. Clases y Objetos

- Las clases actúan como plantillas o moldes que definen la estructura y

comportamiento de los objetos. Son como los planos de una casa, donde se
especifican los atributos y acciones que los objetos podrán tener.
- Los objetos, por otro lado, son las instancias concretas de estas clases, es
decir, son los "ejemplares" reales que se crean en el programa y que
interactúan entre sí.

2. Encapsulamiento
 - El encapsulamiento es un principio fundamental de la POO que consiste
en ocultar los detalles internos de un objeto y exponer solo la interfaz necesaria
para interactuar con él. Esto se logra definiendo métodos públicos que
permiten acceder y modificar los datos internos del objeto, mientras que el
resto de la implementación permanece protegida y segura dentro de la clase.

3. Herencia

- La herencia es un mecanismo mediante el cual una clase puede heredar

propiedades y comportamientos de otra clase, denominada clase padre o
superclase. Esto permite la reutilización de código y la creación de jerarquías
de clases, donde las clases más específicas (clases hijas o subclases) heredan
las características de las clases más generales.

4. Polimorfismo

- El polimorfismo es una característica que permite que objetos de

diferentes clases respondan de manera distinta a un mismo mensaje o acción.
Esto se logra mediante la definición de métodos con el mismo nombre en
diferentes clases, pero con implementaciones específicas para cada una. El
polimorfismo facilita el diseño de sistemas flexibles y adaptables, donde los
objetos pueden comportarse de manera variable según el contexto.

III. Ventajas de la POO

- La POO ofrece numerosas ventajas, entre las que se incluyen:

- Reutilización de código: al permitir la creación de clases y objetos que
encapsulan funcionalidades específicas, la POO fomenta la reutilización de
código en diferentes partes de un programa o incluso en proyectos distintos.

- Modularidad y organización del código: al dividir el programa en clases

y objetos, se facilita la gestión y comprensión del código, lo que conduce a una
mayor claridad y mantenibilidad.
- Encapsulamiento y ocultamiento de datos: al encapsular los datos dentro
de objetos y controlar su acceso mediante métodos, se promueve la seguridad y
la integridad de los datos, evitando su manipulación indebida.

- Mantenibilidad y escalabilidad: gracias a la estructura modular y flexible

de la POO, los programas pueden modificarse y ampliarse con relativa
 facilidad, lo que facilita su mantenimiento y evolución a medida que los
requisitos cambian.

- Abstracción de conceptos del mundo real: la POO permite modelar

entidades del mundo real de manera más precisa y natural, lo que facilita la
comprensión y el diseño de sistemas complejos.

IV. Desventajas de la POO

- Aunque la POO ofrece numerosas ventajas, también presenta algunas

desventajas, entre las que se incluyen:
- Complejidad y curva de aprendizaje: para comprender y aplicar
correctamente los principios y técnicas de la POO, es necesario adquirir un
conocimiento profundo de los conceptos involucrados, lo que puede resultar
desafiante para los principiantes.

- Sobrecarga de memoria por creación de objetos: en programas que

hacen un uso intensivo de la POO, la creación y gestión de numerosos objetos
puede generar una sobrecarga de memoria, lo que puede afectar al rendimiento
del sistema.

- Dificultad para diseñar y planificar la arquitectura: el diseño de sistemas

orientados a objetos requiere un cuidadoso análisis y planificación para
garantizar una estructura coherente y eficiente, lo que puede resultar
complicado en proyectos de gran envergadura o con requisitos cambiantes.

V. Instancias y Objetos

- Al instanciar una clase, se crea un nuevo objeto que posee sus propios
valores de propiedades y puede invocar los métodos definidos en la clase. Esto
permite la creación de múltiples instancias de una misma clase, cada una con
su propio estado y comportamiento.

VI. Herencia

- La herencia es un mecanismo fundamental de la POO que permite la

creación de jerarquías de clases, donde las clases hijas heredan propiedades y
comportamientos de las clases padres. Esto facilita la reutilización de código y
la creación de abstracciones más generales y flexibles.
 VII. Polimorfismo

- El polimorfismo es una característica esencial de la POO que permite que

objetos de diferentes clases respondan de manera distinta a un mismo mensaje
o acción. Esto facilita el diseño de sistemas flexibles y adaptables, donde los
objetos pueden comportarse de manera variable según el contexto en el que se
utilicen.

VIII. Encapsulamiento

- El encapsulamiento es un principio fundamental de la POO que consiste

en ocultar los detalles internos de un objeto y exponer solo la interfaz necesaria
para interactuar con él. Esto se logra definiendo métodos públicos que
permiten acceder y modificar los datos internos del objeto, mientras que el
resto de la implementación permanece protegida y segura dentro de la clase.
Ejemplos
 Anexos
■ Anexo 1: "Object-Oriented Programming with C++" Por E. Balagurusamy

■ Anexo 2: "Head First Object-Oriented Analysis and Design" Por Brett D.

McLaughlin, Gary Pollice y David
■ Anexo 3: "Effective Java" Por Joshua Bloch.

■ Anexo 4: "Python Object-Oriented Programming" Por Dusty Phillips.

■ Anexo 5: "Object-Oriented Software Engineering: A Use Case Driven Approach"

Por Ivar Jacobson.
■ Anexo 6: "Design Patterns: Elements of Reusable Object-Oriented Software" Por
Erich Gamma, Richard Helm, Ralph Johnson y John Vlissides.

■ Anexo 7: "Clean Code: A Handbook of Agile Software Craftsmanship" Por Robert

C. Martin.

■ Anexo 8: "Object-Oriented Analysis and Design with Applications" Por Grady

Booch, Robert A. Maksimchuk, Michael W. Engel, Bobbi J. Young, Jim Conallen y
Kelli A. Houston.

Recomendaciones
1. Practica la modularidad y el principio de responsabilidad única (SRP):
En la sección de Ventajas de la POO, se mencionó la modularidad como una
de las ventajas principales. Para aprovechar al máximo esta característica, es
importante diseñar clases que sigan el principio de responsabilidad única
(SRP), es decir, cada clase debe tener una única responsabilidad o motivo para
cambiar. Al dividir el sistema en clases cohesivas y bien definidas, facilitamos
la reutilización del código, la comprensión del sistema y su mantenimiento a lo
largo del tiempo.

2. Comprende y aplica los principios SOLID: Los principios SOLID son un

conjunto de cinco principios de diseño de software que se centran en la
creación de clases y sistemas de software más robustos, flexibles y
mantenibles. Cada letra de SOLID representa un principio específico:
 - S: Principio de responsabilidad única (SRP): una clase debe tener una única razón
para cambiar.

- O: Principio de abierto/cerrado (OCP): las clases deben estar abiertas para la

extensión, pero cerradas para la modificación.

- L: Principio de sustitución de Liskov (LSP): los objetos de un programa deben

ser sustituibles por instancias de su subtipo sin afectar a la corrección del programa.

- I: Principio de segregación de interfaces (ISP): los clientes no deben verse

obligados a depender de interfaces que no utilicen.

- D: Principio de inversión de dependencias (DIP): los módulos de alto nivel no

deben depender de los módulos de bajo nivel, ambos deben depender de
abstracciones. Además, las abstracciones no deben depender de los detalles, sino los
detalles de las abstracciones.

Referencias
1. "Clean Code: A Handbook of Agile Software Craftsmanship" de Robert C. Martin.
Este libro aborda varios principios de diseño de software, incluidos los principios
SOLID, y proporciona ejemplos prácticos para escribir un código limpio y
mantenible utilizando la Programación Orientada a Objetos.

2. "Object-Oriented Programming in C++" de Coursera. Este curso, ofrecido por la

Universidad de California, Santa Cruz, cubre los fundamentos de la Programación
Orientada a Objetos en C++ y proporciona una introducción práctica a los conceptos
clave, incluyendo clases, herencia, polimorfismo y encapsulamiento.

Conclusión

- La Programación Orientada a Objetos es un paradigma poderoso y versátil

que ha revolucionado la forma en que se desarrollan los sistemas de software.
Al centrarse en la representación de entidades del mundo real como objetos
con propiedades y comportamientos, la POO permite la creación de programas
más claros, modulares y mantenibles. Aunque presenta algunas desventajas,
sus numerosas ventajas la convierten en una herramienta indispensable para el
desarrollo de software moderno.