Curso básico de programación en Visual Basic

  Lección 37

Las clases

 

Realizamos programas para la gestión de empresas. Empresas medianas y pequeñas. Programas de contabilidad, cartera de pedidos clientes proveedores, facturación control de albaranes, tesorería cartera de cobros y pagos y estadísticas. Nuestro agradecimiento a todos los que por unas causas o por otras visitan nuestra web. Gestión de empresas PYMES. Curso de programación de Visual Basic.

Con la futura versión de Visual Basic, (la 7 o Visual Basic.Net), casi a la vuelta de la esquina, (se espera que para antes de que acabe este año 2001, esté en el mercado), es conveniente de que sepas de que va todo esto de las clases, no me refiero a "dar clases", (enseñar a alguien), sino a los módulos de clases, esos ficheros con la extensión .cls

De todas formas, creo que ya iba siendo hora de atacar el tema de las clases, entre otras cosas porque creo que es conveniente conocer cómo usarlas en nuestras aplicaciones, ya que pueden aliviarnos la tarea de crear y re-usar código; pero lo más importante es porque, si se usan de la forma adecuada, pueden permitirnos crear aplicaciones "troceadas" de forma que podamos mejorar partes de esos trozos sin necesidad de cambiar nada del resto del código que las usan... (no voy a adelantarme, así que, tendrás que esperar un poco para que realmente puedas entender de que estoy hablando).

Nota:
Como ya comenté en la entrega 30, la versión, (o versiones), de Visual Basic que hace mejor uso de las clases, sobre todo de las colecciones, es la versión 5, (y mejor aún la 6, aunque con la versión 5 será más que suficiente), por tanto, si estás usando una versión anterior a la 5, puede que algunos de los ejemplos que muestre no funcione correctamente, sobre todo en el tema de las propiedades por defecto y en el manejo de colecciones propias. De todas formas, confío en que todo lo que explique te quede claro, incluso si usas la versión 4, ya que con versiones anteriores, no podrás usar los módulos de clases, simplemente porque ¡Visual Basic no sabe de que se trata!

Si no tienes el Visual Basic 5 o superior, puedes bajarte del sitio de Microsoft una versión reducida, que aunque no te permite crear ejecutables, si que puedes probar todo lo que aquí veamos, aunque sea en el propio entorno integrado (IDE).
Si no lo han cambiado de sitio, dicha versión de VB: la VB5CCE (Visual Basic 5 Control Creation Edition), la puedes encontrar en la siguiente dirección: http://msdn.microsoft.com/vbasic/downloads/tools/cce/default.aspx

Nota del 30/Jun/2003:
He actualizado el link del VB5CCE. Si vuelven a cambiarlo de sitio, es posible que en la dirección indicada no lo encuentres, así que tendrás que buscar en el sitio de Microsoft por "Control Creation Edition" y ¡suerte!
También te puedes pasar por la página VB-Resumen de mi sitio y allí seguramente el link esté más actualizado.

Ya sin más preámbulos, vamos a empezar con el tema que nos interesa:

Los módulos de clases

Seguramente habrás oído hablar sobre Programación Orientada a Objetos, (OOP Object Oriented Programing), Herencia, Polimorfismo, Encapsulación o simplemente que existen un tipo de fichero en Visual Basic, (a partir de la versión 4 inclusive), llamado módulos de clases, (esos fichero tienen la extensión .cls)

Nota:
Aunque no lo sepas, ya has estado trabajando con clases, ya que los formularios son realmente módulos de clases de un tipo especial.

Hasta ahora, todo el código que hemos estado utilizando, sobre todo los procedimientos, los hemos podido usar de forma directa, sin tener que hacer nada especial. Por ejemplo, en el código de la entrega anterior usábamos el procedimiento Buscar para realizar una búsqueda en la base de datos, dicho procedimiento estaba "escrito" en el propio formulario, por tanto la "visibilidad" o ámbito del mismo está limitado a dicho formulario.
El tema de la visibilidad ya se trató en la entrega 26, en dicha entrega vimos un ejemplo de un formulario y un módulo BAS y cómo podíamos acceder a unas variables y a un procedimiento declarados con el "modificador" Public. También vimos cómo, podíamos acceder a variables con el mismo nombre declaradas en el formulario y el módulo BAS, simplemente indicando el nombre del módulo delante de la variable en cuestión, por tanto, te recomiendo que, si no tienes claro esto de la visibilidad de las variables y los procedimientos, le eches un vistazo a dicha entrega. Simplemente, a título recordatorio, te diré que la visibilidad es el ámbito que tienen las variables y los procedimientos, es decir en que parte del código son accesibles (visibles) y en cuales no.

Para usar los módulos de clases es muy importante tener estos conceptos claros, ya que de no ser así, vas a estar más perdido que una chiva en un garaje y no te enterarás de nada... te aviso.

Clases = Objetos (y viceversa)

Como te decía antes, sin saberlo, has estado usando objetos todo el tiempo. Un formulario es un tipo especial de clase, un botón, (CommandButton), es un objeto, (internamente es una clase). Todos los objetos tienen la característica de tener sus propios métodos, propiedades e incluso eventos.
Por ejemplo, el mencionado botón, tiene propiedades, como Caption, Visible, etc, También tiene eventos como Click, MouseMove, etc. Y también tiene métodos, por ejemplo Refresh, Move, etc. Lo mismo ocurre con los formularios, también tienen métodos, propiedades y eventos. Pero todos estos objetos ya existen, simplemente los usamos y ya está.
Lo que en esta entrega (y en otras más) aprenderemos es cómo poder crear nuestros propios objetos, con sus métodos, propiedades y eventos, y todo ello gracias a los módulos de clases.

Nota:
En el resto de esta entrega, usaré tanto la palabra objeto como la palabra clase, estas se referirán tanto a los objetos ya existentes, (más comúnmente conocidos como controles), como a los que nosotros podamos crear, ya sean tanto objetos de código como controles propiamente dicho, (en futuras entregas aprenderemos a crear nuestros propios controles ActiveX u OCX). Sólo espero que no te confundas.

Clases/Objetos = Encapsulación:

La ventaja de usar clases en nuestros proyectos es que podemos encapsular todo el código y tratarlas como si de cajas negras se tratasen, es decir, sabemos que es lo que hacen, cómo usarlas, pero no es imprescindible saber el código que se usa para que todo funcione.
Por tanto una de las características principales que un objeto (o clase) debe tener es que no dependa del exterior, es decir, que sea autosuficiente: todo la información que necesite se debe suministrar mediante las propiedades que dicha clase u objeto exponga al exterior, (mediante las propiedades públicas) y de igual manera, toda la información que un objeto deba mostrar al mundo exterior, se haga mediante las propiedades, métodos y eventos que dicha clase exponga al exterior, (declarados como públicos).

Bien, para entrar en calor, creo que lo mejor es ver un ejemplo.
Asi que abre el Visual Basic, crea un nuevo proyecto EXE y sigue estos pasos para añadir un módulo de clase:
Abre el menú Proyecto y pulsa en: Añadir Módulo de Clase, te mostrará un cuadro de diálogo mostrándote varias tipos de módulos de clase, pulsa en la primera que te muestra: Módulo de Clase, pulsa en Abrir y se añadirá un nuevo fichero, si te fijas en la ventana de propiedades, tendrá como nombre: Class1, (al menos así es como se llama en la versión inglesa de Visual Basic, que es la que yo uso).
Ese nombre será el que identificará al objeto cuando queramos acceder a él, (realmente será el que usaremos para crear variables que accedan a dicho objeto), por tanto es importante darle un nombre con el cual podamos, más o menos, identificar el uso para el que se ha creado dicho objeto.
Por tanto vamos a darle un nombre a la clase, y como en este ejemplo vamos a usar el objeto para almacenar los datos de un "colega" nuestro, le daremos el nombre: cColega.

Nota:
También puedes nombrarla Colega, la "c" es para indicar que se trata de una clase; no es una norma obligatoria, pero... es ampliamente usada por muchos programadores de Visual Basic, (entre ellos yo); otros usan el prefijo de la "c" sólo para el nombre del fichero, así que queda a tu criterio usarla en el nombre de la clase o no.

Esta clase tendrá varias propiedades, una para cada uno de los datos que manipulará, el Nombre, el e-mail y la fecha de nacimiento, además de un método que nos indicará que edad tiene dicho colega.
Veamos cómo añadir propiedades y métodos a una clase:

Añadir propiedades a una clase (u objeto):

Para crear las propiedades, podemos hacerlo de dos formas:

1. La forma más simple, es declarando las propiedades como variables públicas: Cuando declaramos una variable Public en un módulo de clase, dicha variable se convierte en una propiedad.
2. La otra forma es creando un procedimiento Property.

La ventaja de usar los procedimientos Property, es que podemos hacer comprobaciones extras que con las variables sería imposible hacer.
Por ejemplo, al asignar un valor a la propiedad e-mail, se podría comprobar que dicho valor contenga el signo arroba (@); en el caso la fecha de nacimiento, se podría validar que fuese una fecha correcta y en cualquiera de estos casos poder producir un error e incluso un evento para avisar de que algo no se ha hecho bien.
Al asignar un valor a una variable, dicho valor se asigna sin más, no se comprueba nada de nada, simplemente se asigna, sin embargo al usar un procedimiento para hacer dicha asignación podemos hacer las comprobaciones necesarias para asegurarnos que lo que se está asignando es lo correcto.

Cuando usamos procedimientos Property para almacenar valores de propiedades, nos vemos obligados a usar una variable que mantenga el valor asignado a dicha propiedad, esa variable se suele ocultar del mundo exterior declarándola Private, de esta forma esa variable sólo es visible dentro del código del módulo de clase. ¿Recuerdas lo que te dije del ámbito o visibilidad de las variables?

Veamos el código que se podría usar para implementar las propiedades de la clase cColega:

Para el nombre del colega, simplemente declaramos una variable pública:
Public Nombre As String

Para el e-mail crearemos una variable privada para guardar internamente la dirección de e-mail:
(como no podemos usar el signo - en el nombre de una variable, tendremos que usar email, sin signo de separación)
Private m_email As String
m_ es para indicar que es una variable declarada a nivel de módulo y por tanto visible en todo el módulo en el que se ha declarado.
Ahora tenemos que crear el procedimiento Property. Éste podemos crearlo de dos formas, usando la opción Añadir procedimiento... del menú de Herramientas o escribiendo el código directamente... vamos a usar el primer método:
Selecciona Añadir Procedimiento del menú Herramientas, te mostrará un cuadro de diálogo preguntando que tipo de procedimiento quieres crear y con que nombre. Selecciona la opción Property (Propiedad), en Ámbito (Scope) selecciona Public y escribe email en la caja de texto.
Se crearán dos nuevos procedimientos:

Public Property Get email() As Variant

End Property

Public Property Let email(ByVal vNewValue As Variant)

End Property

Cada uno de estos dos procedimientos son: Property Get para devolver el valor de la propiedad y Property Let para asignar un nuevo valor a la propiedad.

Nota:
Por defecto el tipo de datos asignado a un procedimiento Property es del tipo Variant, por tanto habrá que modificarlo para que sea del tipo que vamos a usar.

En el procedimiento que se usa para devolver el contenido actual de la propiedad, simplemente devolvemos el contenido de la variable privada:

Public Property Get email() As String
    ' Devolver el contenido de esta propiedad,
    ' el cual está almacenado en la variable privada
    email = m_email
End Property

En el procedimiento que se usa para asignar un nuevo valor a la propiedad, es donde tenemos que hacer la comprobación de que se asigna un valor que representa una dirección de correo electrónico, (realmente sólo se comprueba que tenga el signo @)

Public Property Let email(ByVal NewValue As String)
    ' Comprobar que el nuevo valor a asignar tenga el signo @
    If InStr(NewValue, "@") = 0 Then
        ' Asignamos los datos del error, pero no lo producimos
        With Err
            .Number = 13
            .Description = "El valor asignado a email no es una dirección _
	de correo electrónico."
            .Source = "cColega.email = " & NewValue
            ' Para producir el error, usariamos
            '.Raise 13
        End With
    Else
        ' Asignamos el nuevo valor a la variable privada
        m_email = NewValue
    End If
End Property

Public Property Let FechaNacimiento(ByVal NewValue As String)
    ' Si no es una fecha correcta...
    If IsDate(NewValue) = False Then
        ' Asignar un error
        With Err
            .Number = 13
            .Description = "El valor asignado a FechaNacimiento no es _
		una fecha válida."
            .Source = "cColega.FechaNacimiento = " & NewValue
        End With
    Else
        m_FechaNacimiento = NewValue
    End If
End Property

Public Property Let FechaNacimiento(ByVal NewValue As String)
    Dim i As Long
    Dim s As String
    '
    ' Comprobar si se usan puntos como separador
    ' si es así, cambiarlos por /
    Do
        i = InStr(NewValue, ".")
        If i Then
            Mid$(NewValue, i, 1) = "/"
        End If
    Loop While i
    '
    ' Comprobar si se usan - como separador
    ' si es así, cambiarlos por /
    Do
        i = InStr(NewValue, "-")
        If i Then
            Mid$(NewValue, i, 1) = "/"
        End If
    Loop While i
    '
    s = ""
    Do
        i = InStr(NewValue, "/")
        If i Then
            s = s & Right$("0" & Left$(NewValue, i - 1), 2) & "/"
            NewValue = Mid$(NewValue, i + 1)
        End If
    Loop While i
    NewValue = s & NewValue
    '
    If InStr(NewValue, "/") Then
        If Len(NewValue) = 5 Then
            ' Si es igual a 5 caracteres, es que falta el año
            NewValue = NewValue & "/"
        ElseIf Len(NewValue) < 3 Then
            ' Si es menor de 3 caracteres es que falta el mes
            NewValue = NewValue & "/" & CStr(Month(Now)) & "/"
        End If
    ElseIf Len(NewValue) < 3 Then
        NewValue = NewValue & "/" & CStr(Month(Now)) & "/"
    Else
        s = ""
        For i = 1 To 2
            s = s & "/" & Mid$(NewValue, (i - 1) * 2 + 1, 2)
        Next
        s = s & "/" & Mid$(NewValue, 5)
        NewValue = s
    End If
    NewValue = Trim$(NewValue)
    '
    ' Comprobar si tiene una barra al principio, si es así, quitarla
    If Left$(NewValue, 1) = "/" Then
        NewValue = Mid$(NewValue, 2)
    End If
    ' Si tiene una barra al final, es que falta el año
    If Right$(NewValue, 1) = "/" Then
        NewValue = NewValue & CStr(Year(Now))
    End If
    '
    ' Convertir la fecha, por si no se especifican todos los caracteres
    ' Nota: Aquí puedes usar el formato que más te apetezca
    NewValue = Format$(NewValue, "dd/mm/yyyy")
    '
    ' Si no es una fecha correcta...
    If IsDate(NewValue) = False Then
        ' Asignar un error
        With Err
            .Number = 13
            .Description = "El valor asignado a FechaNacimiento no es _
		una fecha válida."
            .Source = "cColega.FechaNacimiento = " & NewValue
        End With
    Else
        m_FechaNacimiento = NewValue
    End If
End Property

Private Sub cmdAsignar_Click()
    ' Dimensionamos una variable del tipo del objeto (clase)
    Dim oColega As cColega
    ' Creamos un nuevo objeto y lo asignamos a la variable
    Set oColega = New cColega
    '
    ' Detectamos los errores que se produzcan
    On Error Resume Next
    '
    ' Asignamos a la propiedad Nombre el contenido de Text1(0)
    oColega.Nombre = Text1(0).Text
    ' Asignamos a la propiedad email el contenido de Text1(1)
    oColega.email = Text1(1).Text
    ' Si se produce un error
    If Err Then
        ' Mostrar el mensaje de aviso
        MsgBox "Se ha producido un error en: " & Err.Source & _
	vbCrLf & Err.Description
        ' Posicionar el cursor en la caja de textos del email
        Text1(1).SetFocus
        ' Limpiamos el error
        Err = 0
        ' Salimos de este procedimiento
        Exit Sub
    End If
    '
    ' Asignamos la fecha de nacimiento
    oColega.FechaNacimiento = Text1(2).Text
    If Err Then
        ' Mostrar el mensaje de aviso
        MsgBox Err.Number & ", se ha producido un error en: " & Err.Source & _
	vbCrLf & Err.Description
        ' Posicionar el cursor en la caja de textos del email
        Text1(2).SetFocus
        ' Limpiamos el error
        Err = 0
        ' Salimos de este procedimiento
        Exit Sub
    End If
    ' ... resto del código
    List1.AddItem oColega.Nombre & " - " & oColega.FechaNacimiento
End Sub

'---------------------------------------------------------------------------
' Segundo formulario para "probar" que no todo es lo que parece     
'
' ©Guillermo 'guille' Som, 2003
'---------------------------------------------------------------------------
Option Explicit

' Valor interno para la propiedad del Form2
Private m_FechaCreacion As Date

Private Sub Form_Load()
    ' Asignar el valor de la fecha de creación
    ' (aunque realmente es la fecha en que se carga el formulario)
    m_FechaCreacion = Now
    '
    Label1 = "Form creado el: " & m_FechaCreacion
End Sub

Public Property Get FechaCreacion() As Date
    ' Propiedad de sólo lectura (no existe el procedimiento Property Let)
    FechaCreacion = m_FechaCreacion
End Property

'---------------------------------------------------------------------------
' Formulario para "probar" que no todo es lo que parece             
'
' ©Guillermo 'guille' Som, 2003
'---------------------------------------------------------------------------
Option Explicit

Private Sub Command1_Click()
    ' Mostramos el Form2
    Form2.Show
    ' Mostrar la fecha de creación
    Label1 = Form2.FechaCreacion
End Sub

Private Sub Command2_Click()
    ' Descargar el formulario
    Unload Form2
    ' Si no se asigna Nothing al Form2,
    ' la fecha mostrada será la misma que antes... es decir, aún existe el objeto
    'Set Form2 = Nothing
    '
    ' Una vez descargado, accedemos a la propiedad de la fecha de creación:
    Label2 = "El Form2 se creó el: " & Form2.FechaCreacion
End Sub

Private Sub Form_Initialize()
    m_FechaCreacion = Now
End Sub

'---------------------------------------------------------------------------
' Formulario para "probar" que no todo es lo que parece            
'
' ©Guillermo 'guille' Som, 2003
'---------------------------------------------------------------------------
Option Explicit
'
' Variable del tipo Form2
Private elForm2 As Form2

Private Sub Form_Load()
    ' Creamos el objeto
    Set elForm2 = New Form2
End Sub

Private Sub Command1_Click()
    ' Mostramos el Form2
    elForm2.Show
    ' Mostrar la fecha de creación
    Label1 = elForm2.FechaCreacion
End Sub

Private Sub Command2_Click()
    ' Descargar el formulario
    Unload elForm2
    ' Destruimos el objeto (lo eliminamos de la memoria)
    Set elForm2 = Nothing
    '
    ' Si una vez descargado, accedemos a la propiedad de la fecha de creación:
    ' ESTO PRODUCIRA UN ERROR, YA QUE ¡LA VARIABLE elForm2 NO EXISTE!
    Label2 = "El Form2 se creó el: " & elForm2.FechaCreacion
End Sub