streamalism.org

1. Oversigt

I denne vejledning undersøger vi begrebet træk i Groovy. De blev introduceret i Groovy 2.3-udgivelsen.

2. Hvad er træk?

Egenskaber er genanvendelige komponenter, der repræsenterer et sæt metoder eller adfærd, som vi kan bruge til at udvide funktionaliteten i flere klasser.

Af denne grund, de betragtes som grænseflader, der bærer både standardimplementeringer og tilstand. Alle træk defineres ved hjælp af egenskab nøgleord.

3. Metoder

Erklæring om en metode i en egenskab svarer til at erklære enhver regelmæssig metode i en klasse. Vi kan dog ikke erklære beskyttede eller pakke-private metoder i en egenskab.

Lad os se, hvordan offentlige og private metoder implementeres.

3.1. Offentlige metoder

For at starte undersøger vi hvordan offentlig metoder implementeres i en egenskab.

Lad os oprette en egenskab som hedder UserTrait og en offentligsig hej metode:

træk UserTrait {String sayHello () {returner "Hej!" }}

Derefter opretter vi en Medarbejder klasse, som implementerer UserTrait:

klasse Medarbejder implementerer UserTrait {}

Lad os nu oprette en test for at bekræfte, at en Medarbejder instans kan få adgang sige Hej metode til UserTrait:

def 'Skal returnere msg-streng, når du bruger Employee.sayHello-metoden leveret af brugeregenskab' () {når: def msg = medarbejder.sayHello () så: msg msg forekomst af streng-påstand msg == "Hej!" }

3.2. Private metoder

Vi kan også oprette en privat metode i en egenskab og henvise til det i en anden offentlig metode.

Lad os se implementeringen af ​​koden i UserTrait:

private String greetingMessage () {return 'Hej, fra en privat metode!' } Strenghilsen () {def msg = greetingMessage () println msg return msg} 

Bemærk, at hvis vi får adgang til privat metode i implementeringsklassen, kaster den en MissingMethodException:

def 'Bør returnere MissingMethodException, når du bruger Employee.greetingMessage-metoden' () {når: def undtagelse, prøv {medarbejder.greetingMessage ()} fangst (Undtagelse e) {undtagelse = e} derefter: undtagelse undtagelse forekomst af groovy.lang.MissingMethodException hævder undtagelse. meddelelse == "Ingen signatur af metode: com.baeldung.traits.Employee.greetingMessage ()" + "kan anvendes til argumenttyper: () værdier: []"}

I en egenskab, en privat metode kan være afgørende for enhver implementering, der ikke bør tilsidesættes af nogen klasse, selvom det kræves af andre offentlige metoder.

3.3. Abstrakte metoder

EN egenskab kan også indeholde abstrakt metoder, som derefter kan implementeres i en anden klasse:

træk UserTrait {abstrakt String name () String showName () {return "Hej, $ {name ()}!" }}

klasse Medarbejder implementerer UserTrait {String name () {return 'Bob'}} 

3.4. Tilsidesættelse af standardmetoder

Normalt er en egenskab indeholder standardimplementeringer af dens offentlige metoder, men vi kan tilsidesætte dem i implementeringsklassen:

træk SpeakingTrait {String speak () {return "Speaking !!" }} 

klasse Hundredskaber SpeakingTrait {String speak () {return "Bow Bow !!" }} 

Egenskaber understøtter ikke beskyttet og privat rækkevidde.

4. det her Nøgleord

Opførelsen af det her nøgleord svarer til det i Java. Vi kan overveje egenskab som en super klasse.

For eksempel opretter vi en metode, der vender tilbage det her i en egenskab:

træk UserTrait {def self () {return this}}

5. Grænseflader

EN egenskab kan også implementere grænseflader, ligesom almindelige klasser gør.

Lad os oprette en interface og implementere det i en egenskab:

grænseflade Human {String lastName ()}

træk UserTrait implementerer Human {String showLastName () {return "Hej, $ {lastName ()}!" }}

Lad os nu implementere abstrakt metode til interface i implementeringsklassen:

klasse Medarbejder implementerer UserTrait {String lastName () {return "Marley"}}

6. Egenskaber

Vi kan tilføje egenskaber til en egenskab ligesom vi ville i enhver almindelig klasse:

træk UserTrait implementerer Human {String email String address}

7. Udvidelse af træk

Svarende til en almindelig Groovy klasse, a egenskab kan udvide en anden egenskab bruger strækker sig nøgleord:

træk WheelTrait {int noOfWheels} træk VehicleTrait udvider WheelTrait {String showWheels () {return "Num of Wheels $ noOfWheels"}} klasse Bilværktøjer VehicleTrait {}

Vi kan også udvide flere træk med redskaber klausul:

træk AddressTrait {String residentialAddress} træk EmailTrait {String email} træk Person implementerer AddressTrait, EmailTrait {}

8. Flere arvskonflikter

Når en klasse implementerer to eller flere træk, der har metoder med den samme signatur, skal vi vide, hvordan man løser konflikterne. Lad os se på, hvordan Groovy løser sådanne konflikter som standard, samt en måde, hvorpå vi kan tilsidesætte standardopløsningen.

8.1. Standard konfliktløsning

Som standard er metoden fra sidst deklareret egenskab i redskaber klausul afhentes.

Derfor hjælper træk os med at implementere flere arv uden at støde på diamantproblemet.

Lad os først oprette to træk med en metode, der har den samme signatur:

træk WalkingTrait {String basicAbility () {return "Walking !!" }} træk SpeakingTrait {String basicAbility () {return "Speaking !!" }} 

Lad os derefter skrive en klasse, der implementerer begge træk:

klasse Hund implementerer WalkingTrait, SpeakingTrait {} 

Fordi TalendeTrait erklæres sidst, dens grundlæggende evne Metodeimplementering vil blive hentet som standard i Hund klasse.

8.2. Eksplicit konfliktløsning

Hvis vi ikke bare ønsker at tage standardkonfliktløsningen fra sproget, kan vi tilsidesætte den vedeksplicit vælge hvilken metode der skal ringes op ved hjælp af egenskab. super.metode reference.

Lad os for eksempel tilføje en anden metode med den samme signatur til vores to træk:

String speakAndWalk () {return "Gå og tal !!" }

String speakAndWalk () {return "Tal og gå !!" }

Lad os nu tilsidesætte standardopløsningen for flere arvskonflikter i vores Hund klasse ved hjælp af super nøgleord:

klasse Hund implementerer WalkingTrait, SpeakingTrait {String speakAndWalk () {WalkingTrait.super.speakAndWalk ()}}

9. Implementering af træk ved kørselstid

At implementere en egenskab dynamisk kan vi brug som nøgleord for at tvinge et objekt til en egenskab ved kørselstid.

Lad os f.eks. Oprette en AnimalTrait med grundlæggende adfærd metode:

træk AnimalTrait {String basicBehavior () {return "Animalistic !!" }}

For at implementere flere træk på én gang kan vi bruge medTraits metode i stedet for som nøgleord:

def dog = new Dog () def dogWithTrait = dog.withTraits SpeakingTrait, WalkingTrait, AnimalTrait

10. Konklusion

I denne artikel har vi set, hvordan man opretter træk i Groovy og udforsket nogle af deres nyttige funktioner.

EN egenskab er en virkelig effektiv måde at tilføje fælles implementeringer og funktionaliteter i vores klasser. Derudover giver det os mulighed for at minimere overflødig kode og gør vedligeholdelse af kode lettere.

Som normalt er kodeimplementeringerne og enhedstestene til denne artikel tilgængelige på GitHub.