27. Programación Orientada a Objetos. Clases. Herencia. Polimorfismo.

Lenguajes

1. Introducción..........................................................................................................1
1.1. Relación con los ciclos impartidos en FP........................................................1
1.2. Introducción a la Programación.....................................................................1
1.3. Introducción a la Programación Orientada a Objetos.....................................1
2. Clases y Objetos.....................................................................................................1
2.1. Definición......................................................................................................1
2.2. Encapsulación: interfaz e implementación.....................................................2
2.3. Definición de clases.......................................................................................2
2.4. Paso de mensajes..........................................................................................2
2.5. Instanciación e Inicialización de Objetos.......................................................2
3. Herencia.................................................................................................................3
4. Polimorfismo..........................................................................................................3
5. Visibilidad y dependencia en la P.O.O.....................................................................3
6. Lenguajes de P.O.O...............................................................................................3
6.1. SmallTalk.......................................................................................................3
6.2. C++...............................................................................................................4
6.3. JAVA..............................................................................................................4
7. Diseño de software orientado a objetos.................................................................4
8. Bibliografía............................................................................................................5
27. Programación Orientada a Objetos. Clases. Herencia. Polimorfismo.
Lenguajes
1. Introducción
1.1. Relación con los ciclos impartidos en FP
Este tema está directamente relacionado con los siguientes módulos y ciclos formativos
de la rama de informática:
 CFGS Administración de Sistemas Informáticos:
o Fundamentos de programación (Informática).
 CFGS Desarrollo de Aplicaciones Informáticas:
o Programación en lenguajes estructurados (Informática).
1.2. Introducción a la Programación
 Instrucción: Es una cadena de símbolos de un alfabeto, formada de acuerdo con
ciertas reglas sintácticas que el procesador (o el compilador) entiende, y que
finalmente serán interpretadas y ejecutadas por el procesador.
 Programa: Conjunto de instrucciones en algún lenguaje de programación
suministradas al ordenador, ordenadas de una forma determinada, para que éste
ejecute las operaciones para resolver un problema.
 Lenguaje de programación: Técnica estándar de comunicación que permite
expresar las instrucciones que han de ser ejecutadas en una computadora. Consiste
en un conjunto de reglas sintácticas y semánticas que definen un programa
informático.
Un lenguaje de programación permite a un programador especificar de manera
precisa: sobre qué datos una computadora debe operar, cómo deben ser estos
almacenados y transmitidos y qué acciones debe tomar bajo una variada gama de
circunstancias. Todo esto, a través de un lenguaje que intenta estar relativamente
próximo al lenguaje humano o natural, tal como sucede con el lenguaje Léxico.
1.3. Introducción a la Programación Orientada a Objetos
 La P.O.O. es un paso más en la modularización de los bloques de código, incluyendo
en el mismo módulo las estructuras de datos y los algoritmos que pueden manipular
dichas estructuras. Se popularizó en los 80, en parte gracias a la popularidad de C++,
y en parte al auge de las GUI a las que se adapta particularmente bien.
 La P.O.O. considera a un programa como una colección de agentes ampliamente
autónomos, llamados objetos. Mediante la interacción de los objetos avanza la
ejecución del programa.
 Los objetos son entidades que combinan estado (es decir, datos), comportamiento
(esto es, procedimientos o métodos) e identidad (propiedad del objeto que lo
diferencia del resto). La programación orientada a objetos expresa un programa como
un conjunto de estos objetos, que colaboran entre ellos para realizar tareas y se
comunican mediante mensajes. Esto permite hacer los programas y módulos más
fáciles de escribir, mantener y reutilizar.
2. Clases y Objetos
2.1. Definición
 Objeto: Encapsulación del estado (valores de datos, propiedades) y del
comportamiento (métodos) correspondientes a la representación informática de un
problema de mayor nivel.
o Cada objeto es una instancia de la clase y su comportamiento queda determinado
por la clase a la que pertenecen.
o Se comunican mediante mensajes. La respuesta al mensaje recibido será la
invocación de un método. En C++ en método se describe como una función
miembro y al proceso de paso de mensajes a un objeto se le denomina invocación
a una función miembro.
 Clase: Generalización del concepto de objeto.
 Estructura estática: Las clases

1
 o Las clases son un tipo abstracto de datos equipado con una implementación a
veces parcial.
o Una clase se compone de atributos que determinan una estructura de
almacenamiento para cada objeto de la clase y de rutinas (métodos) que definen
las operaciones aplicables a los objetos y constituyen el único medio de acceder a
los atributos.
 Estructura dinámica: Los objetos
o Una clase es un modelo, mientras que un objeto es sólo un ejemplo concreto de
ese modelo.
o Un objeto es una instancia de alguna clase que consiste en una estructura de
datos formada por tantos campos como atributos tiene la clase. El estado del
objeto viene dado por el valor de dichos campos que sólo deben poder ser
consultados y modificados por los métodos de la clase.
o Los objetos son un concepto de tiempo de ejecución, son creados y manipulados
por el software cuando se ejecuta.
2.2. Encapsulación: interfaz e implementación
 Encapsulación
o Reagrupacmiento bajo un mismo nombre de datos y funciones que manejan
dichos datos.
o Los componentes del software deben actuar como cajas negras y la única forma
de comunicación con ellos debe ser mediante los canales establecidos, que a su
vez deben estar perfectamente definidos y controlados.
o Los módulos deben especificarse y diseñarse de forma que la información
(procedimientos y datos) contenida dentro de un módulo sea inaccesible a otros
módulos que no necesiten tal información.
o Los atributos de una clase pueden ser a su vez clases, pudiendo ser de otras
clases o referencias a estas (como punteros o referencias).
 Interfaz e implementación
o La encapsulación permite distinguir las dos caras del software. Por un lado está la
Interfaz, que es la parte pública y el modo en que una clase se comunica con el
mundo exterior. Y por otro la Implementación, de carácter privado, contiene el
código que sustenta la interfaz, e incluye constantes, tipos variables y
procedimientos de uso interno.
2.3. Definición de clases
class NombreClase{
[public/private/protected]
//variables miembro (propiedades)
[public/private/protected]
//funciones mienbro (métodos)
}
2.4. Paso de mensajes
rectangulo r; r.cambiar(3,5);
rectangulo *r = new(rectangulo); r->cambiar(3,5);
2.5. Instanciación e Inicialización de Objetos
 Se puede distinguir entre variables automáticas y dinámicas. En el primer caso, en
tiempo de ejecución, cuando se entra en un bloque que contiene las declaraciones de
una variable u objeto, se le asigna espacio de memoria automáticamente.
Paralelamente, cuando el bloque termina su ejecución, el espacio es liberado
automáticamente. Las variables dinámicas en cambio, han de ser explícitamente
asignadas mediante una función, que tanto en java como en C++ es new().
 Cuando se asigna memoria dinámicamente es preciso recuperarla de algún modo
cuando los datos dejen de ser necesarios. En el caso de C++ se obliga a que el
programador libere explícitamente el espacio reservado con new(), mediante la
palabra delete (normalmente desde los destructores de cada clase). En cambio en
2
 Smalltalk, Java o C#, se detecta automáticamente cuando los valores dejan de ser
accesibles (cuando ya no están referenciados) y no pueden usarse en ningún cálculo
futuro. La recolección de basura suele hacerse mediante un proceso en segundo plano,
en caso de java, el garbage Collection, la pega es que es costosa en cuanto a recursos
de cómputo.
 A la vez que se asigna memoria es posible dar valores iniciales a los campos de los
objetos. Esta inicialización puede llevarse a cabo por defecto o mediante la llamada
explícita a un método constructor de la clase. Tanto Java como C++ crean un
constructor por defecto, sin embargo, es posible definir constructores alternativos.
 Cuando se crea un objeto se llama automáticamente al constructor del objeto, que no
es otra cosa que un método con el mismo nombre que la clase en el que se puede
reservar memoria, dar valores iniciales a las propiedades, etc.
 Cuando se destruye un objeto porque finalice su bloque de código o porque se llame a
la función delete, se invoca automáticamente a su destructor (~NombreClase en C++
y finalize() en JAVA) en el que, normalmente, se implementarán el cierre de archivos,
liberación de memoria (sólo en C++), etc.
3. Herencia
“Reutilización y extensibilidad”
 La herencia proporciona todas las herramientas necesarias para crear clases a partir
de otras clases por extensión, especialización o combinación. Por herencia nos
referimos a la creación de clases hijas, a partir de otras clases padres, y a la
propiedad de que las instancias de una clase hija puedan tener acceso tanto a la
estructura de datos como al comportamiento asociados con una clase paterna.
 La herencia es multigeneracional y transitiva y organiza las clases en una estructura
jerárquica. Pudiendo así compartir y extender su comportamiento sin tener que
reimplementarlo. Esto suele hacerse habitualmente agrupando los objetos en clases y
estas en árboles o enrejados que reflejan un comportamiento común.
 La herencia puede ser simple, si hereda propiedades y procedimientos de una sola
clase, o múltiple, si lo hace de más de una. Esta característica está soportada
directamente en C++. En Java en cambio, sólo es posible la herencia de una única
clase, pero permite heredar de varios interfaces, que son en realidad clases con todos
los métodos abstractos, y por tanto, habrá que definirlos.
 Una clase hija puede heredar todos o parte de los métodos y las propiedades,
pudiendo a su vez reemplazar o refinar los métodos de la clase padre.
4. Polimorfismo
 Comportamientos diferentes, asociados a objetos distintos, pueden compartir el
mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento
correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y
las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación
de un comportamiento en una referencia producirá el comportamiento correcto para el
tipo real del objeto referenciado. Cuando esto ocurre en "tiempo de ejecución", esta
última característica se llama asignación tardía o asignación dinámica. Algunos
lenguajes proporcionan medios más estáticos (en "tiempo de compilación") de
polimorfismo, tales como la sobrecarga de funciones tanto en C++ como en JAVA y las
plantillas o la sobrecarga de operadores de C++.
5. Visibilidad y dependencia en la P.O.O.
 En C++ existen tres palabras clave: public, los miembros serán accesibles desde fuera
de la clase, protected, sólo accesibles desde dentro de la clase y clases derivadas, y
private, accesibles sólo desde dentro de la clase. amen de elementos como el
cualificador de ámbito :: y las funciones friend entre otros.
 En Java existen hasta cinco niveles: public, private, private protected, protected y
friendly. Las 3 primeras son similares a las de C++, y las 2 últimas están relacionadas
con los paquetes de Java.
6. Lenguajes de P.O.O.
6.1. SmallTalk

3
  No existe distinción entre clases y objetos sino que todo es un objeto, incluyendo las
propias clases o, por ejemplo, los tipos básicos como enteros o caracteres. Todo deriva
de una clase llamada objetc.
 Soporta la recolección de basura.
 Es el enfoque puro de orientación a objetos, sin embargo carece de comprobación
estática de tipos, mecanismos de aserciones, tratamiento de excepciones o clases
diferidas.
 Fue uno de los creadores del concepto de “maquina virtual” lo que asegura la
portabilidad entre sistemas.
6.2. C++
 Lenguaje de programación, diseñado a mediados de los ochenta, como extensión del
lenguaje de programación C.
 Es un lenguaje híbrido, que permite mezclar expresiones en C y C++, y resulta más
sencillo de aprender para los programadores que ya conocen C.
 Actualmente existe un estándar, denominado ISO C++, al que se han adherido la
mayoría de los fabricantes de compiladores más modernos.
 Las principales características del C++ son:
o Abstracción (encapsulación)
o Programación orientada a objetos (polimorfismo y herencia múltiple)
o Plantillas o programación genérica (templates)
o Sobrecarga de operadores
o Manejo de excepciones
o Bibliotecas disponibles de varios suministradores y para multitud de entornos
como, por ejemplo, las MFCs (Microsoft Fundation Classes) ¿.Net Framework?
 La evolución de C++ ha dado lugar a C#, un lenguaje creado por Microsoft dentro
de su plataforma Visual Studio .NET. Tiene una sintaxis similar a C++ pero es más
sencillo (por ejemplo se huye del uso de punteros) y parecido a java, el código fuente
se traduce a un código intermedio (MSIL, Microsoft Intermediate Language) que
posteriormente se ejecuta sobre una máquina virtual denominada .NET Framework,
consiguiendo así la independencia de plataforma hardware. .NET permite además la
programación en muchos más lenguajes, muchos O.O como Visual Basic.Net o J#.
6.3. JAVA
 Lenguaje desarrollado por Sun Microsystems a principios de los 90. Es ideal para
programar en Internet debido a que se ejecuta sobre una “máquina virtual” y por
tanto es portable e independiente de la plataforma de ejecución. Por el contrario, y
debido precisamente a que su lenguaje intermedio BYTECODE debe ser interpretado
sus prestaciones son inferiores a las de los lenguajes compilados como C++.
 Características:
o Es más simple que C++
o Es interpretado
o Permite la ejecución multitarea y los hilos (threads)
o Es robusto y más seguro que C++ (por ejemplo ha eliminado el uso de punteros)
o Incorpora recolección automática de memoria (garbage collection).
o Es fuertemente tipificado e incorpora comprobación estática de tipos.
o Dispone de una librería de clases estándar.
o Admite un cierto grado de herencia múltiple mediante interfaces.
o No dispone de plantillas (templates).
7. Diseño de software orientado a objetos
 Los métodos modernos de diseño de software orientado a objetos incluyen mejoras
entre las que están el uso de los patrones de diseño, diseño por contrato, y lenguajes
de modelado.

4
  Patrones de Diseño: son la base para la búsqueda de soluciones a problemas
comunes en el desarrollo de software y otros ámbitos referentes al diseño de
interacción o interfaces.
 Diseño por contrato (asertos): Ve las relaciones entre las clases y sus clientes
como un acuerdo formal, que expresa los derechos y obligaciones de cada parte.
 Lenguajes de modelado: Conjunto estandarizado de símbolos y de modos de
disponerlos para modelar (parte de) un diseño de software orientado a objetos. El
ejemplo más claro y usado es UML (Lenguaje Unificado de Modelado, Unified Modeling
Language). Es un lenguaje gráfico para visualizar, especificar, construir y documentar
un sistema de software. UML ofrece un estándar para describir un "plano" del sistema
(modelo), incluyendo aspectos conceptuales tales como procesos de negocios y
funciones del sistema, y aspectos concretos como expresiones de lenguajes de
programación, esquemas de bases de datos y componentes de software reutilizables.
8. Bibliografía
 Meyer, Bertrand: “Construcción de software orientado a objetos” 2ª Ed. Prentice hall
1999.
 Ceballos, J.F. “JAVA”.
 Ceballos, J.F. “C++”.
 Pressman, R.S.: “Ingeniería del software. Un enfoque práctico”. McGraw-Hill
 Alcalde, E y García, M.: “Metodología de la programación”. McGraw-Hill
 http://es.tldp.org Documentación libre en español de Linux/Unix
 http://www.tutorialparaprofesores.com Documentación de Microsoft para profesores
 http://technet.microsoft.com Documentación tecnológica de Microsoft
 https://msdn.microsoft.com Centro de desarrollo de Microsoft
 http://algoritmia.com Web sobre el diseño de algoritmos