Parola chiave Groovy def

1. Panoramica

In questo rapido tutorial, esploreremo il concetto della parola chiave def in Groovy. Fornisce una funzione di digitazione opzionale a questo linguaggio JVM dinamico.

2. Significato della parola chiave def

La parola chiave def viene utilizzata per definire una variabile non tipizzata o una funzione in Groovy, poiché è un linguaggio digitato facoltativamente.

Quando non siamo sicuri del tipo di una variabile o di un campo, possiamo sfruttare def per consentire a Groovy di decidere i tipi in fase di esecuzione in base ai valori assegnati:

def firstName = "Samwell" def listOfCountries = ['USA', 'UK', 'FRANCE', 'INDIA'] 

In questo caso firstName sarà una stringa e listOfCountries sarà un ArrayList .

Possiamo anche usare la parola chiave def per definire il tipo di ritorno di un metodo:

def multiply(x, y) { return x*y }

Qui, si moltiplicano può restituire qualsiasi tipo di oggetto, a seconda dei parametri passiamo ad esso.

3. def Variabili

Comprendiamo come funziona def per le variabili.

Quando usiamo def per dichiarare una variabile, Groovy la dichiara come NullObject e gli assegna un valore nullo :

def list assert list.getClass() == org.codehaus.groovy.runtime.NullObject assert list.is(null) 

Nel momento in cui assegniamo un valore alla lista , Groovy ne definisce il tipo in base al valore assegnato:

list = [1,2,4] assert list instanceof ArrayList 

Diciamo che vogliamo che il nostro tipo di variabile sia dinamico e che cambi con un'assegnazione:

int rate = 20 rate = [12] // GroovyCastException rate = "nill" // GroovyCastException

Non possiamo assegnare List o String a una variabile di tipo int , poiché ciò genererà un'eccezione di runtime .

Quindi, per superare questo problema e invocare la natura dinamica di Groovy, useremo la parola chiave def :

def rate assert rate == null assert rate.getClass() == org.codehaus.groovy.runtime.NullObject rate = 12 assert rate instanceof Integer rate = "Not Available" assert rate instanceof String rate = [1, 4] assert rate instanceof List

4. Metodi def

La parola chiave def viene inoltre utilizzata per definire il tipo di ritorno dinamico di un metodo. Questo è utile quando possiamo avere diversi tipi di valori di ritorno per un metodo:

def divide(int x, int y) { if (y == 0) { return "Should not divide by 0" } else { return x/y } } assert divide(12, 3) instanceof BigDecimal assert divide(1, 0) instanceof String

Possiamo anche usare def per definire un metodo senza ritorni espliciti:

def greetMsg() { println "Hello! I am Groovy" }

5. def vs. Type

Discutiamo alcune delle migliori pratiche che circondano l'uso di def .

Sebbene possiamo usare sia def che type insieme durante la dichiarazione di una variabile:

def int count assert count instanceof Integer

La parola chiave def sarà ridondante lì, quindi dovremmo usare def o un tipo.

Inoltre, dovremmo evitare di usare def per parametri non tipizzati in un metodo.

Pertanto, invece di:

void multiply(def x, def y)

Dovremmo preferire:

void multiply(x, y)

Inoltre, dovremmo evitare di usare def quando definiamo i costruttori.

6. Groovy def contro Java Object

Poiché abbiamo visto la maggior parte delle funzionalità della parola chiave def e dei suoi usi attraverso esempi, potremmo chiederci se è simile alla dichiarazione di qualcosa utilizzando la classe Object in Java. Sì, def può essere considerato simile a Object :

def fullName = "Norman Lewis"

Allo stesso modo, possiamo usare Object in Java:

Object fullName = "Norman Lewis";

7. def contro @TypeChecked

Poiché molti di noi provengono dal mondo dei linguaggi rigorosamente tipizzati, potremmo chiederci come forzare il controllo del tipo in fase di compilazione in Groovy . Possiamo facilmente raggiungere questo obiettivo utilizzando l' annotazione @TypeChecked .

Ad esempio, possiamo usare @TypeChecked su una classe per abilitare il controllo del tipo per tutti i suoi metodi e proprietà:

@TypeChecked class DefUnitTest extends GroovyTestCase { def multiply(x, y) { return x * y } int divide(int x, int y) { return x / y } }

In questo caso, la classe DefUnitTest verrà controllata del tipo e la compilazione fallirà a causa del fatto che il metodo multiply non viene digitato . Il compilatore Groovy visualizzerà un errore:

[Static type checking] - Cannot find matching method java.lang.Object#multiply(java.lang.Object). Please check if the declared type is correct and if the method exists.

Quindi, per ignorare un metodo, possiamo usare TypeCheckingMode.SKIP :

@TypeChecked(TypeCheckingMode.SKIP) def multiply(x, y)

8. Conclusione

In questo breve tutorial, abbiamo visto come utilizzare la parola chiave def per richiamare la funzionalità dinamica del linguaggio Groovy e far sì che determini i tipi di variabili e metodi in fase di esecuzione.

Questa parola chiave può essere utile per scrivere codice dinamico e robusto.

Come al solito, le implementazioni del codice di questo tutorial sono disponibili nel progetto GitHub.