Unidad introduccion a la poo

Electiva II. Gambas
Prof. Leany Gonzalez
Unidad No. IV
Introducción a la Programación Orientada a Objetos en
Gambas
La orientación a objetos es un paradigma de programación (POO) que facilita la creación de
programas de calidad por sus factores que potencian el mantenimiento, la extensión y la
reutilización del software generado bajo este paradigma.
La programación orientada a objetos trata de amoldarse al modo de pensar del hombre y
no al de la máquina.
Conceptos de Programación Orientada a Objetos
Empecemos con un ejemplo: Suponga que estas en un estacionamiento caminando hacia
tu auto, entonces tomas el control remoto y oprimes un botón, en ese momento se desactiva
la alarma de tu automóvil.
El control remoto es un objeto físico que tiene propiedades: peso, tamaño y también puede
hacer cosas:
• Puede enviar mensajes al automóvil. No está claro como hace esto, pero no
necesitas saberlo para poder usarlo; solo necesitas saber qué botón oprimir para que
esto ocurra
Los botones son la interfase del control remoto. Si conoces la interfase de un objeto, lo
puedes usar para realizar acciones sin entender cómo trabaja.
El automóvil también es un objeto físico, tiene propiedades y realiza acciones (métodos),
una de ellas es recibir un mensaje de un control remoto para desactivar la alarma.
Gracias a la abstracción eres capaz de hacer que dos objetos interactúen entre sí, sin
necesidad de entender cómo funcionan. Esto también permite que uses otros controles
remotos y otros automóviles de otras marcas y otros modelos.
La clave para desarrollar un sistema utilizando los conceptos de Orientación a Objetos es :
1. definir qué objetos forman parte del sistema
2. crear abstracciones apropiadas para ellos
3. y separar la implementación interna de su comportamiento externo.
1

Electiva II. Gambas
Desde el punto de vista de la programación orientada a objetos, la abstracción consiste en
ocultar los detalles irrelevantes para que el objeto pueda ser comprendido y utilizado por el
usuario. Por un lado, esto disminuye la complejidad permitiendo que el usuario utilice los
datos del objeto sin necesidad de conocer detalles, y por otro lado protege los datos
evitando que el usuario pueda llegar a ellos y modificarlos sin utilizar las funciones
diseñadas para ello, afectando con esto la confiabilidad del sistema.
Pero, ¿Que es un Objeto?
Un objeto puede ser alguna cosa física, como una pluma, un escritorio, un gato; pero
también hay cosas abstractas que son objetos, como un número o una cuenta bancaria.
Sabemos que algo es un objeto si tiene nombre, se puede describir en base a sus
características o propiedades y es capaz de hacer algo o comportarse de cierta manera.
Por ejemplo:
Pensemos en una cuenta bancaria sencilla, podemos describirla como un objeto de la
siguiente manera:
• Clase: Cuenta Bancaria
• Propiedades: Nombre del dueño, saldo actual, tipo de cuenta.
• Comportamientos (métodos): depositar, retirar, consultar el saldo.
Los lenguajes orientados a objetos nos permiten crear abstracciones encapsulando las
propiedades y los comportamientos en un solo concepto llamado clase.
Las propiedades (también llamadas atributos o datos miembro) que pertenecen a una clase
se definen como variables. Y los comportamientos (también llamados métodos o funciones
miembro) se definen como funciones, y éstos tienen la característica de tener acceso a los
atributos privados de la clase
La diferencia entre clase y objeto es sutil pero muy importante. La clase es el concepto
abstracto, es una especie de molde para crear objetos, define qué atributos y métodos tiene
la clase. Por otro lado el objeto es la entidad concreta.
Por ejemplo: El tipo de datos "integer" es la clase que contiene todos los numeros enteros,
y el objeto seria una variable "edad" que es del tipo "integer"
Objetos o Instancias:
A partir de una clase, se pueden crear instancias, es decir objetos y cada objeto tiene
valores distintos para sus atributos.
Por ejemplo: Continuando con nuestro ejemplo de la clase cuenta bancaria.
La clase es Cuenta Bancaria.
Los objetos podrían ser
Objeto 1:
Cuenta 193
Nombre del dueño: Jorge López
Saldo actual: 5,248.00
2

Electiva II. Gambas
Tipo de cuenta: ahorros
Objeto 2:
Cuenta 281
Nombre del dueño: Laura Treviño
Saldo actual: 3,915.00
Tipo de cuenta: chequera
Un objeto puede recibir mensajes, los cuales son para pedirle que haga algo, o bien, que
cambie alguna de sus propiedades. Esto es equivalente a llamar a una función, solo que al
llamar al método se tiene que hacer referencia al objeto específico en el que se ejecutará
dicho método.
Por ejemplo: Se puede pedir a la cuenta bancaria 193 ejecutar el método depositar con el
valor 100, lo cual se reflejará con un cambio en el valor del atributo saldo actual, el nuevo
valor para dicho atributo será 5,348.00. Pero nota que el valor del atributo saldo actual de la
cuenta 281 permanece sin cambio.
Como Crear y/o Añadir Formularios, Módulos Y Clases
Vamos a explicar cómo se crean y/o añaden formularios, módulos y clases a un
programa gráfico.
Cuando creamos un programa gráfica, en el proyecto se nos va a crear un formulario
llamado FMain.
Para añadir al proyecto otro formulario, clase o módulo, tenemos que:
1) Ir a la parte izquierda del Ide, donde se nos muestra el árbol del proyecto.
2) Pulsar el botón derecho del ratón, aparece un menu.
3) Elegimos la opción de "Nuevo"
4) Aparece un submenu con "Directorio", "Módulo..", "Clase..", "Formulario..."
Nota:
La opción de crear Directorios, es muy interesante a la hora de organizar proyectos con gran
3

Electiva II. Gambas
número de formularios y clases. Esta opción también nos permite crear directorios dentro de
otros directorios, con lo cual el código fuente queda organizado. A la hora de codificar, para
hacer llamadas a formularios, clases o módulos que estén en directorios no hace falta
indicar el directorio.
5) Elegimos una opción "Formulario....","Módulo...", "Clase...", nos aparece una nueva
ventana, con dos pestañas "Nuevo" y "Existente". En la pestaña "Existente" podemos
elegir un formulario módulo ó clase que ya existente del disco.
Por ejemplo, nos interesa una clase que hemos creado en otro proyecto, y de este modo la
podemos incorporar a nuestro nuevo proyecto.
5.1) Si hemos elegido "Formulario..." o "Módulo....": en la pestaña "Nuevo", podemos poner
el nombre del nuevo formulario. Este nombre posteriormente lo podemos cambiar.
5.2) Si hemos elegido "Clase...", además de pedirnos el nombre, también nos dá la opción
de indicar si tiene clase padre (hereda de otra clase, este concepto lo veremos más tarde en
el curso) y si es exportado (esta opción la explicaremos más adelante) que la dejaremos sin
marcar.
4

Electiva II. Gambas
Nota: Más sobre Formulario
Cuando creamos un formulario, llamandole "XXXX", realmente se crean dos archivos:
1) Uno "XXXX.form" que es donde "visualmente" pondremos los controles (textbox,
valuebox, button, etc) y los contenedores (Hbox, Panel, Frame, etc).
2) Otro "XXXX.class" que contiene el código de gambas que va a ejecutar (subrutinas,
funciones, etc.)
Cuando se borre o renombre un formulario, estos dos archivos se borraran o renombrarán.
Clase
¿que es una clase?
En la programación orientada a objetos, una clase es una construcción que se utiliza como
un modelo (o plantilla) para crear objetos de ese tipo. El modelo describe el estado y
contiene el comportamiento que todos los objetos creados a partir de esa clase tendrán.
Un objeto creado a partir de una determinada clase se denomina una instancia de esa clase.
Una clase por lo general representa un sustantivo, como una persona, lugar o cosa. Es el
modelo de un concepto dentro de un programa de computadora.
Fundamentalmente, delimita los posibles estados y define el comportamiento del concepto
que representa. Encapsula el estado a través de espacios de almacenaje de datos
llamados atributos, y encapsula el comportamiento a través de secciones de código
reutilizables llamadas métodos.
5

Electiva II. Gambas
Ejemplo:
La clase "perro", tiene propiedades o atributos:
- color
- raza
- peso
y tiene métodos:
- ladrar
- comer
La clase "perro" la podemos representar como este dibujo genérico (modelo o plantilla):
Un objeto de la clase "perro" (instancia de la clase "perro") identifica a un perro en concreto.
El perro "pluto"
El perro "lassie"
6

Electiva II. Gambas
Añadiendo Propiedades
Para añadir a la propiedades a una clase, usamos la orden "Property"
PROPERTY [ READ ] Identifier [ , Synonymous1 [ , Synonymous2 ... ] ] AS Datatype
Nota:
Read: añadiendo esta palabra, hará que la propiedad sea de solo lectura.
Para manejar esta propiedad, se debe de crear una variable privada y dos procedimientos
privados que nos van a permitir la lectura (_read) y la asignación de valores (_write).
Veamos un ejemplo creando una propiedad llamada "Edad":
PROPERTY Edad AS integer 'Propiedad creada
PRIVATE $Edad AS integer 'variable privada
PRIVATE FUNCTION Edad_read() AS integer 'Devuelve el valor de Edad
RETURN $Edad
END
PRIVATE SUB Edad_write(Valor AS integer) ' Escribe el valor en la propiedad
$Edad = Valor
END
Nota:
Tener estos métodos (_write y _read) puede parecer equivalente a haber declarado el
atributo como público (Public); sin embargo hay una pequeña diferencia que es muy
importante:
• Si hacemos el atributo público cualquiera función o subrutina puede modificar su
valor sin verificar que el nuevo valor que se le asigne sea un valor apropiado;
• Por otro lado, un método para establecer el valor de la variable puede realizar la
validación del dato que va a asignar al atributo y si no es un dato válido puede
rechazarlo.
7

Electiva II. Gambas
Por ejemplo, podemos añadir una comprobación cuando se vaya a asignar un valor a la
propiedad Edad
Private Sub Edad_write(Valor As Integer)
'comprobamos si el "valor" es mayor que 0
If valor > 0 Then
'si el valor es mayor que 0, se le puede asignar
$Edad = Valor
Else
Message.Info("No se puede asignar un valor de edad inferior o igual que 0")
Endif
End
Añadiendo Métodos
Para definir métodos, se hace como si fueran funciones o subrutinas, y si usan el valor de
las propiedades, se deben de usar las "variables privadas" que definidas junto a las
propiedades.
Ejemplo:
Tenemos una clase "circulo", que tiene la propiedad "radio"
' Gambas class file
Property radio As Float
Private $radio As Float
Private Function radio_Read() As Float
Return $radio
End
Private Sub radio_Write(Value As Float)
$radio = Value
End
Creamos una función, que calcule y devuelve el área del circulo.
Public Function area() As Float
Dim superficie As Float
superficie = Pi * $radio ^ 2
Return superficie
End
8

Electiva II. Gambas
Método Constructor:
Hay un método "especial", que nos permite que cuando instanciamos una clase, se puedan
definir parámetros (uno o varios) y/o ejecutar líneas de código cuando se cree el objeto.
Para ello se usa el método "_new()"
Por ejemplo, si queremos que un objeto circulo cuando se cree, le podamos dar un radio,
debemos añadir este constructor en la clase :
Public Sub _new(Optional r As Float)
If r <> 0 Then
$radio = r
Print "Se ha creado un circulo, con radio "; $radio
else
Print "Se ha creado un circulo, falta definir radio "
endif
End
Clases y Objetos: Instanciar una clase
¿Cómo se crean objetos de una clase?
Dentro de un programa de Gambas una instancia u objeto de la clase se representa como
una variable, por lo que para crear una instancia declara una variable cuyo tipo de dato es el
nombre del objeto, se usa el siguiente formato:
Para definir el tipo de objeto:
• [Dim | Public | Private ] nombre as Nombre_Clase
y luego para crear el objeto:
• nombre=New Nombre_Clase
Vemos un ejemplo, usando la clase Circulo, del anterior post.
Public Sub Main()
Dim cir As ClassCirculo 'creamos la variable, que sea del tipo ClassCirculo
cir = New ClassCirculo 'Creamos el objeto
Print "Uso de clase Circulo"
Print "Introduce el radio:"
Input cir.radio
Print "El area es: "; cir.area()
9

Electiva II. Gambas
'vamos a crear un nuevo objeto circulo, con un radio predefinido:
cir = New ClassCirculo(8)
Print "Radio: "; cir.radio
Print "El area es: "; cir.area()
End
Nota:
Fijate que usamos el operador punto (.) para acceder tanto a las propiedades como a los
métodos del círculo.
Ejemplo:
La compañía Ibarra va a remodelar su nave industrial de tal manera que va a pintar toda
nave y necesita saber cuanto tiempo le llevaría pintar la nave. Define una clase Rectángulo
que tenga las siguientes especificaciones:
Atributos:
· largo
· ancho
Métodos:
· calcula Area
Y utiliza esta clase para resolver el siguiente problema: Hay una pared rectangular que tiene
una ventana rectangular; se requiere un programa que dadas las dimensiones (largo y
ancho) de la ventana y de la pared muestre en la pantalla el tiempo necesario para pintar la
pared si se sabe que se puede pintar 1.5 m2 en 10 minutos.
1º Definimos la clase, con sus propiedades (largo y ancho) y su método (area):
' Gambas class file
Property largo As Float
Private $largo As Float
Private Function largo_read() As Float
Return $largo
End
Private Sub largo_write(Valor As Float)
$largo = Valor
End
Property ancho As Float
Private $ancho As Float
Private Function ancho_read() As Float
Return $ancho
End
Private Sub ancho_write(Valor As Float)
10

Electiva II. Gambas
$ancho = Valor
End
Public Sub area() As Float
Return $largo * $ancho
End
Ahora el programa principal, para resolver el problema...
' Gambas module file
Public Sub Main()
Dim p As Rectangulo 'pared
Dim v As Rectangulo 'ventana
Dim areapintada As Float 'nos servira para almacenar la superfice real de pintado
p = New Rectangulo
v = New Rectangulo
Print "Ejemplo de Clase: Pintado de nave"
'pedimos los datos de la pared y de la ventana
Print "Introduce datos de la nave"
Print "Datos de la pared:"
Print "Largo:"
Input p.largo
Print "Ancho:"
Input p.ancho
Print "Datos de la ventana:"
Print "Largo:"
Input v.largo
Print "Ancho:"
Input v.ancho
'calcula el area de la ventana y de la pared
'la superficie realmente pintada es la diferencia del area de la pared y la ventana
areapintada = p.area() - v.area()
Print "Calculo el tiempo a emplear, sabiendo que 1.5 m2 los hago en 10 minutos..."
'aplico una regla de 3...
Print "Area real a pintar: "; areapintada
Print "Se tardará en pintar la pared: "; areapintada * 10 / 1.5; " minutos"
End
11

Electiva II. Gambas
Salida del programa en la terminal:
Ejemplo de Clase: Pintado de nave
Introduce datos de la nave
Datos de la pared:
Largo:
10
Ancho:
2
Datos de la ventana:
Largo:
1
Ancho:
5
Calculo el tiempo a emplear, sabiendo que 1.5 m2 los hago en 10 minutos...
Area real a pintar: 15
Se tardará en pintar la pared: 100 minutos
Más Sobre Constructores y Hacer una Copia de un Objeto
Más Sobre Constructores
En el post anterior hablamos sobre el método especial "_new", que nos ayuda a dar valores
a los parámetros o realizar instrucciones justo cuando instanciamos un objeto.
Los métodos también admiten (al igual que las funciones y las subrutinas), parámetros
opcionales (optional). Además tenemos funciones en gambas que permiten conocer que
tipo de parámetro es el que se le está pasando al instanciar la clase.
Con esta dos herramientas, podemos programar que un mismo método _new, pueda crear
objetos usando diversos tipos y números de parámetros.
Por ejemplo: Tenemos la clase ClassCirculo, con la cual se crean Círculos.
Podemos definir los círculos de diversas maneras:
• Forma 1: x, y, radio, nos dan la X e Y y radio (integer)
• Forma 2: x, y, radio, nos dan la X e Y y radio (pero son Float)
• Forma 3: classe Coordenada, radio (circulo dado el centro por la clase coordenada y
su radio)
• Forma 4: clase coordenda1,coordenado2,coordenada3 (circulo que pase por 3
puntos)
12

Electiva II. Gambas
¿cómo se programa?
Lo que tenemos que hacer es usar varias ordenes If... then,,, para que según sea el tipo de
parámetro pasar crearlo.
Para saber el tipo de parámetro, usamos:
• La orden TypeOf(parametro1), nos devuelve un número que se identifica con el tipo
de variable (ver http://www.gambasdoc.org/help/lang/typeof?v3 )
• Si sabemos que es un objeto Object.Type(parametro1), que nos dá el nombre de la
clase.
¿Como se defineria la clase ClassCirculo?
-->
Public Sub _new(Optional parametro1 As Variant, Optional parametro2 As Variant, Optional
parametro3 As Variant)
' Forma: x, y, radio : nos dan la X e Y y radio (integer)
If TypeOf(parametro1) = gb.Integer And TypeOf(parametro2) = gb.Integer And
TypeOf(parametro3) = gb.integer Then
Print "Me pasan 3 numeros integer, en la forma X, Y, Radio"
'realizo copia de propiedades...
'...
hx = parametro1
hy = parametro2
hradio = parametro3
estado = "iniciado"
Return
Else
' Forma: x, y, radio : nos dan la X e Y y radio (pero son Float)
If TypeOf(parametro1) = gb.float And TypeOf(parametro2) = gb.float And
TypeOf(parametro3) = gb.float Then
Print "Me pasan 3 numeros float, en la forma X, Y, Radio"
'crearia el circulo
'...
hx = parametro1
hy = parametro2
hradio = parametro3
Return
Else
' forma: classe Coordenada, radio (circulo dado el centro por la clase coordenada y su radio)
If Object.Type(parametro1) = "ClassCoordenada" And TypeOf(parametro2) = gb.float Then
Print "Me pasan una clase ClassCoordenada, y el Radio (float)"
'crearia el circulo con los datos pasado
13

Electiva II. Gambas
'....
'
Return
Else
' Forma: clase coordenda1,coordenado2,coordenada3 (circulo que pase por 3 puntos)
If Object.Type(parametro1) = "ClassCoordenada" And Object.Type(parametro2) =
"ClassCoordenada" And Object.Type(parametro3) = "ClassCoordenada" Then
Print "Me pasan 3 clases ClassCoordenada"
'se crearia el circulo teniendo en cuenta 3 coordenadas.
'....
'
Return
Endif
Endif
Endif
Endif
¿como usar la clase?
-->
Print "================================================================"
Print "= Constructores ="
Print "================================================================"
' Forma: x, y, radio : nos dan la X e Y y radio (integer)
Print "Constructor caso:"
c1 = New ClassCirculo(2, 3, 4)
' Forma: x, y, radio : nos dan la X e Y y radio ( Float)
c2 = New ClassCirculo(2.3, 24.2, 34.2)
' forma: classe Coordenada, radio (circulo dado el centro por la clase coordenada y su radio
(float))
c3 = New ClassCirculo(coord1, 34.3)
' Forma: clase coordenda1,coordenado2,coordenada3 (circulo que pase por 3 puntos)
c4 = New ClassCirculo(coord1, coord2, coord3)
Hacer una Copia de un Objeto:
Para copiar variables en Gambas, usamos el operador igual "=".
Por ejemplo
dim Nombre as string
14

Electiva II. Gambas
dim NombreCopia as string
Nombre=”Julio”
NombreCopia=nombre
print Nombre, NombreCopia
Sin embargo, con objetos no podemos hacer lo mismo, ya que el operador igual ("=") lo que
hace es copiar la referencia del objeto (no hace copia). Cualquier cambio que haríamos
en el objecto copiado modificaria al objeto original.
Print "Coordenadas Mal copiadas por referencia!!!: "
Print coord1.escribe()
coord2.y = 234343455
Print "Coordenadas: "
Obtenemos en pantalla...
Coordenadas Mal copiadas por referencia!!!:
X: 23 Y: 34
X: 23 Y: 34
Coordenadas:
X: 23 Y: 234343455
X: 23 Y: 234343455
Como ves, al alterar la clase copiada (coord2), se modifica tambien la clase origen (coord1)
Para copiar objetos, tenemos que hacerlo mediante lineas de código, que se encarguen de
copiar y asignar las propiedades (sus valores) del objeto Origen a las otras propiedades del
objeto_copia. Por ejemplo, con este método dentro de la clase ClassCoordenada
-->
Public Function copia(origen As ClassCoordenada) As ClassCoordenada
Me.x = origen.x
Me.y = origen.y
End
'Esta es la opción más correcta vease comentarios...
Public Sub copia(origen As ClassCoordenada)
Me.x = origen.x
Me.y = origen.y
End
15

Electiva II. Gambas
Para usarlo:
coord1 = New ClassCoordenada
coord2 = New ClassCoordenada
coord1.x = 23
coord1.y = 34
coord2.copia(coord1)
Print "Coordenadas: Copia mediante metodo "
coord2.y = 3433445
Print "Coordenadas Cambio: "
Y es resultado...
Coordenadas: Copia mediante metodo
X: 23 Y: 34
X: 23 Y: 34
Coordenadas Cambio:
X: 23 Y: 34
X: 23 Y: 3433445
Como se observa, ahora si, se copia bien, ya que al modificar la clase copiada, la de origen
no se modifica.
Para terminar, también podemos usar el método constructor para que crear una copia de un
objeto:
Public Sub _new(Optional parametro1 As Variant, Optional parametro2 As Variant, Optional
parametro3 As Variant)
Dim clase As String
If TypeOf(parametro1) = gb.Object And If Object.Type(parametro1) = "ClassCirculo" Then
hy = parametro1.y
hx = parametro1.x
hradio = parametro1.radio
estado = parametro1.leerEstado()
Return
Endif
…..
16

Electiva II. Gambas
…..
Y usarlo así:
Print "Proceso de copia de circulo.."
copia = New ClassCirculo(c1)
Función que lo hace:
Public Sub CopyObject(hObjeto As Object) As Object
Dim hNewMe As Object = Object.New(Object.Type(hObjeto)) 'se genera un objeto de la
mismo tipo que nos pasan
Dim s As String 'variable utilizada para almacenar el valor de hclass.symbols
Dim hclass As Class = Object.Class(hObjeto) 'contiene el valor de la clase del objeto
Dim hChild As Object
Dim nuevoObjeto As Object
Dim caso As Integer 'tipo de dato de la propiedad del objeto
Dim contador, a As Integer 'para usarlo en bucle si son arrays
Dim arrayPosible As Object
'Inicio de la copia de las propiedades....
For Each s In hclass.Symbols
If s = "Chlidren" Then Continue
If Not hclass[s].ReadOnly Then
caso = TypeOf(Object.GetProperty(hObjeto, s))
Select Case caso
Case gb.Object
'la propiedad es un objeto, vuelvo a llamar a la funcion para que me extraiga los valores y no
las referencias
nuevoObjeto = CopyObject(Object.GetProperty(hObjeto, s))
Object.SetProperty(hNewMe, s, nuevoObjeto)
Try contador = Object.GetProperty(hObjeto, s).count
If Error Then
'no es un array
Else
For a = 0 To contador - 1
nuevoObjeto.add(Object.GetProperty(hObjeto, s)[a])
Next
Endif
Default
'la propiedad no es un objeto, copio el valor
Object.SetProperty(hNewMe, s, Object.GetProperty(hObjeto, s))
End Select
Endif
Next
'devuelvo la copia del objeto
17

Electiva II. Gambas
Return hNewMe
End
Y un ejemplo:
http://jsbsan.blogspot.com.es/2013/08/poo-en-gambas3-copiar-objetos.html
Nota 2:
Esta función copia tanto las propiedades como los métodos que tenga el objeto.
No copia variables publicas definidas dentro del objeto (ni por supuesto las privadas)
Más sobre constructores: Numero de parámetros no definidos ("...")
En la anteriores entradas se hablaba de constructores con parámetros opcionales, usando la
palabra clave "optional". Pero hay una forma en la que podemos indicar un número de
parámetros arbitrarios en la definición para que cuando lo usamos podamos poner los
parámetros que necesitemos.
Necesitaremos definir el código del método _new para que sepa qué hacer con esos
parámetros.
Ejemplo:
Tenemos un circulo, que lo podemos definir de dos formas:
- Dando el radio y la coordenada del centro
- Dando 3 pares de coordenadas, por donde debe de pasar el circulo:
Así se definiría la clase Circulo:
' Gambas class file
Public Sub _new(...)
Select Case Param.Count
Case 2
Print "-----------------------------------------------------------"
Print "Circulo definido por el radio y la coordenada del centro"
Print "Ciculo radio: ", Param[0]
Print "Coordenada Centro: ("; Param[1][0]; " , "; Param[1][1]; ")"
'el primer dato es el radio
'el segundo dato es una cordenada
'a continuación el algoritmo del cálculo del círculo dado el centro y su radio.
Case 3
Print "-----------------------------------------------------------"
Print "Circulo definido por 3 pares de coordenadas, (3 puntos por donde debe de pasar
el circulo)"
'se dan 3 puntos por los cuales debe de pasar el circulo
18

Electiva II. Gambas
Print "Coordenada Punto 1: ("; Param[0][0]; " , "; Param[0][1]; ")"
'a continuación el algoritmo del cálculo del circulo que pase los 3 puntos
End Select
End
Así lo usaríamos en la clase principal:
PUBLIC SUB main()
Dim circuloTmp As Circulo
circuloTmp = New Circulo(100, [2, 3])
circuloTmp = New Circulo([1.2, 5], [2, 3], [9, 2])
END
En la consola obtendríamos
-----------------------------------------------------------
Circulo definido por el radio y la coordenada del centro
Circulo radio: 100
Coordenada Centro: (2 , 3)
-----------------------------------------------------------
Circulo definido por 3 pares de coordenadas, (3 puntos por donde debe de pasar el circulo)
Coordenada Punto 1: (1,2 , 5)
Coordenada Punto 2: (2 , 3)
Coordenada Punto 3: (9 , 2)
Nota:
Esto de los parámetros indefinidos, es aplicable a cualquier método o función. Otro ejemplo
usando también en otras funciones
Public Sub Form_Open()
Dim TextBox1 As New TextBox(Me)
Dim circuloTmp As Circulo
pruebas("hola", "adios", 20, "pepito", textbox1)
pruebas(4.14, 55, "gambas")
End
Public Sub pruebas(...)
Dim v As Variant
Print "---------------------------------------------------"
Print "Numero de parametros introducidos:", Param.Count
For Each v In Param
Print "valores: ", v
Next
19

Electiva II. Gambas
End
Salida por consola:
---------------------------------------------------
Numero de parametros introducidos: 5
valores: hola
valores: adios
valores: 20
valores: pepito
valores: (TextBox 0x9ff7c5c)
---------------------------------------------------
Numero de parametros introducidos: 3
valores: 4,14
valores: 55
valores: gambas
Metodos Especiales: _new, _compare,...
Los métodos especiales se declaran en clases, cuyo nombre comienza con un guión bajo, y
son llamados por el intérprete en situaciones especiales.
Existen ocho método especiales diferentes, y todos son opcionales.
_init Inicialización de la clase.
_exit Deinstanciación de la clase.
_new Instanciación de los objetos.
_free Deinstanciación de un objeto.
_next Enumeración de una clase u objeto.
_get Operador de lectura de un Array.
_put Operador de escritura de un Array.
_call Uso de un objeto o clase como un método.
_unknown Llamada a un método o propiedad desconocida.
_compare Define como comparar los objetos del mismo tipo en un array.
Para ver un ejemplo de _compare, vease este enlace: propiedades y metodos de array de
objetos
20

Electiva II. Gambas
Propiedades y Métodos (.add, .remove, .find, etc) de array de objetos
Propiedades
bounds Retorna una cadena, que informa sobre el
tipo de clase
count Devuelve el número de elementos que
tiene el array
data Retorno el puntero del dato
Dim Retorna el número de dimensiones del
arrray
length Igual que count
max Devuelve el mayor índice del array:
array.max=array.count-1
type Devuelve el tipo de dato. (ver: Constantes
predefinidas de tipo de dato)
Métodos
Clear Limpia el array.
.Clear ( )
Remove Borra uno o más elementos del array
.Remove ( Index As Integer [ , Length As
Integer ] )
Resize Cambia el tamaño del array
disminuyéndolo o expandiéndolo (sólo es
posible usarlo en array de una dimensión)
.Resize ( Size As Integer )
add Añada (o inserta en la posición indicada)
un nuevo elemento nuevo.
.Add ( Value As Object [ , Index As Integer
] )
copy Retorna la copia de parte del array
21

Electiva II. Gambas
.Copy ( [ InicioIndice As Integer, Longitud
As Integer ] ) As Object[]
delete Borrar parte del array, retornandolo
.Delete ( InicioIndice As Integer [ , longitud
As Integer ] ) As Object[]
exist Devuelve verdadero si existe la referencia
al objeto dentro del array
.Exist ( Value As Object ) As Boolean
existbyref Al igual que el método exist, pero sin usar
el método especial _compare
extract Igual que delete
Fill Rellena un array con un objeto
determinado
.Fill ( Value As Object [ , Start As Integer,
Length As Integer ] )
find Busca un objeto dentro del array
devolviendo la posición donde que ocupa.
Si no lo encuentra devuelve -1. Se puede
indicar una posición de inicio de la
busqueda.
.Find ( Value As Object [ , Start As Integer
] ) As Integer
findbyref Al igual que find, pero sin usar el metodo
especial _compare
insert Inserta un array de objetos dentro del
mismo array, se puede especificar una
posición, sino, lo hará al final del array.
.Insert ( Array As Object[] [ , Pos As
Integer ] ) As Object[]
pop Borra el último elemento del array,
retornandolo.
22

Electiva II. Gambas
.Pop ( ) As Object
push Añade un array al final del array (es una
simplificación del método .add)
.Push ( Value As Object )
reverse Invierte el orden del array de elementos y
los devuelve
.Reverse ( ) As Object[]
sort Ordena el array Ascententemente
(gb.ascent) o descendentemente
(gb.descent)
Para ordenalo usa el método especial
_compare
.Sort ( [ Mode As Integer ] ) As Object[]
A continuación un ejemplo, de cómo usar el método sort en un array de objetos.
Tenemos una clase llamada ClassPersona, en ella tenemos dos propiedades (nombre y
edad). Queremos que los array que de esta clase se ordene por el nombre.
Este seria el código de la clase ClassPersona:
' Gambas class file
Property edad As Integer
Private hedad As Integer
Property nombre As String
Private hnombre As String
Private Function nombre_Read() As String
Return hnombre
End
Private Sub nombre_Write(Value As String)
hnombre = Value
End
Private Function edad_Read() As Integer
Return hedad
23

Electiva II. Gambas
End
Private Sub edad_Write(Value As Integer)
hedad = value
End
Public Function _compare(Other As ClassPersona) As Integer
' Return Sgn(hedad - Other.edad)
If hnombre > Other.nombre Then Return 1
Return -1
End
Nota:
Debemos fijarnos que en el método especial _compare, se ha comentado como seria si se
ordenará por la edad.
Ahora pasamos a crear el programa principal, donde se crea el array de objetos
(listaPersonas) y los voy a ordenar y mostrar de forma ascendente y
descendente:
Dim a As Integer 'contador para el for...next
Dim per As New ClassPersona 'objeto que nos sirve para ir añadiendo valores al array
Dim listaPersonas As ClassPersona[] 'array de objetos de la clase ClassPersona
per.edad = 23
per.nombre = "Eva Muñoz"
listaPersonas = New ClassPersona[]
listaPersonas.Add(per) 'añado nuevo elemento al array
per = Null 'borro el objeto
per = New ClassPersona
per.edad = 34
per.nombre = "Julio Sanchez"
listaPersonas.Add(per) 'añado nuevo elemento al array
'ordeno....
listaPersonas = listaPersonas.Sort(gb.Ascent)
'muestro en la consola los valores de los objetos
Print "Edad", "Nombre (ascendente)"
For a = 0 To listaPersonas.Max
Print listaPersonas[a].edad, listaPersonas[a].nombre
Next
'ahora los muestro de forma descendente:
listaPersonas = listaPersonas.Sort(gb.Descent)
'muestro en la consola los valores de los objetos
24

Electiva II. Gambas
Print "Edad", "Nombre (descendiente)"
For a = 0 To listaPersonas.Max
Print listaPersonas[a].edad, listaPersonas[a].nombre
La Herencia entre clases: inherits
¿que es la herencia?
La herencia facilita la creación de objetos a partir de otros ya existentes e implica que una
subclase obtiene todo el comportamiento (métodos) y eventualmente los atributos
(variables) de su superclase.
La clase de la que se hereda se suele denominar clase base, clase padre, superclase, clase
ancestro.
La clase derivada de la herencia, se le puede añadir sus propios métodos o cambiar los
definidos en la clase superclase, para modificar su comportamiento.
Es a destacar, el hecho de que cuando se usa como parámetro en una función una clase
padre, dicha función admitirá también como objetos válidos, los objetos heredados de la
clase padre.
¿Cómo se consigue la herencia en Gambas3?
Simplemente al iniciar la clase, se usa esta orden:
• INHERITS ParentClass
Donde ParentClass es la clase de la que queremos heredar los métodos y propiedades.
En gambas3 solo existe la "herencia Simple", la herencia múltiple hay que simularla
mediante composición de clases.
Ejemplo:
Hacer un programa que registe los Docentes, Administrativos y personal de limpieza. Con
los métodos y atributos de la figura 1.
Haremos la siguiente estructura de clases:
25

Electiva II. Gambas
Declararemos la clase Persona:
' Gambas class file
Property nombre As String
Private hnombre As String
Property SueldoMensual As Single
Private hsueldoMensual As Single
'------------------- lectura y escritura de valores de propiedades -------------
Private Function nombre_Read() As String
Return hnombre
End
Private Sub nombre_Write(Value As String)
hnombre = value
End
Private Function SueldoMensual_Read() As String
Return hsueldoMensual
End
Private Sub SueldoMensual_Write(Value As String)
hsueldoMensual = value
End
'------------------- Metodos -------------
Public Sub Consultar()
Print "Consultar datos...."
Print "Nombre: " & hnombre
Print "Sueldo: "; sueldo()
Print "----------------------------"
26

Electiva II. Gambas
End
Public Function Sueldo() As String
Return "El sueldo de una persona es de " & Str$(hsueldoMensual) & " €."
End
Public Sub Registrar(nombre As String, sueldo As Single, Optional valor1 As Variant,
Optional valor2 As Variant) 'nombre As String, sueldo As Single)
hnombre = nombre
hsueldoMensual = sueldo
End
En la función registrar (número de línea 51), se dejan varios parámetros en forma de
opcional (se pueden poner o no) y tipo variant (que admitirían cualquier tipo de
datos), que nos servirán para usarlo en las clases heredadas.
Declaremos las clases que la heredan:
Administrativos
' Gambas class file
Inherits Persona
Property area As String
Private harea As String
Private Function area_Read() As String
Return harea
End
Private Sub area_Write(Value As String)
harea = Value
End
'------------------- Métodos -------------
Print "Nombre: " & Super.nombre
Print "Area de trabajo: " & harea
Print "Sueldo: ", Super.sueldo()
Print "----------------------------"
End
27

Electiva II. Gambas
Public Sub Registrar(nombrePropio As String, sueldoCantidad As Single, Optional
AreaTrabajo As Variant, Optional v As Variant) 'nombre As String, sueldo As Single)
Super.nombre = nombrePropio
Super.SueldoMensual = sueldoCantidad
harea = areaTrabajo
End
Docente:
' Gambas class file
Inherits Persona
Property cargo As String
Private hcargo As String
Property horasTrabajadas As Integer
Private hhorasTrabajadas As Integer
Private Function cargo_Read() As String
Return hcargo
End
Private Sub cargo_Write(Value As String)
hcargo = Value
End
Private Function horasTrabajadas_Read() As Integer
Return hhorasTrabajadas
End
Private Sub horasTrabajadas_Write(Value As Integer)
hhorasTrabajadas = Value
End
'------------------- Metodos -------------
Print "Cargo: " & hcargo
Print "Horas Trabajadas: " & hhorasTrabajadas
Print "Sueldo: ", Me.sueldo()
Print "----------------------------"
End
28

Electiva II. Gambas
cargoTrabajo As Variant, Optional horas As Variant) 'nombre As String, sueldo As
Single)
hcargo = cargoTrabajo
hhorasTrabajadas = horas
End
Public Function Sueldo() As String
Dim gana As String
gana = Super.SueldoMensual + 30 * hhorasTrabajadas
Return "El sueldo de una persona es de " & Str$(gana) & " Bs."
End
Cabe destacar la línea 43 donde se hace uso de Me.Sueldo() para calcularlo según
la función que está definida en la clase (líneas 57 y sucesivas). Sin embargo en la
línea 40, se hace uso de Super.Nombre para llamar a la clase padre.
PersonalLimpieza
' Gambas class file
Inherits Persona
Property turno As String
Private hturno As String
Private Function turno_Read() As String
Return hturno
End
Private Sub turno_Write(Value As String)
hturno = Value
End
'------------------- Metodos -------------
TurnoTrabajo As Variant, Optional val1 As Variant) 'nombre As String, sueldo As
Single)
29

Electiva II. Gambas
hturno = turnoTrabajo
End
'------------------- Metodos -------------
Print "Turno: " & hturno
Print "Sueldo: ", Super.sueldo()
Print "----------------------------"
End
Y la clase Main: (inicio del programa)
Public Sub Main()
Dim per1 As New Persona
Dim per2 As New Administrativo
Dim per3 As New Docente
Dim per4 As New PersonalLimpieza
per1.Registrar("Juan", 100)
per1.Consultar()
per2.Registrar("Jose", 120, "Administracion General")
per2.Consultar()
per3.Registrar("Javier", 80, "Profesor Matematicas", 10)
per3.Consultar()
per4.Registrar("Julio", 74, "nocturno")
mostrar(per4)
End
Public Sub mostrar(per As Persona)
Print "********************************************************"
Print "Usando una función que recibe cualquier clase de persona"
Print "********************************************************"
per.Consultar()
End
30

Electiva II. Gambas
Aquí se puede destacar el uso de la función mostrar(), que recibe una clase persona (o
cualquiera que herede de ella) y trabaja con los métodos que tenga sin ningún problema.
Por ejemplo en este caso se le envia una clase PersonalLimpieza y nos muestra sus datos
Me, Super y Herencia
En este párrafos se mostrará el uso de ME y de SUPER. En la documentación oficial explica
que son:
ME Devuelve una referencia al objeto actual.
ME es obligatorio cuando quiere llamar a un método heredado, o acceder a una propiedad
o heredada.
SUPER
Devuelve una referencia al objeto actual que empleará la implementación de los símbolos de
la clase padre.
Como se ve con ME se hace referencia al objeto actual. Si estamos en el código del
formulario, y lo queremos cerrar, usamos esta orden:
me.close()
De esta forma, estamos cerrando el formulario actual.
Ejemplo:
Un ejemplo de uso de Super y Me. Se trata de tener dos clases, una clase padre llamada
Soldado y otra que le herede llamado "SoldadoAmetralladora"
Código de la clase Soldado:
' gambas class file
Public Sub dispara()
Print "me prepararo para disparar...."
Me.dibujadisparo()
End
31

Electiva II. Gambas
Public Sub dibujadisparo()
Print "---- dibuja una piedra volando por la pantalla -------"
End
Código de la clase SoldadoAmetralladora:
' gambas class file
Inherits Soldado
' gambas class file
Private arma As String = "ametralladora"
Public Sub dispara()
Print "me prepararo para disparar...."
Me.dibujadisparo()
End
Public Sub dibujadisparo()
If arma = "ametralladora" Then
Print "---- dibuja disparando una ametralladora -------"
Else
Super.dibujadisparo()
Endif
End
Public Sub quitoarma()
arma = "sin ametralladora"
End
Y el programa principal:
Public Sub Form_Open()
Dim soldadotmp As New Soldado
Dim soldadoAmetralladora As New SoldadoAmetralladora
Print soldadotmp
soldadotmp.dispara()
Print SoldadoAmetralladora
SoldadoAmetralladora.dispara()
Print "--------Quito arma -----"
soldadoAmetralladora.quitoarma()
soldadoAmetralladora.dispara()
End
Lo que hace la aplilcación es crear un la clase Soldado (soldadotmp), y luego crear otra del
tipo SolddoAmetralladora (que hereda de la clase Soldado).
32

Electiva II. Gambas
Cuando se ejecuta el método SoldadoAmetralladora.dispara(), ejecuta las ordenes que tiene
el método dispara(). Este método llama a "dibujadisparo". Que según el valor de la variable
arma, escribe "dibuja dispara una ametralladora" o hace la llamada al método
dibujadisparo() de la clase padre, usando SUPER.
Resultado:
El resultado de la aplicación es este:
(Soldado 0x8879b54)
me prepararo para disparar....
---- dibuja una piedra volando por la pantalla -------
(soldadoAmetralladora 0x8879c14)
---- dibuja disparando una ametralladora -------
--------Quito arma -----
---- dibuja una piedra volando por la pantalla -------
Clases y Objetos: Borrar un objeto (destructor)
Gambas se encarga de cuando ya no se usa un objeto, este se borre. De todas maneras,
si quieres forzar el borrado de un objeto, usa la orden null.
Por ejemplo: objeto=Null
De esta manera borramos un objeto, ¿como averiguamos si un objeto es null?
If isnull(objeto) then ....'esto se ejecuta si el objeto es Null
Ejemplo de Herencia y Polimorfismo (I: Modo Consola)
Vamos a pasar a describir un ejemplo de herencia y polimorfismo en Gambas3.
El objetivo es hacer un programa que calcule el perímetro de rectángulos, cuadrados y
circunferencia, usando la programación orientada a objetos.
Podemos crear una clase, la llamaremos classfigura, que englobe a los diversos tipos
(rectángulo, cuadrado, circuferencia)..
Esta clase figura tendrá un método para cálculo del perímetro (CalculoPerimetro) y otro que
he añadido para que nos de información de la figura.
' Gambas class file
Public Function CalculoPerimetro() As Float
33

Electiva II. Gambas
End
Public Function define() As String
End
Ahora añadiremos varias clases, que hereden de la clase figura. Esto se hace haciendo click
con el botón derecho en el menú del proyecto:
Pulsando en el menú "Nuevo" y luego "Clase"
Ahora elegimos que herede de la clase Figura y le pondremos el nombre de ClassCuadrado
34

Electiva II. Gambas
Repetimos los pasos para crear las clases ClassRectangulo y ClassCirculo, todas ellas
heredan de la la classFigura.
Ahora, nos vamos a la clase Cuadrado, y redefinimos las funciones (a esto se le llama
polimorfismo):
' Gambas class file
Export
Inherits ClassFigura
Private $lado As Float
Public Sub _new(lado As Float) ''constructor: pide las longitudes del lado
$lado = lado
End
Public Function CalculoPerimetro() As Float '' calculo del perimetro
Dim perimetro As Float
perimetro = $lado * 4
Return perimetro
End
Public Function define() As String ''Escribe que figura es
Return "Cuadrado"
End
Ahora la clase Réctangulo: classRectangulo
' Gambas class file
Export
Private $ladoA As Float
Private $ladoB As Float
Public Sub _new(ladoA As Float, ladoB As Float) ''constructor: pide las longitudes de
los lados A y B
$ladoA = ladoA
$ladoB = ladoB
End
35

Electiva II. Gambas
perimetro = $ladoA * 2 + 2 * $ladoB
Return perimetro
End
Return "Rectangulo"
End
Y ahora la clase Circulo: classCirculo
' Gambas class file
Export
Private $radio As Float
Public Sub _new(radio As Float) ''constructor: pide el radio del circulo
$radio = radio
End
perimetro = 2 * $radio * Pi
Return perimetro
End
Return "Círculo"
End
Por ahora no vemos nada nuevo.. ninguna utilidad...¿no?... ahora verás...
En la clase de inicio, vamos a definir varias instancias y una función "informe":
Public Sub Main()
Dim cua As New ClassCuadrado(19)
Dim rect As New ClassRectangulo(10, 5)
Dim cir As New ClassCirculo(8)
Print "Escribimos los perimetros de las figuras creadas anteriormente"
informe(cua)
informe(rect)
informe(cir)
36

Electiva II. Gambas
End
Public Function informe(a As ClassFigura) As Float
Print a.define(); " ";
Print a.CalculoPerimetro()
End
Fíjate que la función informe recibe como argumento una clase figura, y en la funcion Main,
le estamos mandando diversas clases (pero todas ellas heredan de la clase figura!!!)
Lo que nos va a imprimir, va a hacer el cálculo del perímetro, siendo la forma de calcularlo
como lo hayamos definido en la figura que le mandemos...
Resultado en la consola:
Escribimos los perímetros de las figuras creadas anteriormente
Cuadrado 76
Rectangulo 30
Circulo 50,2654824574367
La gran ventaja que tiene este método, es que el día de mañana, que añadamos una nueva
figura (por ejemplo una elipse), la función "informe" no cambiará en nada, siendo capaz de
darnos el cálculo del perímetro.
Actividad:
1) Añade la claseElipse, para que nos calcule el perimetro.
2) Añade a las clases anteriores la fórmula de cálculo del área. Y que el programa principal
sea capaz de darnos el área de las figuras.
Usar clases realizadas en otros programas Gambas en tu programa.
Para usar clases realizadas en otros programa de Gambas, se puede hacer de dos
maneras:
1) Añadiendo el archivo .class como existente:
En el lado izquierdo del Ide, en "fuentes", pulsar el botón derecho, elegir la opción de
"Nuevo", la opción "Clase" (si quisiéramos añadir un módulo o formulario existente, lo
haríamos de la misma forma)
37

Electiva II. Gambas
y saldrá un nuevo formulario, donde tenemos que elegir la pestaña "Existente".
Allí se puede buscar y seleccionar el archivo .class que se necesite.
Nota:
Ten en cuenta que los archivo de código (clases y módulos) y formularios (.fmain), se
encuentran en gambas3, en el subdirectorio .src del directorio del proyecto.
2) Añadir una bibioteca.
Para añadir una biblioteca, es necesario previamente que se cumplan dos cosas:
a) Que las clases que van a ser compartidas, sean Exportables, osea en el código de la
clase debe de tener puesto el comando Export
38

Electiva II. Gambas
b) Que tengamos el archivo .gambas donde estén esas clases exportables.
Para añadir la biblioteca a nuestra aplicación, hacemos lo siguiente:
En el menú Proyecto/Propiedades, vamos a la pestaña librerías:
Luego se presiona el botón "Agregar", y aparece un formulario donde se puede elegir los
archivo .gambas
39

Electiva II. Gambas
Una vez elegido, vemos como se añade el archivo al proyecto:
Y ya podemos usar las clases que sean "exportables" del OrdenarArrays en nuestra
aplicación.
Nota: Advertencia!
Como se puede ver gambas avisa si se crea un ejecutable del proyecto, las librerías (en
nuestro caso OrdenarArrays.gambas) debe de ser también almacenada en el mismo
directorio, en caso contrario el programa no funcionaría ya que no las encontraría.
El error que mostraría en la consola sería:
ERROR: #27: Cannot load component 'OrdenarArrays.gambas': cannot find library
40

Unidad introduccion a la poo

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Unidad introduccion a la poo

Similar a Unidad introduccion a la poo (20)

Más de Sol Hernández

Más de Sol Hernández (20)

Último

Último (20)

Unidad introduccion a la poo