¿Qué es y para qué sirve  la programación orientada a objetos?

Cualquiera que haya programado un poco se dará cuenta de la importancia que tiene para el programador la dichosa documentación. Documentación que le sirve tanto a él como a otras personas (todavía no he conocido a uno al que le guste realizar tan atractiva labor).

Pero la cosa no se queda ahí, además sin una buena documentación un programador pierde el tiempo en hacer rutinas o procedimientos que ya estaban hechos con anterioridad y que posiblemente él mismo hizo. También una aplicación con mala documentación es muy difícil de depurar y de corregir errores posteriores a su implementación.

¿ y qué tiene esto que ver con la programación orientada a objetos ?

Este tipo de programación consiste en agrupar en "objetos" aquel código, rutinas, procedimientos, etc, que tengan cosas en común, de forma que cuando un programador las utilice sepa dónde encontrarlas. Un "nuevo"  concepto (entre comillas porque en realidad no es nuevo, pero bueno) que incluye la generación de aplicaciones "autodocumentadas". Una vez generado o construido un objeto el programador, y los que vengan detrás, podrán olvidarse por completo del objeto y sencillamente utilizarlo, al igual que hacemos con los textbox, commands, grids, etc.

Argumentos a favor de la POO:
Imaginemos que queremos utilizar ventanas en nuestro proyecto.
Queremos que estas ventanas puedan hacer dos cosas, abrirse y cerrarse. Además una ventana deberá tener una propiedad llamada "estado" que nos indique si está abierta o cerrada.
Con Visual Basic, sin utilizar la potencia de la POO escribiríamos algo parecido a esto:

            Sub Abrir()
                estado = 1 'Abrimos la ventana
            End Sub

            Sub Cerrar()
                estado = 0 'Cerramos la ventana
            End Sub

Si ahora otra persona, o incluso el mismo programador dentro de un mes, se pone a leer esto, estaréis de acuerdo conmigo en que no entenderá nada. No sabe qué es lo que abre ni lo que cierra ¿Cómo se va a dar cuenta de que está manipulando una ventana?
Pero eso no es todo. ¿Qué sucede si desea crear varias ventanas? ¿Cómo distingue unas de otras? ¿Definiendo más variables, como por ejemplo: estado1, estado2, etc?
¡Menudo lío! ¡Y estamos hablando de una simple ventana con una propiedad y dos métodos!
Hombre, exagero un poco, seguramente el programador haría algo así:
 

Sub Abrir (index as integer)
    estado(index) = 0 'Abrimos la ventana número index
End Sub

Sub Cerrar (index as integer)
    estado(index) = 1 'Cerramos la ventana index
End Sub

Es posible que haga esto, que se construya un Array de ventanas con sus correspondiente variables de estado.
La POO nos ofrece la posibilidad de una vez definida una clase (en este caso la clase ventana) poder crear tantas instancias (objetos) de esa clase como necesitemos y dotarlas de un nombre propio.

¿ Cómo se crea una clase ?

Una clase se puede crear utilizando un módulo de clase "class module".
Para crear un objeto, previamente hay que crear una clase. Una clase define los métodos de los objetos y sus propiedades.
Vamos con un ejemplo:

•         Abrir un nuevo proyecto
•         En el menú Insertar seleccionar "módulo de clase". Aparecerá en la ventana de nuestro proyecto el nuevo archivo Class1.

Analicemos el nuevo archivo:
Para poder acceder a sus propiedades seguramente no te baste con seleccionarlo en la ventana del proyecto y pulsar F4 sino que tendrás que abrirlo haciendo doble Click sobre él y posteriormente pulsar F4.
Al hacer esto observamos que tiene tres propiedades:

1. Propiedad "Instancing". Nos indica, en caso de que queramos hacer pública la clase (ya explicaremos esto) si podremos crear cero, una o n instancias de la clase (objetos). De momento poner Not Creatable.
2. Propiedad "Name". Con esta propiedad damos nombre a la clase que queremos crear. En nuestro ejemplo el nombre más apropiado sería "ventana".
3. Propiedad "Public". Como ya intuís con esta propiedad determinamos si hacemos o no pública nuestra clase (si queremos o no que otras aplicaciones puedan crear nuevos objetos de la clase ventana). De momento poner False. Nota: al poner false en esta propiedad se ignora el valor de la propiedad "Instancing"

Ya hemos creado la clase ventana. ¿Qué os parece?, ¿sencillo no?.
Sigamos analizando el formulario de clase...
Dicho formulario tiene en principio dos métodos: Initialize y Terminate. Abandonémoslos por ahora.

Ya estamos en disposición de empezar a crear los métodos y propiedades que van a definir la clase ventana.
Los métodos de una clase se definen sencillamente implementando funciones o procedimientos en el "general" del módulo de tipo Public
Las propiedades se definen definiendo variables también de tipo Public en el general del módulo.

Siguiendo con nuestro ejemplo, nuestra ventana ha de poder abrirse y cerrarse además de tener una propiedad llamada "estado" que nos indique si está abierta o cerrada.

Para definir pues la propiedad "estado" basta con escribir en el general del módulo de clase:

 

Public estado as integer '1 abierta, 0 cerrada

Para definir los métodos abrir y cerrar:

 
                                    Public Sub abrir()
                                        estado = 1
                                    End Sub

                                    Public Sub cerrar()
                                        estado = 0
                                    End Sub

 ¡Ya tenemos la clase ventana terminada!

¿Cómo se crea un objeto?

Siguiendo con el ejemplo creemos nuestro primer objeto ventana.
En el Form_Load del formulario del mismo proyecto (Form1) escribir lo siguiente:

                        Dim Ventana_salita As New ventana ' Creamos mi Ventana_salita
                        Ventana_salita.abrir 'Abramos la ventana de la salita
                        estado = Ventana_salita.estado 'comprobemos que efectivamente se ha abierto
                        Ventana_salita.cerrar 'Cerremos ahora la ventana
                        estado = Ventana_salita.estado

Ejecuta el código paso a paso para ir viendo el valor que va tomando la variable estado.

¿Qué ocurre si ahora queremos crear otra ventana? Puedes crear tantas ventanas (instancias de la clase ventana) como desees. Por ejemplo creemos la ventana del baño.

                        Dim Ventana_baño As New ventana
                        Ventana_baño.abrir
                        Ventana_baño.cerrar
                        ,etc

¿Qué os parece? A partir de ahora el programador sólo deberá recordar que puede crear ventanas y que las ventanas se pueden abrir y cerrar. Además, si algún día desea revisar el código asociado a los métodos abrir o cerrar sabrá dónde encontrarlo sin dificultad; en la clase ventana.

A continuación guardemos el proyecto con el nombre, por ejemplo, "libreria.vbp" (más adelante entenderéis porqué le llamo así)

Al hacerlo observaréis que se ha generado un archivo llamado ventana.cls. Este es el archivo de definición de la clase (por deformación yo directamente le llamo: el objeto ventana, aunque no existe ningún objeto hasta que no se crea una instancia de la clase, como ya sabéis con la orden As New)

Si ahora queréis utilizar el objeto ventana en nuevos proyectos basta con que en éstos insertéis el archivo de clase ventana.cls

Ya sé lo que estáis pensando, que valla chapuza. Cada proyecto que utilice el objeto ventana tendrá que tener insertado el archivo ventana.cls.
Esto ha de ser así porque no hemos dicho que la clase sea pública.
A continuación nos metemos con ese tema.

¿Cómo se crea una clase pública?

Antes de meternos directamente con el procedimiento conviene tener una serie de conceptos claros. Para que una aplicación pueda servir a otras aplicaciones objetos ambas tienen que entenderse a través de la interfaz de Automatización OLE.
Una aplicación hace de servidor OLE (servidor de objetos) y otra de cliente. Por ejemplo, cuando hacemos unas tablas en Excel y las queremos pegar en Word, Excel hace de servidor OLE y Word es el cliente. Ambos se entienden a través de la interfaz de automatización OLE y Excel le proporciona a Word el objeto "tabla" (en lugar de "ventana").

Así que, como habréis intuido, para que nuestro proyecto pueda servir el objeto ventana (ya que queremos que sea público) a otras aplicaciones deberemos convertir el proyecto en un servidor OLE.

¿Cómo se crea un servidor OLE? (sólo disponible en la versión profesional y para empresas)

Nada más sencillo (no diréis que no doy ánimos :)).
Para que un proyecto con clases se convierta en un servidor OLE el proyecto deberá contener además de las clases, un módulo con el procedimiento Sub Main, aunque en éste no escribamos nada de código. Así que manos a la obra:
 

• Insertar un módulo (normal) en el proyecto (module1)
• Si queréis podéis borrar el formulario Form1, ya que para nuestros propósitos no nos es de utilidad.
• Escribir en el módulo el procedimiento Sub Main vacío.

                                                Sub Main()
                                                End Sub
 

• Acceder a las propiedades de la clase ventana y hacerla pública. Para ello en la propiedad Public poner True. Si queréis que distintas aplicaciones puedan crear más de una instancia (objeto) poner la propiedad Instancing a Creatable MultiUse.

 

• Guardar el proyecto.

Repasemos. En nuestro proyecto tenemos un archivo llamado ventana.cls que define la clase ventana. También tenemos un módulo con un procedimiento Sub Main sin código alguno. No tenemos nada más. Además nuestra clase es pública y multiuse.
 

Ya reunimos todos los ingredientes para hacer de nuestro proyecto un servidor OLE.

Acceder al menú Archivo y seleccionar "Crear archivo Ole dll" (sólo disponible en la versión profesional y para empresas).
Dejar el nombre por defecto, que será "libreria.dll"
Si hemos llevado a cabo con éxito la operación se nos habrá generado dicho archivo y además se habrá registrado automáticamente en el registro de Windows.
Es interesante que accedamos al registro para ver un par de cosillas. Para ello ir a Menú Inicio, Ejecutar. Poner "regedit".
Una vez dentro del editor del registro de windows lo más sencillo para localizar los parámetros correspondientes a nuestro servidor OLE es que utilicemos el comando buscar, introduciendo como cadena a buscar "libreria.dll".

Una vez encontrada observemos el valor de las siguientes constantes:
 

• InprocServer32 = "c:windowsescritoriolibreria.dll". Esta constante indica el camino hasta la dll que hemos creado. Cada vez que queramos crear una instancia de una clase contenida en esta dll, el sistema la buscará ahí.
• ProgID = "project1.ventana". Este valor es muy importante. Será la cadena que deberemos escribir cuando desde nuestras aplicaciones queramos crear una instancia de ventana. project1 es la aplicación que nos sirve la clase ventana.

Una vez visto esto podemos salgamos del editor del registro de Windows e intentemos crear un objeto ventana para utilizar en una aplicación de Visual Basic.

¿Cómo se crea un objeto servido por un servidor OLE?
 
Abramos un nuevo proyecto con Visual Basic y escribamos las siguientes líneas de código en el Form_Load del formulario Form1.

                                    Dim ventana_cocina As Object
                                    Set ventana_cocina = CreateObject("proyect1.ventana")

Ya tenemos creado nuestro objeto sin necesidad de tener en el proyecto el archivo de clase ventana.cls.
Como antes, podemos hacer:

                                    ventana_cocina.abrir
                                    ventana_cocina.cerrar
                                    ,etc

Como ya se os habrá ocurrido, sería útil, a medida que hacemos aplicaciones, crear una especie de librería de objetos (quiero decir clases) para ser utilizada en cualquier momento. Todos ellos dentro de, por ejemplo, libreria.dll. De esta forma todo será más fácil de encontrar.

Ah, otra cosa, no creáis que me olvido de los métodos Initialize y Terminate comunes a todas las clases. Simplemente decir que se suele utilizar para reinicializar y comprobar parámetros comunes a la clase. Explicar cuándo se producen ambos eventos me ocuparía varias líneas y no lograría expresarlo bien. Lo mejor es que escribáis código en ellos y ejecutéis paso a paso para daros cuenta del momento exacto en el que se ejecutan. Baste decir que el evento Initialize se produce inmediatamente antes de referirnos al objeto por primera vez y el evento Terminate se produce cuando se encuentra la primera línea de código que ya no hace referencia al objeto.

En fin, el tema lo doy por finalizado.
Espero haber transmitido la utilidad de generar aplicaciones con programación orientada a objetos y que me hayáis entendido (más bien haberme explicado).
Lógicamente el ejemplo de la ventana es totalmente ilustrativo. Nadie va a crearse un objeto para hacer algo tan simple. Pero la potencia de la POO nos facilita mucho las cosas cuando debemos agrupar procedimientos o código que sea muy complejo y del que no nos queramos volver a acordar. Simplemente creamos una instancia y la utilizamos.