PDF de programación - Curso de VB - Capítulo 18

CURSO DE VB

CAPÍTULO 181

Índice de contenido
TIPOS, COLECCIONES Y CLASES..................................................................................................2
INTRODUCCIÓN...........................................................................................................................2
TIPOS..............................................................................................................................................2
COLECCIONES..............................................................................................................................6
DEFINIR UNA COLECCIÓN....................................................................................................6
AÑADIR ELEMENTOS A UNA COLECCIÓN........................................................................7
CONTAR ELEMENTOS DE UNA COLECCIÓN....................................................................7
ELIMINAR ELEMENTOS DE UNA COLECCIÓN.................................................................7
RECORRER LOS ELEMENTOS DE UNA COLECCIÓN.......................................................8
UN EJEMPLO CON TODO LO ANTERIOR............................................................................8
CLASES...........................................................................................................................................9
TRABAJANDO CON LAS CLASES...........................................................................................11
EXPORTANDO EL MÓDULO DE CLASE............................................................................12
SEGUIMOS CON EL TRABAJO CON CLASES...................................................................13
UTILIZANDO LAS PROPIEDADES: PROCEDIMIENTO PROPERTY..............................16
PROPERTY LET..................................................................................................................16
PROPERTY GET.................................................................................................................16
PROPERTY SET..................................................................................................................17
APLIQUEMOS EL PROCEDIMIENTO PROPERTY........................................................17
UNAS BREVES EXPLICACIONES TEÓRICAS BASADAS EN TODO LO ANTERIOR. 21
UN EJEMPLO INTEGRÁNDOLO CON ACCESS.....................................................................23
PARA FINALIZAR ESTE CAPÍTULO........................................................................................31

1

La BD donde están los ejemplos de este capítulo os la podéis bajar aquí.

Visítame en http://siliconproject.com.ar/neckkito/

1

TIPOS, COLECCIONES Y CLASES

INTRODUCCIÓN

El objetivo de este capítulo es llegar a comprender las
clases. Sin embargo, para ello es necesario asimilar dos
conceptos clave: los tipos y las colecciones. Si bien no son
lo mismo (lógicamente) las ideas que subyacen en cada uno
de ellos nos allanarán el camino para llegar a las clases.

Es por esto por lo que empezaremos desarrollando los que son los tipos, cómo se definen, etc.,
y haremos lo mismo con las colecciones (que, además, ya nos debería “sonar de algo” si
hemos seguido todo este curso hasta aquí).

Como utilizaremos los conceptos explicados cuando hablábamos de matrices, si notáis que
tenéis un momento de “debilidad memorística”, quizá sería interesante que tuvierais a mano el
capítulo 9, donde se habla de ellas. 

Os advierto que este capítulo quizá pueda resultaros algo complejo, sobre todo en la parte
final del mismo y en especial en el apartado “Un ejemplo integrándolo con Access”,
básicamente porque se mezclan no sólo cosas de este capítulo sino elementos que hemos ido
explicando (y aprendiendo, supongo ) durante este curso. Pensad que la finalidad es
podernos construir nuestro propio módulo de clase (todo un “lujazo” para nuestra aplicación).

Empecemos pues.

TIPOS
Nuestro buen amigo Access nos dice, refiriéndose a la instrucción Type, lo siguiente: <<Se usa
en el nivel de módulo para definir un tipo de datos definido por el usuario que contiene uno o
más elementos>>.

Vayamos por partes:

•
•

•

•

“Se usa a nivel de módulo”. Pues vaya, ya tenemos una primera pista.
“Tipo de datos”. Sabemos que hay datos numéricos, booleanos, de texto... ¿Qué tipo de
datos será?
“Definido por el usuario”. Ergo no es un tipo de datos llamémosle “estándar”, sino que
es el usuario el que se lo “saca de la manga”.
“Contiene uno o más elementos”. Eso me suena a matrices, ¿verdad?

Sigamos. La estructura para definir un tipo es la siguiente:

PUBLIC/PRIVATE TYPE nombreTipo

nombreElemento1 AS tipoDato
…
nombreElementoN AS tipoDato

END TYPE

OK. Ya tenemos la estructura para definir un tipo. ¿Y los elementos?

Visítame en http://siliconproject.com.ar/neckkito/

2

Pues los elementos deben ser definidos dentro de un procedimiento.

Lo anterior nos lleva a tener que remarcar dos puntos:

•

•

La declaración del tipo NO va dentro de un procedimiento,
sino que debemos situarlo en la cabecera del módulo.
La declaración de los elementos SÍ va dentro de un
procedimiento.

Vamos a realizar un pequeño ejercicio muy simple para
empezar a entender lo anterior. Después complicaremos un
poco el asunto.

En una BD en blanco vamos a insertar un módulo estándar, que llamaremos mdlDefinoTipos.
Vamos a crearnos un tipo personalizado, que llamaremos CodigoColor. La idea es que nuestra
empresa tiene, como mecanismo de seguridad, un código de colores: a cada color le
corresponde un grado de peligrosidad.

Como hemos comentado antes, la definición de los tipos debe ir en la cabecera del módulo
(debajo de Option Compare Database / Option Explicit). Así, los elementos que componen
nuestro tipo serán dos:

1.- Nombre del color
2.- Significado de peligro

Deberíamos pues definirlo así:

…
Public Type CodigoColor
nombre As String * 10
significado As String * 25
End Type
…

Como veis, las variables que indican la definición de los elementos son, en este caso, de tipo
texto String. Además, hemos indicado su longitud máxima (a través de “* 10” y “* 25”).

Segunda fase: rellenar los elementos.

Como es el primer ejemplo “fácil” sólo vamos a rellenar los datos de un color. Como
comentaba antes, una vez entendido lo que hace nuestro código pondremos un ejemplo más
complejo.

Para rellenar los elementos del tipo vamos a utilizar un procedimiento público, que llamaremos
rellenaCodigos. Lo escribiríamos así, inmediatamente debajo de nuestra definición de tipo
personalizado CodigoColor:

…
Public Sub rellenaCodigos()
'Declaramos una variable, diciéndole que es de nuestro tipo personalizado
Dim vColor As CodigoColor
'Rellenamos los valores
vColor.nombre = "Verde"
vColor.significado = "Sin peligro"

Visítame en http://siliconproject.com.ar/neckkito/

3

'Mostramos los resultados
MsgBox vColor.nombre & vColor.significado, vbInformation, "DATOS"
End Sub
…

Fijaos en que:

Debo declarar la variable como mi tipo personalizado
Debo indicar a qué elemento me refiero, y rellenarlo,
utilizando la estructura: <variable.elemento = valor>

Si nos situamos en nuestro procedimiento y pulsamos F5
veremos qué nos muestra el MsgBox.

Compliquemos un poco más la cosa. Supongamos que tenemos un listado de países con sus
monedas. El listado que utilizaremos será el siguiente:

1 -
2 -
3 -

USA

España
Japón

- Dólar
- Euro
- Yen

Nos crearemos, en nuestro módulo, un nuevo tipo, al que llamaremos Monedas, de la manera
siguiente:

…
Public Type tipoMoneda
nombre As String * 10
Moneda As String * 10
End Type
…

Y nos crearemos un procedimiento llamado usaMoneda, así:

…
Public Sub usaMoneda(ByVal indice As Integer)
'Declaramos una variable como nuestro tipo, pero en forma de matriz
Dim paisMoneda(1 To 3) As tipoMoneda
'Rellenamos los datos
paisMoneda(1).nombre = "USA"
paisMoneda(2).nombre = "España"
paisMoneda(3).nombre = "Japón"
paisMoneda(1).moneda = "Dólar"
paisMoneda(2).moneda = "Euro"
paisMoneda(3).moneda = "Yen"
'Devolvemos un MsgBox con la información

paisMoneda(indice).moneda, _
vbInformation, "RESULTADO"
End Sub
…

MsgBox "El país " & paisMoneda(indice).nombre & " usa la moneda " &

Finalmente, nos creamos un formulario en blanco y, en un botón de comando, escribimos el
siguiente código2:

…

2

El tema de control de errores os lo dejo para vosotros 

Visítame en http://siliconproject.com.ar/neckkito/

4

Private Sub cmdProcedimientousaMoneda_Click()
'Declaramos las variables
Dim vCod As Variant

'Solicitamos al usuario un código de país
vCod = InputBox("Introduzca código del país (número
del 1 al 3)", "CÓDIGO PAÍS", "1")
'Llamamos al procedimiento usaMoneda()
Call usaMoneda(vCod)
End Sub
…

Pensad que la “gracia” del ejemplo está en entender la
mecánica de cómo funciona la definición de tipos
personalizados.

También pensad que podemos “reutilizar” nuestra definición de tipo para otras acciones (si lo
planificamos bien nos puede salir una definición de tipos bastante “universal”).

Por ejemplo, si creamos otro procedimiento para saber en qué moneda debemos pagar a un
cliente, sabiendo su código de cliente, sólo deberíamos escribir un procedimiento específico
para ello, sin tener que volver a definir otro tipo.

Es decir, en nuestro módulo podemos escribir lo siguiente:

…
Public Sub clienteMoneda(ByVal Indice As Integer)
Dim cliMon(1 To 3) As tipoMoneda
cliMon(1).nombre = "Meals Co"
cliMon(2).nombre = "Verduras SA"
cliMon(3).nombre = "Arigato"
cliMon(1).moneda = "Dólar"