Groovy def Keyword

1. Übersicht

In diesem kurzen Tutorial werden wir das Konzept des Schlüsselworts def in Groovy untersuchen. Es bietet eine optionale Eingabefunktion für diese dynamische JVM-Sprache.

2. Bedeutung des def- Schlüsselworts

Das Schlüsselwort def wird verwendet, um eine untypisierte Variable oder eine Funktion in Groovy zu definieren, da es sich um eine optional typisierte Sprache handelt.

Wenn wir uns über den Typ einer Variablen oder eines Felds nicht sicher sind, können wir def nutzen , damit Groovy zur Laufzeit anhand der zugewiesenen Werte über Typen entscheidet:

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

Hier ist firstName ein String und listOfCountries eine ArrayList .

Wir können auch das Schlüsselwort def verwenden , um den Rückgabetyp einer Methode zu definieren:

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

Hier kann Multiplizieren jeden Objekttyp zurückgeben, abhängig von den Parametern, die wir an ihn übergeben.

3. def Variablen

Lassen Sie uns verstehen, wie def für Variablen funktioniert.

Wenn wir def verwenden , um eine Variable zu deklarieren, deklariert Groovy sie als NullObject und weist ihr einen Nullwert zu:

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

Sobald wir der Liste einen Wert zuweisen , definiert Groovy seinen Typ basierend auf dem zugewiesenen Wert:

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

Nehmen wir an, wir möchten unseren Variablentyp dynamisch gestalten und mit einer Zuweisung ändern:

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

Wir können einer int- typisierten Variablen keine Liste oder Zeichenfolge zuweisen , da dies eine Laufzeitausnahme auslöst .

Um dieses Problem zu lösen und die Dynamik von Groovy aufzurufen, verwenden wir das Schlüsselwort 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. def Methoden

Das Schlüsselwort def wird ferner verwendet, um den dynamischen Rückgabetyp einer Methode zu definieren. Dies ist praktisch, wenn wir für eine Methode verschiedene Arten von Rückgabewerten haben können:

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

Wir können def auch verwenden , um eine Methode ohne explizite Rückgabe zu definieren:

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

5. def vs. Type

Lassen Sie uns einige der Best Practices für die Verwendung von def diskutieren .

Obwohl wir sowohl def als auch type zusammen verwenden können, während wir eine Variable deklarieren:

def int count assert count instanceof Integer

Das Schlüsselwort def ist dort redundant, daher sollten wir entweder def oder einen Typ verwenden.

Außerdem sollten wir vermeiden, def für untypisierte Parameter in einer Methode zu verwenden.

Daher anstelle von:

void multiply(def x, def y)

Wir sollten es vorziehen:

void multiply(x, y)

Darüber hinaus sollten wir vermeiden, def beim Definieren von Konstruktoren zu verwenden.

6. Groovy def vs. Java Object

Da wir die meisten Funktionen des Schlüsselworts def und seine Verwendung anhand von Beispielen gesehen haben, fragen wir uns möglicherweise, ob es ähnlich ist, etwas mit der Object- Klasse in Java zu deklarieren . Ja, def kann als ähnlich wie Object angesehen werden :

def fullName = "Norman Lewis"

Ebenso können wir Object in Java verwenden:

Object fullName = "Norman Lewis";

7. def vs. @TypeChecked

Da viele von uns aus der Welt der streng typisierten Sprachen stammen, fragen wir uns möglicherweise, wie die Typüberprüfung zur Kompilierungszeit in Groovy erzwungen werden kann . Dies können wir leicht mit der Annotation @TypeChecked erreichen .

Beispielsweise können wir @TypeChecked für eine Klasse verwenden, um die Typprüfung für alle Methoden und Eigenschaften zu aktivieren:

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

Hier wird die DefUnitTest- Klasse typgeprüft , und die Kompilierung schlägt fehl, da die Multiplikationsmethode nicht typisiert ist . Der Groovy-Compiler zeigt einen Fehler an:

[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.

Also, ein Verfahren zu ignorieren, können wir verwenden TypeCheckingMode.SKIP :

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

8. Fazit

In diesem kurzen Tutorial haben wir gesehen, wie Sie mit dem Schlüsselwort def die dynamische Funktion der Groovy-Sprache aufrufen und zur Laufzeit die Arten von Variablen und Methoden bestimmen lassen.

Dieses Schlüsselwort kann beim Schreiben von dynamischem und robustem Code hilfreich sein.

Wie üblich sind die Code-Implementierungen dieses Tutorials im GitHub-Projekt verfügbar.