Índice

Introducción ........................................................................................................................................ 3
1.1 Paradigma de la POO y visual ........................................................................................................ 4
Paradigma de la POO....................................................................................................................... 4
Paradigma Visual ............................................................................................................................. 4
2.1 Lenguajes de programación visual y orientada a eventos ............................................................ 5
Lenguajes de programación visual .................................................................................................. 5
Lenguaje de programación orientada a objetos ............................................................................. 6
3.1 Elementos del modelo de objetos: clases, objetos, abstracción, modularidad, encapsulamiento,
herencia y polimorfismo ..................................................................................................................... 7
Clase ................................................................................................................................................ 7
Objeto.............................................................................................................................................. 8
Abstracción...................................................................................................................................... 8
Modularidad .................................................................................................................................... 9
Encapsulamiento ............................................................................................................................. 9
Herencia ........................................................................................................................................ 10
Polimorfismo ................................................................................................................................. 10
Conclusión ......................................................................................................................................... 10
Introducción

En este escrito estudiaremos sobre los lenguajes de programación dirigida a objetos

y su paradigmas y sus componentes, un paradigma es una forma de entender y representar la
realidad: un conjunto de teorías, estándares y métodos que, juntos, representan un modo de
organizar el pensamiento, es decir, un modo de ver el mundo, al igual que un lenguaje
dirigido a objetos tratan a los programas como conjuntos de objetos que se ayudan entre ellos
para realizar acciones. Entendiendo como objeto al entidades que contienen datos.
Permitiendo que los programas sean más fáciles de escribir, mantener y reutilizar, estos temas
mencionados serán desarrollado a lo largo del trabajo.
1.1 Paradigma de la POO y visual

Paradigma de la POO

Los lenguajes de programación proporcionan mecanismos para implementar una

filosofía o paradigma de programación. Un paradigma es una forma de entender y representar
la realidad: un conjunto de teorías, estándares y métodos que, juntos, representan un modo
de organizar el pensamiento, es decir, un modo de ver el mundo. Cada nuevo paradigma
responde a una necesidad real de nuevas formas de afrontar problemas. A menudo un nuevo
paradigma es creado como respuesta a las deficiencias de paradigmas anteriores. Un
paradigma de programación es una forma de conceptualizar en qué consiste la ejecución de
un programa y cómo deben de estructurarse y organizarse las tareas que se llevaran a cabo
en esa ejecución.

Paradigma Orientado a Objetos

El paradigma orientado a objetos (OO) define los programas en términos de

comunidades de objetos. Los objetos con características comunes se agrupan en clases (un
concepto similar al de tipo abstracto de dato (TAD)). Los objetos son entidades que combinan
un estado (es decir, datos) y un comportamiento (esto es, procedimientos o métodos). Estos
objetos se comunican entre ellos para realizar tareas. Es en este modo de ver un programa
donde este paradigma difiere del paradigma imperativo o estructurado, en los que los datos
y los métodos están separados y sin relación. El paradigma OO surge para solventar los
problemas que planteaban otros paradigmas, como el imperativo, con el objeto de elaborar
programas y módulos más fáciles de escribir, mantener y reutilizar. Entre los lenguajes que
soportan el paradigma OO están Smalltalk, C++, Delphi (Object Pascal), Java y C#.

Paradigma Visual

El concepto de programación visual es un poco confuso ya que actualmente se le

considera programación visual a los lenguajes de programación textual que tienen una
interfaz gráfica para poder visualizar lo que uno está desarrollando. Este concepto en
programación visual es erróneo ya que este es aquel que por medio de iconos puedes ir
creando programas sin tener un lenguaje textual atrás de él. La programación visual

(visual programming) se refiere al desarrollo de software donde las notaciones gráficas y los
componentes de software manipulables interactivamente son usados principalmente para
definir y componer programas. La programación visual se define comúnmente como el uso
de expresiones visuales(tales como gráficos, animación o iconos) en el proceso de la
programación, pueden ser utilizadas para formar la sintaxis de los nuevos lenguajes de
programación visuales que conducen a los nuevos paradigmas tales como programación por
la demostración; o pueden ser utilizadas en las presentaciones gráficas del comportamiento
o de la estructura de un programa. El objetivo de la programación visual es mejorar la
comprensión de los programas y simplificar la programación en sí. Más allá, la programación
visual deberá fomentar a los usuarios finales a construir sus propios programas, que de otra
forma deben ser escritos por programadores profesionales.

2.1 Lenguajes de programación visual y orientada a eventos

Lenguajes de programación visual

Es un idioma artificial diseñado para expresar computaciones que pueden ser llevadas
a cabo por máquinas como las computadoras. Pueden usarse para crear programas que
controlen el comportamiento físico y lógico de una máquina, para expresar algoritmos con
precisión, o como modo de comunicación humana.

Para que la computadora entienda nuestras instrucciones debe usarse un lenguaje

específico conocido como código máquina, el cual la máquina comprende fácilmente, pero
que lo hace excesivamente complicado para las personas. De hecho sólo consiste en cadenas
extensas de números 0 y 1. La primera programadora de computadora conocida fue Ada
Lovelace. Incluso aunque Babbage nunca completó la construcción de cualquiera de sus
máquinas, el trabajo que Ada realizó con éstas le hizo ganarse el título de primera
programadora de computadoras del mundo. El nombre del lenguaje de programación Ada
fue escogido como homenaje a esta programadora. Todos este tipo de lenguaje se
denominaba de bajo nivel. A medida que la complejidad de las tareas que realizaban las
computadoras aumentaba, se hizo necesario disponer de un método más eficiente para
programarlas. Entonces, se crearon los lenguajes de alto nivel.

Lenguaje orientado a procedimientos que hace énfasis en los procedimientos.

Lenguaje orientado a problemas el cual los resuelve sin el detalle de la programación y el
Lenguaje orientado el cual hace énfasis en el objeto de la acción.

Lenguajes de Programación

 Lenguajes de Programación Cobol

 Lenguajes de Programación Lenguaje C
 Lenguajes de Programación Fortran
 Lenguajes de Programación Pascal

Lenguaje de programación orientada a objetos

Los lenguajes de programación orientados a objetos tratan a los programas como

conjuntos de objetos que se ayudan entre ellos para realizar acciones. Entendiendo como
objeto al entidades que contienen datos. Permitiendo que los programas sean más fáciles de
escribir, mantener y reutilizar. Los objetos tienen toda la información (atributos) que los
diferencia de otros pertenecientes a otra clase. Por medio de unos métodos se comunican los
objetos de una misma o diferente clase produciendo el cambio de estado de los objetos. Esto
hace que a los objetos se les trate como unidades indivisibles en las que no se separan la
información ni los métodos usados en su tratamiento.

Los lenguajes de programación orientadas a objetos son lenguajes dinámicos en los

que estos objetos se pueden crear y modificar sobre la marcha. Esta programación orientada
a objetos (POO) tomo auge a mediados de los años ochenta debido a la propagación de las
interfaces gráficas de usuarios, para lo que los lenguajes de programación orientados a
objetos están especialmente dotados.

Los principales lenguajes de programación orientados a objetos son:

 Ada
 C++
 C#
  VB.NET
 Clarion
 Delphi
 Eiffel
 Java
 Lexico (en castellano)
 Objective-C
 Ocaml
 Oz
 PHP
 PowerBuilder
 Python
 Ruby
 Smalltalk.

No todos estos lenguajes de programación orientados a objetos son específicamente

orientados a objetos. Sino que algunos de ellos se le han añadido extensiones orientadas a
objetos.

3.1 Elementos del modelo de objetos: clases, objetos, abstracción, modularidad,

encapsulamiento, herencia y polimorfismo

Clase

En la programación orientada a objetos, una clase es una construcción que se utiliza como
un modelo (o plantilla) para crear objetos de ese tipo. El modelo describe el estado y el
comportamiento que todos los objetos de la clase comparten. Un objeto de una determinada
clase se denomina una instancia de la clase. La clase que contiene (y se utilizó para crear)
esa instancia se puede considerar como del tipo de ese objeto, por , una instancia del objeto
de la clase "Personas" sería del tipo

"Personas".
 Una clase por lo general representa un sustantivo, como una persona, lugar o
(posiblemente bastante abstracta) cosa - es el modelo de un concepto dentro de un programa
de computadora. Fundamentalmente, encapsula el estado y el comportamiento del concepto
que representa. Encapsula el estado a través de marcadores de datos llamados atributos (o
variables miembro o variables de instancia), encapsula el comportamiento a través de
secciones de código reutilizables llamados métodos.

Objeto

En el paradigma de programación orientada a objetos (POO, o bien OOP en inglés),

un objeto se define como la unidad que en tiempo de ejecución realiza las tareas de un
programa. También a un nivel más básico se define como la instancia de una clase.

Estos objetos interactúan unos con otros, en contraposición a la visión tradicional en la cual
un programa es una colección de subrutinas (funciones o procedimientos), o simplemente
una lista de instrucciones para el computador. Cada objeto es capaz de recibir mensajes,
procesar datos y enviar mensajes a otros objetos de manera similar a un servicio.

Abstracción

La abstracción consiste en aislar un elemento de su contexto o del resto de los

elementos que lo acompañan. En programación, el término se refiere al énfasis en el "¿qué
hace?" más que en el "¿cómo lo hace?" (característica de caja negra). El común denominador
en la evolución de los lenguajes de programación, desde los clásicos o imperativos hasta los
orientados a objetos, ha sido el nivel de abstracción del que cada uno de ellos hace uso.

Los lenguajes de programación son las herramientas mediante las cuales los
diseñadores de lenguajes pueden implementar los modelos abstractos. La abstracción
ofrecida por los lenguajes de programación se puede dividir en dos categorías: abstracción
de datos (pertenecientes a los datos) y abstracción de control (perteneciente a las estructuras
de control).

Los diferentes paradigmas de programación han aumentado su nivel de abstracción,

comenzando desde los lenguajes de máquina, lo más próximo al ordenador y más lejano a la
comprensión humana; pasando por los lenguajes de comandos, los imperativos, la
orientación a objetos (OO), la Programación Orientada a Aspectos (POA); u otros
paradigmas como la programación declarativa, etc.

Modularidad

En programación modular, y más específicamente en programación orientada a

objetos, se denomina Modularidad a la propiedad que permite subdividir una aplicación en
partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente
como sea posible de la aplicación en sí y de las restantes partes.

Estos módulos que se puedan compilar por separado, pero que tienen conexiones con
otros módulos. Al igual que la encapsulación, los lenguajes soportan la Modularidad de
diversas formas.

Según Bertrand Meyer "El acto de particionar un programa en componentes

individuales para reducir su complejidad en algún grado. A pesar de particionar un programa
es útil por esta razón, una justificación más poderosa para particionar un programa es que
crea una serie de límites bien definidos y documentados en el programa. Estos límites, o
interfaces, son muy valiosos en la comprensión del programa.

Encapsulamiento

En programación modular, y más específicamente en programación orientada a

objetos, se denomina encapsulamiento al ocultamiento del estado, es decir, de los datos
miembro, de un objeto de manera que sólo se puede cambiar mediante las operaciones
definidas para ese objeto.

Cada objeto está aislado del exterior, es un módulo natural, y la aplicación entera se
reduce a un agregado o rompecabezas de objetos. El aislamiento protege a los datos asociados
a un objeto contra su modificación por quien no tenga derecho a acceder a ellos, eliminando
efectos secundarios e interacciones.
Herencia

En orientación a objetos la herencia es el mecanismo fundamental para implementar

la reutilización y extensibilidad del software. A través de ella los diseñadores pueden
construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y
verificadas) evitando con ello el rediseño, la modificación y verificación de la parte ya
implementada. La herencia facilita la creación de objetos a partir de otros ya existentes,
obteniendo características (métodos y atributos) similares a los ya existentes.

Es la relación entre una clase general y otra clase más específica. Por ejemplo: Si
declaramos una clase párrafo derivada de una clase texto, todos los métodos y variables
asociadas con la clase texto, son automáticamente heredados por la subclase párrafo.

Polimorfismo

En programación orientada a objetos el polimorfismo se refiere a la capacidad para

que varias clases derivadas de una antecesora utilicen un mismo método de forma diferente.

Por ejemplo, podemos crear dos clases distintas: Pez y Ave que heredan de la
superclase Animal. La clase Animal tiene el método abstracto mover que se implementa de
forma distinta en cada una de las subclases (peces y aves se mueven de forma distinta).

Como se mencionó anteriormente, el concepto de polimorfismo se puede aplicar tanto

a funciones como a tipos de datos. Así nacen los conceptos de funciones polimórficas y tipos
polimórficos. Las primeras son aquellas funciones que pueden evaluarse o ser aplicadas a
diferentes tipos de datos de forma indistinta; los tipos polimórficos, por su parte, son aquellos
tipos de datos que contienen al menos un elemento cuyo tipo no está especificado.

Conclusión

En este escrito pudimos comprender en totalidad los paradigmas de los lenguajes de

programación POO para poder así ser llevados la práctica y mejorar un entendimiento
correcto, teniendo conocimientos solidos y fuertes en este ámbito de la programación,
comprendimos lo estructurado que están los programas y su aplicación de cada uno.