Groovy - Opcionales

Groovy es un lenguaje escrito "opcionalmente", y esa distinción es importante a la hora de comprender los fundamentos del idioma. En comparación con Java, que es un lenguaje de tipo "fuerte", mediante el cual el compilador conoce todos los tipos de cada variable y puede comprender y respetar los contratos en el momento de la compilación. Esto significa que las llamadas a métodos se pueden determinar en tiempo de compilación.

Al escribir código en Groovy, los desarrolladores tienen la flexibilidad de proporcionar un tipo o no. Esto puede ofrecer cierta simplicidad en la implementación y, cuando se aprovecha adecuadamente, puede dar servicio a su aplicación de una manera sólida y dinámica.

En Groovy, la escritura opcional se realiza mediante la palabra clave 'def'. A continuación se muestra un ejemplo del uso de ladef método -

class Example { 
   static void main(String[] args) { 
      // Example of an Integer using def 
      def a = 100; 
      println(a); 
		
      // Example of an float using def 
      def b = 100.10; 
      println(b); 
		
      // Example of an Double using def 
      def c = 100.101; 
      println(c);
		
      // Example of an String using def 
      def d = "HelloWorld"; 
      println(d); 
   } 
}

En el programa anterior, podemos ver que no hemos declarado las variables individuales como Integer, float, double o string a pesar de que contienen estos tipos de valores.

Cuando ejecutamos el programa anterior, obtendremos el siguiente resultado:

100 
100.10 
100.101
HelloWorld

La escritura opcional puede ser una utilidad poderosa durante el desarrollo, pero puede generar problemas de mantenimiento durante las últimas etapas del desarrollo cuando el código se vuelve demasiado extenso y complejo.

Para tener una idea de cómo se puede utilizar la escritura opcional en Groovy sin que su base de código se convierta en un lío irreparable, es mejor adoptar la filosofía de la “escritura de pato” en sus aplicaciones.

Si reescribimos el código anterior usando el tipo pato, se vería como el que se muestra a continuación. Los nombres de las variables reciben nombres que se parecen más a menudo al tipo que representan, lo que hace que el código sea más comprensible.

class Example { 
   static void main(String[] args) { 
      // Example of an Integer using def 
      def aint = 100; 
      println(aint); 
		
      // Example of an float using def 
      def bfloat = 100.10; 
      println(bfloat); 
		
      // Example of an Double using def 
      def cDouble = 100.101; 
      println(cDouble);
		
      // Example of an String using def 
      def dString = "HelloWorld"; 
      println(dString); 
   } 
}