Scala -trekk

Å bruke grensesnitt er en veldig viktig funksjonalitet av objektorientert programmering. Scala er et så allsidig språk at det lar deg oppnå den samme funksjonaliteten ved å bruke trekk. Derfor vil denne guiden være dedikert til å bruke egenskaper i Scala -programmeringsspråket i Ubuntu 20.04.

Hva er formålet med egenskaper i Scala -programmeringsspråket?

Vi har allerede nevnt at trekkene i Scala tjener samme formål som grensesnittene i Java. Det betyr at du har lov til å lage et generisk grensesnitt ved hjelp av Scala -egenskaper, og klassene dine vil få lov til å utvide denne egenskapen ved å implementere de ønskede metodene. Dessuten er en interessant ting med Scala-egenskapene at du står fritt til å bruke både abstrakte og ikke-abstrakte metoder innenfor en egenskap. Imidlertid, hvis du bruker en ikke-abstrakt metode innenfor en egenskap, trenger du ikke å gi implementeringen i klassen som vil utvide denne egenskapen.

Bruke trekkene i Scala:

For å utnytte egenskapene i Scala i Ubuntu 20.04, må du lese gjennom følgende tre eksempler:

Eksempel 1: Bruke egenskaper med bare abstrakte metoder i Scala:

På Scala-programmeringsspråket kan vi ha både abstrakte og ikke-abstrakte metoder innenfor en egenskap. I dette eksemplet vil vi imidlertid bare ha abstrakte metoder innenfor vår definerte egenskap og se hvordan egenskaper fungerer i Scala -programmeringsspråket. Du må se på koden som er vist nedenfor for å forstå dette:

Vi har først definert en egenskap som heter "kategori" i denne skalakoden. Innenfor denne egenskapen har vi erklært to abstrakte metoder ved hjelp av "def" nøkkelordet med navnene "ansatt" og "ansatt_age". Derfor siden dette er abstrakte metoder, vil vi implementere dem i klassen som vil utvide denne egenskapen. Deretter har vi designet en klasse som heter "ansatt" og har brukt nøkkelordet "Extends" for å utvide egenskapen som er opprettet ovenfor fra denne klassen. Etter det har vi først implementert de abstrakte metodene for vår egenskap i denne klassen. Deretter har vi laget en annen metode som heter “Employee_name” i denne klassen.

Endelig har vi brukt "Objekt" nøkkelord for å lage vår sjåførklasse som heter "Trait". Innenfor denne klassen har vi vår "Main ()" -funksjon der vi har laget en ny forekomst av vår "ansatt" -klasse som heter "EMP". Deretter har vi suksessivt kalt alle funksjonene til denne klassen (de som er definert i klassen og også de som utvides fra egenskapen) ved å bruke forekomsten av denne klassen.

Dette Scala -skriptet kan samles ved å bruke kommandoen gitt nedenfor:

$ Scalac -egenskap.Scala

Etter en vellykket samling, kan dette skriptet utføres med følgende kommando:

$ Scala Trait

Du kan være vitne til fra utdataene nedenfor at vi har implementert en klasse som strekker seg fra en Scala -egenskap og dens produksjon viste seg å være nøyaktig som ment.

Eksempel 2: Bruke egenskaper med både abstrakte og ikke-abstrakte metoder i Scala:

I dette eksemplet vil vi bruke både de abstrakte og ikke-abstrakte metodene i Scala. Det betyr at vi vil implementere noen metoder innenfor egenskapen og vil implementere de andre i klassen som vil utvide denne egenskapen. På denne måten vil vi finne ut hvilken innvirkning det etterlater på produksjonen vår. Derfor vil vi bruke det samme eksemplet som vi har implementert ovenfor som en grunnlinje med små modifikasjoner. Det eksakte Scala -programmet er som følger:

Forskjellen mellom våre første og andre eksempler er at vi i dette har implementert "Employee_age ()" -metoden innenfor vår egenskap. Derfor ble det en ikke-abstrakt metode. På den annen side har vi implementert "ansatt ()" -metoden i klassen vår som utvidet vår egenskap. Med andre ord, vi har bare definert signaturen til denne funksjonen innenfor vår egenskap som gjorde det til en abstrakt funksjon. Resten av koden er den samme som vårt første eksempel.

For å se om denne modifiseringen etterlot noen innvirkning på output eller ikke, samlet vi og utførte dette skriptet. Du kan se på utdataene som vises nedenfor og bekrefte at denne utgangen er den samme som vårt første eksempel. Det innebærer at uansett om du bruker de abstrakte eller ikke-abstrakte metodene innenfor Scala-egenskaper, vil produksjonen din forbli den samme.

Eksempel nr. 3: Bruke flere egenskaper i Scala:

En Scala -klasse kan også utvide flere egenskaper om gangen. Følgende eksempel skildrer dette:

Igjen har vi brukt det samme eksemplet som en grunnlinje. Den eneste forskjellen mellom våre andre og tredje eksempler er at vi i denne har skapt en annen egenskap som heter "kvalifisering" og har implementert en ikke-abstrakt metode innenfor denne egenskapen. Deretter, mens vi utvider klassen vår fra disse egenskapene, har vi brukt nøkkelordet "utvider" med den første egenskapen og har brukt "med" nøkkelordet mellom navnene på de to egenskapene. Tilsvarende, hvis du har mer enn to egenskaper å utvide klassen fra, vil du skille navnene på alle egenskapene ved å bruke "med" nøkkelordet. I vår "Main ()" -funksjon har vi også kalt funksjonen til den nye egenskapen som vi har laget i dette eksemplet.

Bildet nedenfor presenterer utgangen fra dette Scala -skriptet, som bekrefter at en klasse kan utvide flere egenskaper samtidig.

Konklusjon:

Ved hjelp av denne opplæringen ønsket vi å gi deg en kort oversikt over arbeidene med trekkene i Scala i Ubuntu 20.04. For det delte vi først med deg hovedformålet med å bruke trekkene i Scala ved å fremheve deres nære likhet med grensesnittene i Java. Deretter delte vi hvordan disse egenskapene kan brukes med abstrakte og ikke-abstrakte metoder. Til slutt diskuterte vi tre eksempler som brukte scala -trekk effektivt. Vi har prøvd å holde disse eksemplene ekstremt enkle og enkle, slik at du raskt kan ta forestillingen om å bruke Scala -trekk.