Indhold

• Kotlin vs Java, den senere tilbyder en mere kortfattet kode - uden findViewByIds
• Kotlin er som standard ikke-sikkert
• Udvidelsesfunktioner
• Coroutines er førsteklasses borgere
• Der er ingen markerede undtagelser
• Indfødt støtte til delegation
• Dataklasser
• Smart casts
• Support til konstruktører
• Ingen støtte til implicit udvidede konverteringer
• Annotationsbehandlingsbiblioteker med Kotlin
• Udskiftelighed med Java
• Afslutter

Java er muligvis stadig det første programmeringssprog, der dukker op, når du tænker på Android, men du gør det ikke har at bruge Java til Android-udvikling. Faktisk er Kotlin nu Googlesforetrukkenofficielt sprog til Android!

For at lære mere om Java skal du få et gratis introduktion til Java-kursus på Make Android Apps.

I dag leveres Android Studio med indbygget Kotlin-support, så det at oprette et Android-projekt, der forstår Kotlin-kode, er lige så let som at markere et afkrydsningsfelt i Android Stores guide til projektoprettelse. Støtten er vokset for muligheden for overarbejde, til det punkt, at denne beslutning nu hovedsageligt kommer til at foretrække.

Men hvis du foretager overgangen fra Java til Kotlin, hvad får du præcis? Hvilke funktioner har Kotlin, at Java ikke har det, og omvendt?

I denne artikel skal vi se på alle de store forskelle mellem Kotlin og Java.

Kotlin vs Java, den senere tilbyder en mere kortfattet kode - uden findViewByIds

Hvis du sammenligner en Kotlin-klasse og en Java-klasse, der udfører det samme arbejde, vil Kotlin-klassen generelt være meget mere kortfattet, men der er især et område, hvor Kotlin alvorligt kan reducere mængden af ​​kedelpladen, du har brug for at skrive: findViewByIds.

Kotlin Android-udvidelser giver dig mulighed for at importere en henvisning til en visning i din aktivitetsfil, på hvilket tidspunkt du vil være i stand til at arbejde med denne visning, som om den var en del af aktiviteten. Resultatet? Du behøver aldrig at skrive en anden findViewById-metode igen!

Inden du kan bruge disse udvidelser, skal du tilføje en ekstra plugin til din build-graded-fil på modulniveau (anvend plugin: 'kotlin-android-extensions'), men efter det er du klar til at begynde at importere Views, for eksempel, hvis din Activity_main.xml-fil indeholdt en TextView med ID textView, vil du tilføje følgende til din aktivitet:

import kotlinx.android.synthetic.main.activity_main.textView

Du kan derefter få adgang til denne TextView ved hjælp af bare dens ID:

textView.setText ("Hej verden")

Dette er meget mere kortfattet end Java-ækvivalent:

TextView text = (TextView) findViewById (R.id.textView); text.setText ("Hello World");

Kotlin er som standard ikke-sikkert

NullPointerExceptions er en enorm kilde til frustration for Java-udviklere. Java giver dig mulighed for at tildele null til en hvilken som helst variabel, men hvis du prøver at bruge en objektreference, der har en nullværdi, skal du afstive dig selv for at støde på en NullPointerException!

Læs også: Kotiln til Android-introduktion

I Kotlin er alle typer ikke-nullable (ikke i stand til at have en nulværdi) som standard. Hvis du prøver at tildele eller returnere null i din Kotlin-kode, mislykkes den på kompileringstidspunktet, så ingen af ​​følgende linjer vil blive kompileret:

val navn: String = null

sjov getName (): String = null

hvis du virkelig ønsker at tildele en nullværdi til en variabel i Kotlin, skal du eksplicit markere den variabel som nullable ved at tilføje et spørgsmålstegn efter typen:

val nummer: Int? = null

Dette gør det næsten umuligt at støde på NullPointerExceptions i Kotlin - faktisk, hvis du støder på denne undtagelse, er chancerne sandsynligvis, fordi du eksplicit bad Kotlin om at kaste en, eller NullPointerException stammer fra ekstern Java-kode.

Udvidelsesfunktioner

Kotlin giver udviklere muligheden for at udvide en klasse med ny funktionalitet, hvilket er ideelt, hvis der er en klasse, som du altid mente manglede en vigtig metode!

Disse 'udvidelsesfunktioner' er ikke tilgængelige i Java, selvom de er tilgængelige på andre programmeringssprog, som du kan bruge til Android-udvikling, f.eks. C #.

Læs næste: Java-tutorial til begyndere

Du opretter en udvidelsesfunktion ved at præfikse navnet på den klasse, du vil udvide (f.eks. 'Streng') til navnet på den funktion, du opretter ('styleString') for eksempel:

fun String.styleString (): String {// Style strengen og returner den derefter //}

Du kan derefter ringe til denne funktion i tilfælde af den udvidede klasse via. notation, som om det var en del af denne klasse:

myString.styleString ()

Coroutines er førsteklasses borgere

Hver gang du påbegynder en langvarig operation, f.eks. Netværk I / O eller CPU-intensivt arbejde, blokeres den opkaldstråd, indtil operationen er afsluttet. Da Android som standard er enkeltrådet, så snart du blokerer for hovedtråden, fryser din app UI, og det forbliver ikke svarende, indtil handlingen er afsluttet.

I Java har løsningen traditionelt været at oprette en baggrundstråd, hvor du kan udføre dette intensive eller langvarige arbejde, men at styre flere tråde kan føre til kompleks, fejlbenyttet kode, og at oprette en ny tråd er en dyr operation.

Mens du kan oprette yderligere tråde i Kotlin, kan du også bruge koroutiner. Coroutines udfører langvarige og intensive opgaver ved at afbryde udførelsen på et bestemt punkt uden at blokere tråden og derefter genoptage denne funktion på et senere punkt, muligvis på en anden tråd. Dette giver dig mulighed for at oprette ikke-blokerende asynkron kode, der udseende synkron, og er derfor mere klar, kortfattet og menneskelig læsbar. Coroutines er også stakløse, så de har en lavere hukommelsesforbrug sammenlignet med tråde, og de åbner døren til yderligere stilarter af asynkron ikke-blokerende programmering, såsom async / venter.

Der er ingen markerede undtagelser

Kotlin har ikke kontrollerede undtagelser, så du behøver ikke at fange eller erklære nogen undtagelser.

Om dette er noget, der trækker dig til Kotlin, eller får dig til at ønske at holde fast ved Java, afhænger af din mening om kontrollerede undtagelser, da dette er en funktion, der deler udviklerfællesskabet. Hvis du er træt af at prøve / fange blokke, der sputter din Java-kode, vil du være tilfreds med denne mangel, men hvis du finder ud af, at markerede undtagelser tilskynder dig til at tænke på gendannelse af fejl og i sidste ende skubbe dig mod at skabe mere robust kode, så er det mere sandsynligt, at du ser dette som et område, hvor Java har kanten over Kotlin.

Indfødt støtte til delegation

Kotlin understøtter, i modsætning til Java, designmønsteret "sammensætning over arv" via førsteklasses delegering (undertiden kendt som implicit delegation). Delegation er, hvor et modtagende objekt delegerer operationer til et andet delegeret objekt, som er et hjælpeobjekt med den oprindelige kontekst.

Kotlins klassedelegering er et alternativ til arv, der gør det muligt at bruge flere arv. I mellemtiden hjælper Kotlins delegerede egenskaber med at forhindre duplikering af kode, for eksempel hvis du har brug for at genbruge den samme kode til flere egenskaber 'brev og sættere, kan du pakke denne kode ud i en delegeret egenskab. Ejendomsdelegaten skal definere getValue-operatørfunktionen og eventuelt setValue-operatøren:

klasse Delegat {operator fun getValue (...) ... ... ...} operator fun setValue (...) ... ... ...}}

Når du opretter en egenskab, kan du derefter erklære, at getter- og setterfunktionerne for denne bestemte egenskab håndteres af en anden klasse:

klasse MyClass {var property: String by Delegate ()}

Dataklasser

Det er ikke usædvanligt, at et projekt har flere klasser, der ikke gør andet end at have data. I Java finder du dig selv at skrive en masse kedelplade-kode til disse klasser, selvom klasserne selv har meget lidt funktionalitet. Typisk er du nødt til at definere en konstruktør, felter til lagring af data, getter og setterfunktioner for hvert felt plus hashCode (), lig (() og toString () -funktioner.

I Kotlin, hvis du inkluderer 'data'-nøgleordet i din klassedefinition, udfører kompilatoren alt dette arbejde for dig, inklusive generering af alle de nødvendige getters og sættere:

dataklasse Dato (var måned: String, var dag: Int)

Smart casts

I Java skal du ofte kontrollere type og derefter kaste et objekt i situationer, hvor det allerede er klart, at objektet kan støbes.

Kotlins smarte casts kan håndtere disse overflødige casts til dig, så du behøver ikke at kaste inde i en erklæring, hvis du allerede har kontrolleret det med Kotlins 'is' -operatør. For eksempel ved kompilatoren, at følgende rollebesætning er sikker:

if (hej er streng) {printString (hej)}

Support til konstruktører

I modsætning til Java kan en Kotlin-klasse have en primær konstruktør og en eller flere sekundære konstruktører, som du opretter ved at inkludere dem i din klassedeklaration:

klasse MainActivity-konstruktør (firstName: String) {}

Ingen støtte til implicit udvidede konverteringer

Kotlin understøtter ikke implicit udvidelse af konverteringer til tal, så mindre typer konverteres ikke implicit til større typer. Hvis du vil tildele en værdi af typen Byte til en Int-variabel i Kotlin, skal du udføre en eksplicit konvertering, mens Java har understøttelse af implicitte konverteringer.

Annotationsbehandlingsbiblioteker med Kotlin

Kotlin understøtter alle eksisterende Java-rammer og -biblioteker, inklusive avancerede rammer, der er afhængige af annotationsbehandling, selvom nogle Java-biblioteker allerede leverer Kotlin-udvidelser, såsom RxKotlin.

Hvis du vil bruge et Java-bibliotek, der er afhængig af annotationsbehandling, er det lidt anderledes at tilføje det til dit Kotlin-projekt, da du bliver nødt til at specificere afhængigheden ved hjælp af Kotlin-kapt plugin, og brug derefter Kotlin Annotation-behandlingsværktøjet (kapt) i stedet for annotationProcessor. For eksempel:

// Anvend plugin // anvend plugin: kotlin-kapt // Tilføj de respektive afhængigheder vha. Kapt-konfigurationen // afhængigheder {kapt "com.google.dagger: dagger-compiler: $ dagger-version" ... ... ...}

Udskiftelighed med Java

Når du diskuterer, om du skal bruge Kotlin eller Java til Android-udvikling, skal du være opmærksom på, at der er en tredje mulighed: Brug begge dele. På trods af alle forskelle mellem de to sprog er Java og Kotlin 100% interoperable. Du kan kalde Kotlin-kode fra Java, og du kan kalde Java-kode fra Kotlin, så det er muligt at have Kotlin- og Java-klasser side om side inden for det samme projekt, og alt vil stadig samles.

Denne fleksibilitet til at flytte mellem de to sprog er nyttig, når du kommer i gang med Kotlin, da det giver dig mulighed for at introducere Kotlin i et eksisterende projekt trinvist, men du foretrækker også at bruge begge sprog permanent. Der kan for eksempel være visse funktioner, som du foretrækker at skrive i Kotlin, og visse funktioner, som du har lettere for at skrive i Java. Da Kotlin og Java begge kompilerer til bytecode, vil dine slutbrugere ikke være i stand til at fortælle, hvor din Java-kode slutter, og Kotlin-koden begynder, så der er ingen grund til, at du ikke kan frigive en app, der består af Java og Kotlin-kode.

Hvis du ønsker at prøve Kotlin selv, så er du, så længe du har Android Studio 3.0-forhåndsvisning eller nyere installeret, nogle få måder, du kan komme i gang på:

• Opret et nyt Android Studio-projekt. Den nemmeste metode er at oprette et nyt projekt og markere afkrydsningsfeltet 'Inkluder Kotlin support' fra guiden til projektoprettelse.

• Føj en Kotlin-klasse til et eksisterende bibliotek. Kontrol-klik på det pågældende bibliotek, og vælg derefter 'File> New> Kotlin File / Class.' Android Studio viser et banner, der beder dig om at konfigurere dit projekt til at understøtte Kotlin; Klik på linket 'Konfigurer' og følg instruktionerne på skærmen.

• Konverter eksisterende Java-filer til Kotlin. Du kan køre en hvilken som helst Java-fil gennem en Kotlin-konverter ved at kontrollere-klikke på filen og vælge 'Kode> Konverter Java-fil til Kotlin-fil.'

Afslutter

Som du kan se, er der masser af gode grunde til at foretrække Kotlin frem for Java, men der er et par områder, hvor Java har overhånden. Måske mest bemærkelsesværdigt: mange Android-udviklere er simpelthen mere fortrolige med Java på dette tidspunkt. Det er sandsynligt, at Kotlin vs Java-debatten ikke afvikles når som helst, hvor begge har deres egne fordele. Så skal du skifte til Kotlin, eller føler du, at Java stadig er den bedste mulighed til Android-udvikling?

Læs næste: En introduktion til Java-syntaks til Android-udvikling