Groovy def sleutelwoord

1. Overzicht

In deze korte tutorial verkennen we het concept van de def trefwoord in Groovy. Het biedt een optionele typefunctie voor deze dynamische JVM-taal.

2. Betekenis van de def Trefwoord

De def trefwoord wordt gebruikt om een ​​ongetypeerde variabele of een functie in Groovy te definiëren, aangezien het een optioneel getypeerde taal is.

Als we niet zeker weten wat het type variabele of veld is, kunnen we gebruikmaken van def om Groovy typen te laten beslissen tijdens runtime op basis van de toegewezen waarden:

def firstName = "Samwell" def listOfCountries = ['VS', 'VK', 'FRANKRIJK', 'INDIA'] 

Hier, Voornaam zal een ... zijn Draad, en listOfCountries zal een ArrayList.

We kunnen ook de def trefwoord om het retourtype van een methode te definiëren:

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

Hier, vermenigvuldigen kan elk type object retourneren, afhankelijk van de parameters die we eraan doorgeven.

3. def Variabelen

Laten we eens kijken hoe def werkt voor variabelen.

Wanneer we gebruiken def om een ​​variabele te declareren, declareert Groovy het als een NullObject en wijs een nul waarde eraan:

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

Op het moment dat we een waarde toekennen aan de lijst, Groovy definieert het type op basis van de toegekende waarde:

list = [1,2,4] assert list instantie van ArrayList 

Laten we zeggen dat we ons variabele type dynamisch willen hebben en willen veranderen met een toewijzing:

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

We kunnen niet toewijzen Lijst of Draad aan een int getypte variabele, zoals dit genereert een runtime-uitzondering.

Dus om dit probleem op te lossen en de dynamische aard van Groovy aan te roepen, gebruiken we de def trefwoord:

def rate assert rate == null assert rate.getClass () == org.codehaus.groovy.runtime.NullObject rate = 12 assert rate instanceof Integer rate = "Niet beschikbaar" assert rate instanceof String rate = [1, 4] assert rate instantie van lijst

4. def Methoden

De def trefwoord wordt verder gebruikt om het dynamische retourtype van een methode te definiëren. Dit is handig als we verschillende soorten retourwaarden kunnen hebben voor een methode:

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

We kunnen ook gebruik maken van def om een ​​methode te definiëren zonder expliciete resultaten:

def greetMsg () {println "Hallo! Ik ben Groovy"}

5. def versus type

Laten we enkele van de best practices bespreken rond het gebruik van def.

Hoewel we beide kunnen gebruiken def en typ samen terwijl je een variabele declareert:

def int count assert count instanceof Integer

De def trefwoord zal daar overbodig zijn, dus we moeten beide gebruiken def of een type.

Bovendien zouden we moeten Vermijd te gebruiken def voor parameters zonder type in een methode.

Daarom in plaats van:

ongeldig vermenigvuldigen (def x, def y)

We zouden de voorkeur moeten geven aan:

leegte vermenigvuldigen (x, y)

Verder zouden we moeten Vermijd te gebruiken def bij het definiëren van constructeurs.

6. Groovy def versus Java Voorwerp

Zoals we de meeste functies van de def trefwoord en het gebruik ervan door middel van voorbeelden, kunnen we ons afvragen of het vergelijkbaar is met het declareren van iets met de Voorwerp klasse in Java. Ja, def kan als vergelijkbaar worden beschouwd Voorwerp:

def fullName = "Norman Lewis"

Evenzo kunnen we gebruiken Voorwerp in Java:

Object fullName = "Norman Lewis";

7. def vs. @TypeChecked

Omdat velen van ons afkomstig zouden zijn uit de wereld van strikt getypte talen, kunnen we ons afvragen hoe typecontrole tijdens het compileren in Groovy te forceren. We kunnen dit eenvoudig bereiken met behulp van de @TypeChecked annotatie.

We kunnen bijvoorbeeld gebruiken @TypeChecked over een klasse om typecontrole in te schakelen voor al zijn methoden en eigenschappen:

@TypeChecked klasse DefUnitTest breidt GroovyTestCase uit {def vermenigvuldigen (x, y) {terug x * y} int delen (int x, int y) {terug x / y}}

Hier de DefUnitTest klasse wordt type gecontroleerd, en compilatie mislukt vanwege de vermenigvuldigen methode wordt niet getypeerd. De Groovy-compiler geeft een foutmelding weer:

[Statische typecontrole] - Kan geen overeenkomende methode java.lang.Object # multiply (java.lang.Object) vinden. Controleer of het aangegeven type correct is en of de methode bestaat.

Zo, om een ​​methode te negeren, kunnen we gebruiken TypeCheckingMode.SKIP:

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

8. Conclusie

In deze korte zelfstudie hebben we gezien hoe u de def sleutelwoord om de dynamische functie van de Groovy-taal op te roepen en het de soorten variabelen en methoden tijdens runtime te laten bepalen.

Dit trefwoord kan handig zijn bij het schrijven van dynamische en robuuste code.

Zoals gewoonlijk zijn de code-implementaties van deze tutorial beschikbaar op het GitHub-project.