Vad är Kotlin? Java-alternativet förklaras

Kotlin är ett allmänt ändamål, gratis, öppen källkod, statiskt skrivet "pragmatiskt" programmeringsspråk som ursprungligen utformades för JVM (Java Virtual Machine) och Android som kombinerar objektorienterade och funktionella programmeringsfunktioner. Det är fokuserat på interoperabilitet, säkerhet, tydlighet och verktygsstöd. Versioner av Kotlin inriktad på JavaScript ES5.1 och inbyggd kod (med LLVM) för ett antal processorer är också i produktion.

Kotlin har sitt ursprung i JetBrains, företaget bakom IntelliJ IDEA, 2010, och har varit öppen källkod sedan 2012. Kotlin-teamet har för närvarande mer än 90 heltidsmedlemmar från JetBrains, och Kotlin-projektet på GitHub har mer än 300 bidragsgivare. JetBrains använder Kotlin i många av sina produkter inklusive dess flaggskepp IntelliJ IDEA.

Kotlin som ett mer koncist Java-språk

Vid första anblicken ser Kotlin ut som en mer kortfattad och strömlinjeformad version av Java. Tänk på skärmdumpen ovan, där jag automatiskt har konverterat ett Java-kodprov (till vänster) till Kotlin. Lägg märke till att den tanklösa upprepningen som är förenad med att starta Java-variabler har försvunnit. Java-idiomet

StringBuilder sb = ny StringBuilder ();

Blir i Kotlin

val sb = StringBuilder ()

Du kan se att funktioner definieras med funnyckelordet och att semikolon nu är valfria när nya rader finns. Den valnyckelordet förklarar en skrivskyddad egendom eller lokal variabel. På samma sätt vardeklarerar nyckelordet en mutbar egenskap eller lokal variabel.

Ändå är Kotlin starkt typad. Den valoch varsökord kan bara användas när typen kan utläsas. Annars måste du deklarera typen. Typinferens verkar förbättras med varje release av Kotlin.

Ta en titt på funktionsdeklarationen nära toppen av båda rutorna. Returtypen i Java föregår prototypen, men i Kotlin efterföljs prototypen, avgränsad med ett kolon som i Pascal.

Det är inte helt uppenbart från detta exempel, men Kotlin har avslappnat Java krav på att funktioner ska vara klassmedlemmar. I Kotlin kan funktioner deklareras på toppnivå i en fil, lokalt i andra funktioner, som en medlemsfunktion i en klass eller ett objekt och som en tilläggsfunktion. Tilläggsfunktioner ger C # -liknande möjligheter att utöka en klass med ny funktionalitet utan att behöva ärva från klassen eller använda någon form av designmönster som Decorator.

För Groovy-fans implementerar Kotlin byggare; faktiskt kan Kotlin-byggare typkontrolleras. Kotlin stöder delegerade egenskaper, som kan användas för att implementera lata egenskaper, observerbara egenskaper, vetorbara egenskaper och mappade egenskaper.

Många asynkrona mekanismer tillgängliga på andra språk kan implementeras som bibliotek som använder Kotlin coroutines. Detta inkluderar async/ awaitfrån C # och ECMAScript, kanaler och välj från Go och generators/ yieldfrån C # och Python.

Funktionell programmering i Kotlin

Att tillåta funktioner på högsta nivå är bara början på den funktionella programmeringsberättelsen för Kotlin. Språket stöder också funktioner av högre ordning, anonyma funktioner, lambdas, inline-funktioner, förslutningar, svansrekursion och generik. Med andra ord har Kotlin alla funktioner och fördelar med ett funktionellt språk. Tänk till exempel på följande funktionella Kotlin-idiom.

Filtrera en lista i Kotlin

val positiva = list.filter {x -> x> 0}

För ett ännu kortare uttryck, använd itnär det bara finns en enda parameter i lambdafunktionen:

val positives = list.filter {it> 0}

Korsning av en karta / parförteckning i Kotlin

för ((k, v) på karta) {println (“$ k -> $ v”)}

koch  v kan kallas vad som helst.

Använda intervall i Kotlin

för (i i  1..100) {...} // slutet intervall: inkluderar 100

för (i i  1 till 100) {...} // halvöppet intervall: inkluderar inte 100

för (x i  2..10 steg 2) {...}

för (x i  10 ner till 1) {...}

om (x i  1..10) {...}

Ovanstående exempel visar  for nyckelordet samt användningen av intervall.

Även om Kotlin är ett fullfjädrat funktionellt programmeringsspråk, bevaras det mest av den objektorienterade karaktären av Java som en alternativ programmeringsstil, vilket är mycket praktiskt när man konverterar befintlig Java-kod. Kotlin har klasser med konstruktörer, tillsammans med kapslade, inre och anonyma inre klasser, och det har gränssnitt som Java 8. Kotlin har inte har en newsökord. För att skapa en klassinstans, ring konstruktören precis som en vanlig funktion. Vi såg det i skärmdumpen ovan.

Kotlin har en enda arv från en namngiven superklass, och alla Kotlin-klasser har en standard superklass Any, vilket inte är detsamma som Java-basklassen java.lang.Object. Anyinnehåller endast tre fördefinierade medlemsfunktioner: equals(), hashCode()och toString().

Kotlin-klasser måste markeras med opennyckelordet för att andra klasser ska kunna ärva från dem. Java-klasser är typ av motsats, eftersom de är ärvbara om de inte är markerade med finalnyckelordet. För att åsidosätta en superklassmetod måste själva metoden markeras openoch subklassmetoden måste markeras override. Det här är en bit med Kotlins filosofi att göra saker uttryckliga snarare än att förlita sig på standardvärden. I detta speciella fall kan jag se var Kotlins sätt att uttryckligen markera basklassmedlemmar som öppna för arv och härledda klassmedlemmar som åsidosättningar undviker flera typer av vanliga Java-fel.

Säkerhetsfunktioner i Kotlin

På tal om att undvika vanliga fel designades Kotlin för att eliminera risken för referenser till nollpekare och effektivisera hanteringen av nollvärden. Det gör det genom att göra ett nullolagligt för standardtyper, lägga till ogiltiga typer och implementera genvägsnoteringar för att hantera tester för null.

Till exempel kan en vanlig variabel av typen  inte innehålla  :String null

var a: String = "abc"

a = null // kompileringsfel

Om du måste tillåta nollor, till exempel för att hålla SQL frågeresultat kan du deklarera en null typ genom att lägga till ett frågetecken på typ, till exempel String?.

var  b: Sträng?

b = null  // ok

Skyddet går lite längre. Du kan använda en icke-ogiltig typ utan straffrihet, men du måste testa en ogiltig typ för nollvärden innan du använder den.

För att undvika den detaljerade grammatiken som normalt behövs för nolltestning introducerar Kotlin ett säkert samtal , skriftligt ?.. Till exempel returnerar om inte , och annars. Typen av detta uttryck är .b?.length b.lengthbnullnullInt?

Med andra ord b?.lengthär det en genväg för if (b != null) b.length else null. Denna syntax kedjar snyggt, vilket eliminerar en hel del prolixlogik, särskilt när ett objekt fyllts i från en serie databasfrågor, varav någon kan ha misslyckats. Till exempel bob?.department?.head?.nameskulle returnera namnet på Bobs avdelningschef om Bob, avdelningen och avdelningschefen inte är null.

För att utföra en viss åtgärd endast för icke-nollvärden kan du använda operatören för säker samtal ?.tillsammans med  let:

val listWithNulls: List = listOf ("A", null)

för (artikel i listWithNulls) {

      objekt? .let {println (it)} // skriver ut A och ignorerar null}

Ofta vill du returnera ett giltigt men speciellt värde från ett ogiltigt uttryck, vanligtvis så att du kan spara det till en icke-ogiltig typ. Det finns en speciell syntax för denna som heter Elvis-operatören (jag kidna dig inte), skriven ?:.

val l = b? .längd?: -1

motsvarar 

val l: Int = if (b! = null) b.längd annars -1

På samma sätt utelämnar Kotlin Javas kontrollerade undantag, vilka är kastbara förhållanden som måste fångas. Till exempel JDK-signaturen

Appendable append (CharSequence csq) kastar  IOException;

kräver att du fångar IOExceptionvarje gång du ringer till en appendmetod:

Prova {

  log.append (meddelande)

}

fånga (IOException e) {

  // Gör något med undantag

}

Java-formgivarna tyckte att det här var en bra idé, och det var en nettovinst för leksaksprogram, så länge programmerarna implementerade något förnuftigt i catchklausulen. Alltför ofta i stora Java-program, men ser du kod som den obligatoriska catchklausul innehåller inget annat än en kommentar: //todo: handle this. Detta hjälper ingen och kontrollerade undantag visade sig vara en nettoförlust för stora program.

Kotlin coroutines

Coroutines i Kotlin är i huvudsak lätta trådar. Du startar dem med launchcoroutine-byggaren i vissa sammanhang CoroutineScope. Ett av de mest användbara koroutinomfången är runBlocking{}, vilket gäller omfattningen av dess kodblock.

importera kotlinx.coroutines. *

kul huvud () = runBlocking {// detta: CoroutineScope

    lansera {// starta en ny coroutine inom ramen för runBlocking

        fördröjning (1000L) // icke-blockerande fördröjning i 1 sekund

        println ("Världen!")

    }

    println ("Hej")

}

Den här koden ger följande utdata, med en sekunders fördröjning mellan raderna:

Hallå,

Värld!

Kotlin för Android

Fram till maj 2017 var de enda officiellt stödda programmeringsspråken för Android Java och C ++. Google tillkännagav officiellt stöd för Kotlin på Android på Google I / O 2017 och från början med Android Studio 3.0 Kotlin är inbyggt i Android-utvecklingsverktygssatsen. Kotlin kan läggas till tidigare versioner av Android Studio med ett plugin-program.

Kotlin kompilerar till samma byte-kod som Java, samverkar med Java-klasser på naturliga sätt och delar sitt verktyg med Java. Eftersom det inte finns några omkostnader för att ringa fram och tillbaka mellan Kotlin och Java, är det bra att lägga till Kotlin stegvis i en Android-app för närvarande i Java. De få fall där driftskompatibiliteten mellan Kotlin och Java-kod saknar nåd, till exempel Java-inställningsegenskaper, är sällan påträffade och lätt fixade.

Pinterest var affischbarnet för Android-appar skrivna i Kotlin redan i november 2016, och det nämndes framträdande på Google I / O 2017 som en del av Kotlin-meddelandet. Dessutom gillar Kotlin-teamet att citera apparna Evernote, Trello, Square och Coursera för Android.

Kotlin vs Java

Frågan om att välja Kotlin eller Java för ny utveckling har kommit mycket upp i Android-communityn sedan Googles I / O-meddelande, även om folk redan ställde frågan i februari 2016 när Kotlin 1.0 skickades. Det korta svaret är att Kotlin-koden är säkrare och kortare än Java-kod, och att Kotlin- och Java-filer kan samexistera i Android-appar, så att Kotlin inte bara är användbart för nya appar utan också för att utöka befintliga Java-appar.

Det enda övertygande argumentet jag har sett för att välja Java framför Kotlin skulle vara fallet med kompletta Android-nybörjare. För dem kan det finnas ett hinder för att övervinna med tanke på att de flesta Android-dokumentationer och exempel historiskt finns i Java. Å andra sidan är att konvertera Java till Kotlin i Android Studio en enkel fråga om att klistra in Java-koden i en Kotlin-fil.

För nästan alla andra som gör Android-utveckling är fördelarna med Kotlin övertygande. Den typiska tid som en Java-utvecklare citerar för att lära sig Kotlin är några timmar - ett litet pris att betala för att eliminera nollreferensfel, aktivera tilläggsfunktioner, stödja funktionell programmering och lägga till coroutines. Den typiska grova uppskattningen indikerar ungefär 40 procent minskning av antalet kodrader från Java till Kotlin.