DDD: Groovy mediante casos reales. (parte 1)

(DDD significa Departamento de Delirios)

Groovy es una "expansion" del lenguaje Java (como lo es C++ a C).

Conceptos que estaria copado que sepas (y que groovy implementa):
- Debilmente tipado/Tipado dinamico si se quiere (podes hacer todo Fuertemente tipado/Tipado estatico):
http://tinyurl.com/2937ppl

- Soporte nativo de Expresiones Regulares:
http://tinyurl.com/66ec58
http://tinyurl.com/394owu (Si entendes este link, es porque entendiste las Exp. Reg.)

- Beans (Generacion automatica de Setters & Getters)
http://tinyurl.com/2bmjcpy

- Soporte nativo para Lenguajes de marcado:
http://tinyurl.com/24wllrh

Conceptos que se explicaran:
- Soporte nativo de colecciones (Tipo Smalltalk)
- "Navegacion segura"
- Iteracion polimorfica
- Expresiones dentro de Strings (Tipo PHP)
- Clausuras/Bloques de codigo.


NOTA INICIAL: En Groovy, una linea termina con un "salto de linea" (enter). El "punto y coma" no hace falta!

-------------------------------------------------------------------------------------
1 - Tipado dinamico:

Supongamos una base de datos con "Equipos", y un campo "Tipo_Equipo" que contiene un integer.

Supongamos una Clase abstracta "Equipos", de la cual heredan las clases "Router" "PC" "Mac"

envez de hacer:

A - BigDecimal miNumero = MiFactory.DameUnNumero(3);
B - public static BigDecimal DameUnNumero(int num) {return new BigDecimal(num);}

podemos hacer:

A - def miNumero = MiFactory.DameUnNumero(3);
B - static def DameUnNumero(num) {return new BigDecimal(num)}

miNumero, en tiempo de ejecucion, será del tipo de datos que devuelva el método MiFactory.DameUnNumero.
De esta forma, si ya no nos gusta BigDecimal, y queremos que retorne un Integer, el codigo será:

B - static def DameUnNumero(num) {return new Integer(num)}

Y la linea A no se modificará (haciendo tu codigo mas "mantenible").

-------------------------------------------------------------------------------------

2 - Soporte nativo de expresiones regulares

Ejemplos:

//  ==~  Machea TODA la cadena       
"2009" ==~ /\d+/             // retorna TRUE
"holla" ==~ /\d+/            // retorna FALSE
"cheesecheese" ==~ "cheese"   // retorna FALSE

//  =~   Machea AL MENOS en una parte de la cadena 
"cheesecheese" =~ "cheese"   // retorna TRUE
"cheesecheese" =~ "queso"   // retorna FALSE

// Sobreescribir cadenas:
def replaced1 = "abc".replaceAll(/(a)(b)(c)/, '$1$3') //retorna "ab"
def replaced2 = "abc".replaceAll(/(a)(b)(c)/, "Pepe $1') //retorna "Pepe a"

En java, es un quilombo, hay que crear la expresion regular, compilarla, y ejecutar un metodo... aca el soporte es nativo, y facil para los que alguna vez programamos en Perl.

Puede ver mas ejemplos en: http://groovy.codehaus.org/Regular+Expressions

-------------------------------------------------------------------------------------

3 - Beans (Generacion automatica de Getters & Setters)

Supongamos el bean Maquina:

class Maquina {  //Groovy asume que la clase es Public
   def nombre
   def placa3D
   def bichos
}

// Desde otro lado

new Maquina(nombre:"La compu", placa·D: new GeForce("GTX 260 192 SP") );

Envez de tener que escribir Getters & Setters uno a uno.