Share
Hvis du er en erfaren Android-applikasjonsutvikler, er du sannsynligvis vant til Java-oversikten. Som et resultat kan du finne Kotlins konsise syntaks, som er rettet mot funksjonelle programmerere, litt foruroligende.
Et vanlig problem nybegynnere møter mens du lærer Kotlin, er å forstå hvordan det forventer at du skal jobbe med Java-grensesnitt som inneholder en enkelt metode. Slike grensesnitt er allestedsnærværende i Android-verdenen og kalles ofte SAM-grensesnitt, hvor SAM er kort for Single Abstract Method.
I denne korte opplæringen lærer du alt du trenger å vite for å kunne bruke Javas SAM-grensesnitt i Kotlin-koden.
Når du vil bruke et Java-grensesnitt som inneholder en enkelt metode i Kotlin-koden, trenger du ikke manuelt å opprette en anonym klasse som implementerer den. I stedet kan du bruke et lambda-uttrykk. Takket være en prosess som kalles SAM-konvertering, kan Kotlin gjennomsiktig omdanne et lambda-uttrykk hvis signatur samsvarer med grensesnittets eneste metode i en forekomst av en anonym klasse som implementerer grensesnittet.
For eksempel, vurder følgende Java-grensesnitt med én metode:
offentlig grensesnitt adder offentlig tomt legg til (int a, int b);
En naiv og Java 7-lignende tilnærming til å bruke det ovennevnte grensesnittet vil innebære å jobbe med en gjenstand uttrykk og vil se slik ut:
// Opprette forekomst av en anonym klasse // ved hjelp av objektet søkeord val adder = objekt: Adder overstyre morsomt tillegg (a: Int, b: Int): Int return a + b
Det er mye unødvendig kode, som heller ikke er veldig lesbar. Ved å utnytte Kotlins SAM-konverteringsfasilitet, kan du imidlertid skrive følgende tilsvarende kode i stedet:
// Opprette forekomst ved hjelp av en lambda val adder = Adder a, b -> a + b
Som du ser, har vi nå erstattet den anonyme klassen med et kort lambda-uttrykk, som er prefiks med navnet på grensesnittet. Merk at antallet argumenter som lambda-uttrykket tar, er lik antall parametere i signaturen til grensesnittets metode.
Mens du arbeider med Java-klasser som har metoder som tar SAM-typer som deres argumenter, kan du forenkle ovenfor syntaksen ytterligere. For eksempel, vurder følgende Java-klasse, som inneholder en metode som forventer en objekt som implementerer Adder grensesnitt:
Accentsconagua
offentlig klasse kalkulator private adder adder; Offentlig tomt settAdder (Adder adder) this.adder = adder; offentlig tomt legg til (int a, int b) Log.d ("CALCULATOR", "Sum er" + adder.add (a, b)); I Kotlin-koden kan du nå direkte sende et lambda-uttrykk til setAdder () metode uten å prefikse den med navnet på Adder grensesnitt.
val kalkulator = Kalkulator () kalkulator.setAdder (a, b -> a + b)
Det er verdt å merke seg at mens du ringer en metode som tar en SAM-type som eneste argument, er du fri til å hoppe over parentesen for å gjøre koden enda mer konsistent.
calculator.setAdder a, b -> a + b
Hvis du tror at lambda-uttrykkene er forvirrende, har jeg gode nyheter for deg: SAM-konverteringer fungerer også bra med vanlige funksjoner. For eksempel, vurder følgende funksjon hvis signatur samsvarer med den av Adder grensesnittets metode:
morsom myCustomAdd (a: Int, b: Int): Int = if (a + b < 100) -1 else if (a+b < 200) 0 else a+b
Kotlin lar deg passere direkte myCustomAdd () fungere som et argument til setAdder () metode av Kalkulator klasse. Ikke glem å referere til metoden ved hjelp av :: operatør. Dette er hvordan:
calculator.setAdder (dette :: myCustomAdd)
den variabelMange ganger inneholder SAM-grensesnitt en-parameter metoder. En enparametermetode, som navnet antyder, har bare en parameter i signaturen. Mens du arbeider med slike grensesnitt, tillater Kotlin deg å utelate parameteren i lambda-uttrykkets signatur og bruke en implisitt variabel som kalles den i uttrykkets kropp. For å gjøre ting klarere, bør du vurdere følgende Java-grensesnitt:
offentlige grensesnitt Doubler public int doubleIt (int nummer);
Mens du bruker Dobbel grensesnitt i Kotlin-koden, trenger du ikke å nevne eksplisitt Nummer parameter i lambda-uttrykkets signatur. I stedet kan du bare referere til det som den.
// Dette lambda-uttrykket bruker det-variabelen val doubler1 = Doubler 2 * it // svarer til dette vanlige lambda-uttrykket val doubler2 = Doubler tall -> 2 * nummer
Som Java-utvikler kan du være tilbøyelig til å lage SAM-grensesnitt i Kotlin. Å gjøre det er imidlertid vanligvis ikke en god ide. Hvis du lager et SAM-grensesnitt i Kotlin, eller oppretter en Kotlin-metode som forventer en objekt som implementerer et SAM-grensesnitt som et argument, vil SAM-konverteringsfasiliteten ikke være tilgjengelig for deg. SAM-konvertering er en Java-interoperabilitetsfunksjon og er begrenset til Java kun klasser og grensesnitt.
Fordi Kotlin støtter høyere rekkefølgefunksjoner-funksjoner som kan ta andre funksjoner som argumenter, trenger du aldri å lage SAM-grensesnitt i den. For eksempel, hvis Kalkulator Klassen er omskrevet i Kotlin, dens setAdder () Metoden kan skrives slik at den direkte tar en funksjon som argument, i stedet for et objekt som implementerer Adder grensesnitt.
klassen kalkulator var adder: (a: Int, b: Int) -> Int = a, b -> 0 // Standard implementering // Setter er tilgjengelig som standard morsomt tillegg (a: Int, b: Int) Log.d ("CALCULATOR", "Sum er" + adder (a, b))Mens du bruker den ovennevnte klassen, kan du angi huggorm til en funksjon eller et lambda-uttrykk ved hjelp av = operatør. Følgende kode viser deg hvordan:
valkalkulator = Kalkulator () calculator.adder = dette :: myCustomAdd // ELLER calculator.adder = a, b -> a + b
Android APIs er i stor grad skrevet i Java, og mange bruker SAM-grensesnitt i stor utstrekning. Det samme kan sies om de fleste tredjepartsbiblioteker også. Ved å bruke teknikkene du lærte i denne opplæringen, kan du jobbe med dem i Kotlin-koden din på en kortfattet og lettlest måte.
Hvis du vil vite mer om Kotlins Java-interoperabilitetsfunksjoner, kan du se den offisielle dokumentasjonen. Og sjekk ut noen av våre andre opplæringsprogrammer på Android app utvikling!
