Al ser Boo un lenguaje con soporte para múltiples paradigmas de programación, la implementación de objetos (relacionado al OOP) es heredada de python, pero no de una forma estricta, para ello usa la palabra clave class (que va junto al nombre de la clase implementada), además de no ser indispensable la definición de un método constructor (aunque por razones de buena práctica de programación debe considerarse) ya que podemos ejecutar algunas acciones al momento de instanciar la clase (declarar un objeto).

class NombreDeLaClase:
    miembro_campo1 as int

    def constructor():
    	m = 1

    def destructor():
    	m.Dispose() // Aunque haya un Garbage Collector, supongo es bueno considerarlo

¿ Permite Boo la Herencia de clases u objetos ?

Cuando se dice que una cierta clase A hereda a otra clase B significa que la clase A contiene todos los miembros de la clase B más algunos métodos que opcionalmente puede implementar ella misma. Las clases en Boo soportan herencia simple, hereda de una y no de muchas clases.

// Se declara cPadre() y el heredero cHijo()
class cPadre:
	def metodo_del_padre():
		print "Soy el Metodo de una Clase Padre"

// La clase de la cual se hereda va como parametro en la definición de la clase
class cHijo(cPadre):
	def metodo_de_hijo():
		print "Soy el Metodo de la Clase Hijo"

iHijo = cHijo() // Instancia de una clase Hijo
iHijo.metodo_del_padre()

La palabra reservada SUPER

La palabra reservada super sirve para acceder a miembros de la clase heredada de la misma forma que this sirve para acceder a miembros de la propia clase. Su sintaxis es idéntica a la de this, esto es:

class A:
	miembro as string = "Hola mediante valor de un atributo"
	def mensaje():
		print "Hola mediante un método"  

class C(A):
	def mensaje_de_c():
		print super.miembro // Accediendo al miembro de la clase Base

objeto = C()
objeto.mensaje()
objeto.mensaje_de_c()

¿ Cómo se manejan delegados en Boo ?

Una de las características más interesantes en el manejo de eventos es el poder delegar a un bloque el manejo de un evento sin necesidad de definir un método específico para ello (aunque esto no lo evita si uno lo desea) es por ello que podemos definir un delegado para los eventos directamente basta con asignar al evento el bloque como se ve:

button.Clicked += def():
	print "Haz hecho click sobre mi"
	print "Y debo imprimir este mensaje  "

Al analizar el código anterior se ve que al evento “Clicked” se le ha delegado un bloque de instrucciones, esto con el operador += (y es posible quitarselo con -= en teoría), para que se entienda en que momento deben ser usados estos métodos delegados, es cuando suceden eventos (GUI, Web -asp.net, xaml, etc), un ejemplo completo y funcional es el siguiente en Windows.Forms

import System.Windows.Forms
import System.Drawing

f = Form("Hola, Mundo")
f.Show()
Application.Run(f)

¿ Qué son las propiedades y cómo las declaro en Boo ?

Por defecto las variables que declaramos como campos en las clases son protegidas, es decir que no pueden ser accedidas fuera de la clase o el objeto que las define, un ejemplo de ello lo podemos en el siguiente código:

>>> class Prueba:
...	i as int

>>> objeto = Prueba()
>>> objeto.i = 1 // Esto genera un error ya que el campo esta protegido

Es por ello que para acceder a los campos desde fuera, debemos de hacer uso de mecanismos que nos permitan modificar los valores y no solo basta con declarar público el campo (la solución más sencilla)que si bien es un medio no el único ya que junto a ello existen las denominadas propiedades de un campo, que nos permiten definir si un campo es de lectura escritura o ambos(Standard getter/setter), definir el nombre por el cual accedemos a esa campo, y definir incluso condicionantes (pre-condiciones) sobre el campo, ya que el paradigma de orientación a Objetos, permite definir algunos atributos con algunas propiedades especiales o simplemente lo que va dentro de los parentesis, es el nombre por el cual se accede a la propiedad. Para ello veamos mejor el siguiente código:

class Perro:
	[property(Patas)]
	nro_de_patas as int = 4

oLaika = Perro()
print "Nro de patas: " + oLaika.Patas
oLaika.Patas = 2 // Un perro en dos patas??
print "Nro de patas: " + oLaika.Patas

Casos especiales de propiedades.

accesors – getters

Este caso permite definir un atributo de solo lectura para su valor, independiente de que sea pública o no.

//	[getter(Nombre_De_Acceso)]
//	variable_definida as float = 12.3

class cTst:
	[getter(Nombre)]
	_first_name as string = "NoName" 

objEjemplo = cTst()
objEjemplo.Nombre = "Francesca"

mutators – setters

En este caso se puede modificar el valor de la variable pero no se le puede preguntar por su valor directamente.

//	[setter(NombredeAcceso)]
//	variable_definida as int = 12

class cTst2:
	[getter(Temperatura)]
	 temp_personal as float = 36.9 

objEjemplo2 = cTst2()
objEjemplo2.Temperatura = 32.6

Con estos datos espero, que puedan iniciar (o cambiar) su orientación en su programación y si han estado probando Boo, vean que pueden tener cualquier paradigma dentro de este lenguaje de programación, cómo algunos ya se preguntarán es si todos los paradigmas dentro de la programación están cubiertos (como Generics, Decorators o patrones de diseño), bueno a algunos de ellos sí lo están, otros por una cuestión de forma (ya que el CLR puede que ya lo soporte dicese .Net) aún no han sido implementados, aunque se espera que lo estén en futuras versiones; me despido hasta un futuro post sobre Boo, HAppY Coding!.