Código Groovy

public class HolaMundo{

String getSaludo(){
"Programando en Groovy";
}

static int method(String arg) {

return 1;
}

static int method(Object arg) {

return 2;
}

static void testA(){

def holaMundo = new HolaMundo();
println "${holaMundo.getSaludo()}";

def (float x, int y, Object z) = [34.6f,7,new java.util.Date()]

println x
println y
println z
def name = "Raghav"
println 'Name is ${name}'
println "Name is ${name}"
def (String a, int b) = [10,20,30]
println a
println b
def (int c, int d, String n) =[12,13]
println c
println d
println n

//Esto causaria un error:

//def (String m, float p) = ["Hola, mundo"]

def num = 10
println num.getClass().getName()
def numero = (byte) 23
println numero.getClass().getName()

println getMensaje()
}

static void testB(){

Object obj = "Object"
int result = method(obj);
println "Resultado: ${result}"
obj = new Object()
result = method(obj)
println "Resultado: ${result}"
}

static void testC(){

println "*** Meta programacion ***"
X.metaClass.edad = 39
//X.metaClass.setAttribute(objX,"edad",2020-1981)
def objX = new X(nombre:"El general Arteaga.")
println "Nombre: ${objX.nombre}"
println "Edad: "+objX.edad
assert objX.edad == 39
}

static void testD(){

String cadena = "El unicornio salvaje."
def objA = new A()
println "${objA.getTipo(cadena)}"

def fecha = new java.util.Date()

def objB = new B()
println objB.getTipo(fecha)

IGenerica<Integer> entero = new IGenerica<Integer>(){

Integer getTipo(Integer tipo){
return tipo + tipo
}
};

Integer dato = new Integer("32")

println "Entero: ${entero.getTipo(dato)}"

static String getMensaje(){

"Este es un mensaje"
}
static void testE(){
println "*** Aserciones ***"
assert 1 + 6 == 7
assert 45 - 10 == 35
assert 34 > 33 == true
assert 10 % 3 == 1
assert 2 ** 3 == 8
assert "Hola" == "Hola"
assert 9.intdiv(5) == 1
//Esto causara un error:
assert new java.util.Date() == new java.util.Date()
assert !(45 > 133) == !(false)
int i = 9
++i
assert i == 10
assert (!false && false) == false
assert (true && !false) == !false
def salida = (33 > 11)? "Verdadero" : "Falso"
println salida
X.metaClass.edad = 34
def objX = new X(nombre:"Tadeo Sornoja")
println "Nombre: "+objX.nombre
println "Edad: "+objX.edad
assert objX.edad == 34
assert objX instanceof X
}

static void testF(){

println "*** Selectivas ***"
def entrada = -1
switch(entrada) {
case 0:
println "X"
break
case {entrada>0}:
println "Y"
break
case {entrada<0}:
println "Z"
break
}

static void testH(){

println "*** Listas y mapas ***"
def listaNumeros = [12,65,-32,0,12.7, 8.3,-45.0]
listaNumeros.each{it ->
println "Hola: ${it}"
}
println listaNumeros
println listaNumeros[0]
println listaNumeros[6]
def item = 43
println "Item: ${item}"
listaNumeros<<item
def listaOrdenada = listaNumeros.sort()
println listaOrdenada
listaNumeros.remove(0)
println listaNumeros
println listaNumeros.get(0)
println listaNumeros.get(3)
if(listaNumeros.contains(65)){
println "Contiene el numero 65"
}
def vacia = listaOrdenada.isEmpty()? "Lista vacia" : "Lista llena"
println vacia
def tam = listaNumeros.size()
println "Tam: ${tam}"
println listaOrdenada
listaOrdenada.add(0,32)
println listaOrdenada
println listaNumeros.reverse()
listaNumeros.pop()
listaNumeros.pop()
listaNumeros.removeLast()
listaOrdenada.removeLast()
println listaNumeros
println listaOrdenada
listaNumeros.removeAll{it}
listaOrdenada.removeAll{it}
println listaNumeros
println listaOrdenada
println "Clase: ${listaOrdenada.getClass()}"
println "Mapas:"

def mapaNumeros=[3:"A",5:"X",9:"D",7:"T"]
println mapaNumeros

for(n in mapaNumeros){
 println n
println n.key +" : "+n.value
}
println mapaNumeros[3]
mapaNumeros[10] = "G"
println mapaNumeros
println mapaNumeros[10]
def mapaTam = mapaNumeros.size()
println "Tam: "+mapaTam
println mapaNumeros.get(9)//D
println mapaNumeros.get(10)//G
println mapaNumeros.get(3)//A
println mapaNumeros.getAt(3)//A
println mapaNumeros.getAt(9)//D
mapaNumeros.put(4,"Y")
println mapaNumeros
mapaNumeros.put(8,"U")
println mapaNumeros
if(mapaNumeros.containsKey(5)){
println "Contiene llave 5: "+mapaNumeros.getAt(5)
}
println mapaNumeros.containsValue("Q")
println mapaNumeros.containsValue("A")
println "Clase: "+mapaNumeros.getClass()
def mapaClon = mapaNumeros.clone()
println "Mapa clon: "+mapaClon
if(mapaNumeros == mapaClon){
println "Los mapas son identicos"
}

mapaNumeros.each{key, value->
println "Llave: $key, Valor: $value"
}

mapaClon.eachWithIndex{key, value, index->

println "$key, $value, $index"
}

mapaNumeros.each{entry->
println "$entry"
}
println "----------------"
//mapaNumeros.each{entry, i ->
//println "$entry.key , $entry.value: $i"
//}
 mapaClon.clear()
println "Clon: "+mapaClon
mapaClon = mapaNumeros.entrySet()
println "Clon: "+mapaClon
}

static void testI(){

println "*** Clousures ****"
def cadena = "Hola"
def miClousure = {nombre->
println "$cadena $nombre"
}

miClousure.call("Fernando")

def myMetodo = {
println "Ciao, Mondo!!"
}

def msg ="El titulo del libro es: "

def titulo = "El retatro de una odisea sin nombre."
def otroMetodo = {it ->
println "$msg $it"
}

myMetodo()
otroMetodo(titulo)

def testClos = new TestClos()

testClos.callClousure(miClousure)

def otherClousure ={ x,y,z->

return (x+y+z)
}

def suma = otherClousure(1,2,3)

println "Suma: "+suma

def lista = [21,"Manzanas",true, new Integer("31"), Boolean.TRUE]

println lista.each{it}
def mapa = ["A":true,"B":false]
println mapa.each{it}

def numeros =[1,2,3,4,5,6]

println numeros.find{it-> it == 3}
 //Esto provoca un null, no esta el 9 en la lista
println numeros.find{it-> it==9}
println numeros.findAll{it-> it > 3}//4,5,6
println numeros.any{it-> it > 3}//true
println numeros.any{it-> it > 6}//false
println numeros.every{it-> it > 3}
println numeros.collect{it-> it+2}
try{
new File("C:\\Users\\DELL\\Documents\\programacion").each{it->
println "${it}"
}
}catch(Exception ex){
println "Causa: "+ex.getCause()
println "Mensaje: "+ex.getMessage()
}

static void testG(){

println "*** Clases ***"
def mock = new Mock()
mock.suma()//3
mock.suma(2)//4
mock.suma(3,3)//6

Externa externa = new Externa()

externa.nombre = "El general Borbotones."
println externa.nombre
Externa.Interna interna = new Externa.Interna()
interna.valor = new Integer("22")
println interna.valor

X.metaClass.verdadero = false
def objX = new X(nombre:"MX-432")
if(!objX.verdadero){
println "Nombre: ${objX.nombre}"
}

if(objX instanceof X){

println "Es de tipo X"
}

}
 static void main(args){
testA()
testB()
testC()
testD()
testE()
testF()
testG()
testH()
testI()
}

class TestClos{
def callClousure(clous){
clous.call("Groovy")
}
}

class X{
String nombre
}

interface IGenerica<T>{
T getTipo(T tipo)
}

class A implements IGenerica<String>{

String getTipo(String tipo){
return tipo.getClass().getName()
}
}

class B implements IGenerica<java.util.Date>{

java.util.Date getTipo(java.util.Date tipo){
return tipo
}
}

class Mock{
def suma(int a=1, int b=2){
println "Suma: "+(a+b)
 }
}

class Externa{
String nombre
static class Interna{
Integer valor
}
}