Tutorial de Programación Orientada a Objetos

con C++

1. Definición de Clase y Objeto ............................................................................................. 3

1.1. Clase .......................................................................................................................... 3

1.2. Objeto ....................................................................................................................... 3

2. Definición de Atributo y Método ...................................................................................... 3

2.1. Atributo ..................................................................................................................... 3

2.2. Método ..................................................................................................................... 3

3. Herencia ............................................................................................................................ 4

3.1. Herencia Simple ........................................................................................................ 4

3.2. Herencia Múltiple ..................................................................................................... 4

4. Abstracción ....................................................................................................................... 4

4.1. Características ........................................................................................................ 5

5. Polimorfismo ..................................................................................................................... 5

6. Sobrecarga de Métodos .................................................................................................... 5

1. Ejemplo Clase .................................................................................................................... 6

2. Ejemplo Objeto ................................................................................................................. 8

3. Ejemplo Herencia Simple .................................................................................................. 8

4. Ejemplo Herencia Múltiple ............................................................................................... 9

5. Ejemplo Abstracción ....................................................................................................... 11

6. Ejemplo Sobrecarga de Métodos .................................................................................... 13

Introducción

Hola a todos, en este pequeño tutorial que tratará de ser lo más entendible y

sencillo posible para entender conceptos sobre la Programación Orientada a

Objetos, revisándolo de forma teórica y con implementación de sencillas

aplicaciones. La dinámica que trabajaremos será conceptualizar los términos

de acuerdo a como se definen técnicamente, y a los cuales agregaré la

forma en cómo los entiendo según mi punto de vista.

Se pueden encontrar muchos tutoriales por toda la Red sobre este tema,

pero como les digo en este trataré de que quede lo más entendible, hablando

en un lenguaje muy natural.

Acerca del IDE, o plataforma a usar, pues hay muchas BorlandC++, Dev-

Cpp, Netbeans, por nombrar algunos. Para nuestro caso, vamos a usar el

IDE Dev-Cpp (http://s3.amazonaws.com/00001-all-ES/devcpp-

4.9.9.2_setup.exe). Y hablando ya pues particularmente me gusta mucho el

Netbeans y el Dev-Cpp.

Para los que deseen emplear Netbeans, habrá que incorporarle el plugin

(Herramienta) de C/C++ que proveen.

1. Definición de Clase y Objeto En la programación en C++, (y en la mayoría de lenguajes estructurados), es muy común ver el uso del término TAD o TDA (Tipo de Dato Abstracto), pero bueno, pues esta no es la esencia en esta introducción. Y hago la suposición de que se haya visto algo sobre esto en su clase de programación.

1.1. Clase Definición Técnica: Es una representación real de un TDA. Define atributos y métodos que implementa la estructura de datos. La Defino: Define el modelo que van a seguir los Objetos que se instancien de ella. Define comportamientos y características que van a tener los objetos. Ver Ejemplo.

1.2. Objeto Definición Técnica: Un objeto es una instancia de una clase. Puede ser identificado en forma única por su nombre, el cuál es representado por los valores de sus atributos en un momento en particular. Lo Defino: Al ser una instancia de una clase, es el que decide cómo se va a comportar de acuerdo a lo que le haya definido la clase. Ver Ejemplo.

2. Definición de Atributo y Método

2.1. Atributo Definición Técnica: Características individuales que diferencian un objeto de otro y determinan su apariencia, estado u otras cualidades. Lo Defino: Aunque la definición anterior está muy clara, pues solo me restaría decir, que son las variables que se crean dentro de la clase, las cuales toman valores distintos para cada objeto.

2.2. Método Definición Técnica: Definen el comportamiento de los objetos de una clase, es un conjunto de instrucciones que realizan una determinada tarea y son similares a las funciones de los lenguajes estructurados. Lo Defino: Además de dar la posibilidad de comportamiento a los objetos, son muy usados también para ir separando código que es muy extenso y en la definición de la clase se note mayor orden y quede más entendible. Y con esto ir dando pasos a la modularidad y reusabilidad.

3. Herencia Definición Técnica: Es el mecanismo que permite que una clase A herede propiedades de una clase B. Se Dice que "A hereda de B". Objetos de la clase A tienen así acceso a los atributos y métodos de la clase B sin necesidad de redefinirlos. La Defino: Es un proceso por el que se crean unas clases a partir de otra(s) que ya existe(n), pensando sobre todo en la reutilización de código. Otra cosa que se tiene es que las clases que heredan (subclases, clases hijas) son más completas y específicas que las superclases o clases padre. Esto se da mucho cuando se nota que en una clase se usan muchas características y comportamientos de otra(s), entonces se opta por usar Herencia.

3.1. Herencia Simple Esto es cuando una clase hereda de una y solo una, clase padre. Es el tipo de herencia más común y es soportado por todos los lenguajes de Programación Orientados a Objetos. Ver Ejemplo.

3.2. Herencia Múltiple Esto es cuando una clase puede heredar de varias superclases. No es muy común usar este tipo de herencia y además no todos los Lenguajes de Programación Orientada a Objetos lo soportan. C++ sí lo tiene. Ver Ejemplo.

4. Abstracción Definición Técnica: Una clase A se llama clase abstracta si es usada solamente como una superclase para otras clases. La Clase A solamente especifica propiedades. No se usa para crear objetos. Las clases derivadas deben definir las propiedades de A. La Defino: El concepto es precisamente lo que se dice en la anterior definición, pero ya explicándolo un poco mejor, sería algo así: Es la capacidad que tienen las clases para “ocultar” información acerca del comportamiento y propiedades que van a tener las clases que hereden de ella. Ver Ejemplo.

4.1. Características

Las clases abstractas pueden implementar o no métodos. Cuando no los implementan, estos son abstractos.

Las clases abstractas no se pueden instanciar directamente, sólo pueden ser heredadas.

Las clases que heredan de una clase abstracta, son las que deben implementar los métodos abstractos que éstas posean.

5. Polimorfismo Definición Técnica: Capacidad que tienen los objetos de una clase de responder al mismo mensaje o evento en función de los parámetros utilizados durante su invocación. Un objeto polimórfico es una entidad que puede contener valores de diferentes tipos durante la ejecución del programa. Dicho de otra forma, el polimorfismo consiste en conseguir que un objeto de una clase se comporte como un objeto de cualquiera de sus subclases. Lo Defino: Enfocado en el último punto de la Definición Técnica, a través del manejo de herencia se puede llegar a poner en práctica este concepto. Ya que es como lo definen: “conseguir que un objeto de una clase se comporte como cualquiera de sus subclases”

6. Sobrecarga de Métodos Definición Técnica: Se refiere a la posibilidad de tener dos o más funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o más funciones con el mismo nombre realizan acciones diferentes. El compilador usará una u otra dependiendo de los parámetros usados. La Defino: Me parece que la definición anterior queda muy clara. Le agregaría, que para diferenciar estos métodos o funciones, se realiza con el cambio en la firma del método (que se refiere al uso de diferentes parámetros). Ver Ejemplo.

EJEMPLOS

1. Ejemplo Clase

Imagen 1 Persona.h

Imagen 2 Persona.cpp Parte 1

Imagen 3 Persona.cpp Parte 2

2. Ejemplo Objeto

Imagen 4 Ppal.cpp

3. Ejemplo Herencia Simple

Imagen 5 Adulto.h

Imagen 6 Infante.h

4. Ejemplo Herencia Múltiple

Imagen 7 PuntoB.cpp

Imagen 8 C1.cpp

Imagen 9 C2.cpp

Imagen 10 D.cpp

5. Ejemplo Abstracción

Imagen 11 Cuenta.h

Imagen 12 CuentaDeAhorros.cpp

Imagen 13 CuentaCorriente.cpp

6. Ejemplo Sobrecarga de Métodos

Imagen 14 Cuenta.h

Imagen 15 Cuenta.cpp

Imagen 16 Ppal.cpp