Kotlin-programmeringshandledning

Kotlins historia

Här är viktiga landmärken från Kotlins historia:

År	Event
2016	Kotlin v1.0 lanserades
2017	Tillkännagivande av Google om förstklassigt stöd för kotlin i Android
2018	Kotlin v1.2 kommer med tillägg för att distribuera koder mellan JVM och JavaScript
2019	Google tillkännagav Kotlin som sitt föredragna programmeringsspråk för Android Applikationsutvecklare
2021	Den 20 september 2021 lanserades Kotlin v1.5.31.

Anledningar till att använda Kotlin

Här är några viktiga skäl till varför Kotlin används flitigt:

• Kotlin är ett statiskt skrivet språk som är mycket lätt att läsa och skriva.
• Kotlin-program kräver inte semikolon i sina program. Detta gör koden lätt och mer läsbar.
• Denna languare tillåter utbyte och användning av information från Java på olika sätt. Dessutom, Java och Kotlin-kod kan samexistera i samma projekt.
• Kotlins typsystem syftar till att eliminera NullPointerException från koden.
• Det tar dig mindre tid att skriva ny kod i Kotlin. Det är ännu enklare att distribuera kotlin-kod och att underhålla den i skala.

Funktioner hos Kotlin

Här är några funktioner i Kotlin som kommer att göra dig säker på framstegsvägen för programmeringsspråket.

Trimmad kodning:

Kotlin är ett OOPs-baserat programmeringsspråk där kodlinjen kan trimmas upp till 40 %, vilket gör Kotlin till ett idealiskt val för mjukvara eller webbutveckling.

Öppen källa:

Kotlin för Android använder JVM och kombinerar funktionerna hos OOPs och funktionellt orienterad programmering.

Snabb sammanställning:

det är enkelt att kompilera koden när man arbetar med Kotlin vilket ger bättre prestanda för androidutveckling, och det kommer också att förklara vilken typ av datafunktion som kan användas i hela koden.

Tilläggsfunktioner:

Kotlin kan stödja en mängd olika tilläggsfunktioner utan att göra några ändringar i koden. det hjälper till att göra befintlig kod mer tilltalande och magnifik för utvecklare.

Till exempel:

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

Den här koden hjälper till att trimma ner det första och sista tecknet i strängen, vi kan använda det som:

Val string1 = "Today is cloudy."
Val string2 = string1.removeFirstLastChar()

Noll säkerhet:

I Kotlin skiljer systemet mellan nollreferenser och inte nollreferenser som visas i nedanstående Kotlin-exempel.

Till exempel kan en strängvariabel inte innehålla null:

Var string1: String = "Today is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today is Sunday"
String2 = null
print(string2)

Interoperabel:

Kotlin-kod kan användas av Javaoch Java koder kan användas med Kotlin. Så, om du har kunskap om Hoppsan programmering är det lätt att byta till Kotlins utveckling. Även om det finns några ansökningar inskrivna Java, då kan de användas med Kotlins miljö.

Robusta verktyg:

Tycka om Java, Kotlin-kod kan också skrivas med IDE eller med kommandoradsgränssnittet. Det är lätt att arbeta med IDE, och syntaxfel minskar också dramatiskt. Samtidigt, när du arbetar med ett kommandoradsgränssnitt, måste kod kompileras först.

Smart Cast:

Smart gjutning hjälper i princip att minska applikationskostnaderna och förbättrar dess hastighet eller prestanda. Det fungerar på att hantera effektiviteten av kod med hjälp av typgjutning eller oföränderliga värden.

Till exempel, om strängen identifieras, är dens längd och antal och kan hittas med hjälp av Smart Cast-funktionen:

Val string1: Any = "Today is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

Låg kostnad för adoption:

Kotlin föredras av företag på grund av dess förlorade kostnad för adoption. Viktigast av allt är att det är lätt att lära sig av utvecklare, särskilt med en programmeringsbakgrund.

Kotlin-miljöinställningar

Följande är stegen som hjälper dig att ställa in en arbetsmiljö genom att installera Kotlin.

Steg 1) Installera Java

Som vi har diskuterat tidigare att Kotlin bygger på Java, så du måste installera Java först när man planerar att adoptera Kotlin. Se vår Java Installationshandledning.

Steg 2) Installera Java IDE

Lyckligtvis finns det flera Java IDE att välja ifrån. Här har vi gett nedladdningslänkar för att göra det lite enklare för dig.

• För att ladda ner Eclipse, Klicka här.
• För att ladda ner NetBeans, Klicka här.
• För att ladda ner IntelliJ, Klicka här.

I denna Kotlin-handledning kommer vi att använda Eclipse.

Steg 3) Installera Kotlin

För installation av Kotlin i Eclipse, gå till avsnittet Hjälp i Eclipse och klicka på Eclipse Marknadsplatsalternativ.

Skriv nu Kotlin-nyckelordet i sökrutan. Klicka på alternativet Gå för att lista plugin-programmet. Det kommer att ge dig en länk till Kotlin-plugin, du måste installera plug-in från den givna länken.

Vänligen starta om Eclipse IDE, när installationen är klar. Du hittar en genvägsikon i det övre högra hörnet av Eclipse ID. Det är en metod för snabb åtkomst.

Ett annat sätt att komma åt Kotlin in Eclipse IDE är, gå till Windows, Perspektiv, Öppna perspektiv och välj sedan alternativet Andra. Här kan du kontrollera en lista över plugins som installeras senare, enligt nedan.

När du har verifierat Kotlin-installationen, låt oss skapa det första Kotlin-programmet i nästa steg.

Steg 4) Första Kotlin-programmet

Börja med ditt första Kotlin-projekt. Från Arkiv-menyn, välj alternativet Nytt, välj sedan andra och börja med ett nytt Kotlin-projekt från listan.

Nu måste du definiera ett namn för projektet och du är redo att arbeta med Kotlin.

Med dessa enkla steg är det enkelt att ladda ner Eclipse och Kotlin på ditt system och skriv ditt första Kotlin-program direkt.

Architecture av Kotlin

En välbyggd arkitektur är viktig för att en applikation ska skala upp sina funktioner och uppfylla förväntningarna hos slutanvändarbasen. Kotlin har sin egen speciella och distinkta arkitektur för att allokera minnet och för att få kvalitetsresultat för utvecklarna och slutanvändarna.

Kotlins koroutiner och klasser skapar kärnan på ett sådant sätt att de producerar mindre kod, förstärker prestandan och förstärker effektiviteten. Det finns en mängd olika scenarier där kotlin-kompilatorn kan reagera olika, särskilt när den öronmärker olika typer av språk.

I arkitekturdiagrammet är det tydligt att kodexekvering sker i tre enkla steg.

1. I det första steget läggs ".kt" eller kotlin-fil till i kompilatorn.
2. I det andra steget konverterar Kotlin-kompilatorn koden till bytekod.
3. I det tredje steget läggs bytekod in Java Virtuell maskin och utförs av JVM.

När ett par bytekodade filer fungerar på JVM, tänder de den ömsesidiga kommunikationen sinsemellan, vilket är anledningen till funktionen i Kotlin som kallas interoperabilitet för java ook födelse

Det inträffade av Kotlin till JavaManus händer när Kotlin mål JavaManus.

När JavaScriptets mål är valt, vilken kod som helst av Kotlin som är en del av biblioteket som seglar med Kotlin spills sedan ut med JavaManus. Men den Java Development Kit (JDK) eller något Java-bibliotek som används är uteslutet.

En icke-Kotlin-fil tas inte i beaktande under sådan operation. Under inriktning JavaSkript .kt-fil konverteras till ES5.1 av Kotlin-kompilatorn för att generera en konsekvent kod för JavaManus. Kotlin-kompilatorn strävar efter en optimal storleksutdata, interoperabilitet med befintlig modul, samma funktionalitet som standardbiblioteket och utdata som är JavaSkript läsbart.

Det framgår av diskussionen att Kotlin-kompilatorer kan skapa en mer effektiv, kompetent och oberoende kod som ytterligare resulterar i en högpresterande mjukvaruprodukt.

Kotlin Variabel

Variabler används för att lagra data som ska manipuleras och refereras till i programmet. Det är i grunden en enhet för att lagra data och märka den väntar på ett expository alias så att programmet är enkelt att läsa och lätt att förstå. Med andra ord kan vi säga att variabler är behållare för att samla in information.

I Kotlin ska alla variabler deklareras. Men om någon variabel inte deklareras, så dyker det upp som ett syntaxfel. Deklarationen av variabeln bestämmer också vilken typ av data vi tillåter att lagra i variabeln. I Kotlin kan variabler definieras med nyckelord val och var. Här är syntaxen för att deklarera variabler i Kotlin:

Var day = "Monday"
Var number = 3

Här har vi deklarerat den lokala variabeldagen vars värde är "Monday' och vars typ är String och ett annat lokalt variabelnummer vars värde är 3 och vars typ är Int eftersom bokstaven här är av typen heltal som är 3.

Lokala variabler deklareras och initieras vanligtvis samtidigt. Vi kan också utföra vissa operationer medan vi initierar Kotlin-variabeln.

Vi kan utföra en operation på variabeln av samma datatyp, eftersom num1 och num2 här båda är av samma datatyp som är Int, medan dag är av strängdatatypen. Det kommer alltså att visa ett fel. Här är en annan teknik hur du kan definiera variabler i Kotlin.

var day : String = "GURU99"
var num : Int = 100

Låt oss se hur var och val nyckelord skiljer sig från varandra.

Var :

Var är som en generisk variabel som används i alla programmeringsspråk som kan användas flera gånger i ett enda program. Dessutom kan du ändra dess värde när som helst i ett program. Därför är den känd som den föränderliga variabeln.

Här är ett exempel på föränderlig variabel i Kotlin:

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

Här skrivs värdet på num1 som är 20 över av det tidigare värdet på num1 som är 10. Därför är utmatningen av num1 + num2 40 istället för 30.

Värde:

Val är som en konstant variabel, och du kan inte ändra dess värde senare i programmet, som inte heller kan tilldelas flera gånger i ett enda program och bara kan användas en gång i ett visst program. Ergo är den känd som en oföränderlig variabel.

Här är ett Kotlin-programexempel på oföränderliga variabler i Kotlin:

Val num1 = 10
Var num2 = 20

Här kan värdet på num1 som är 10 inte skrivas över av det nya värdet på num1 som är 20, eftersom det är av valtyp som är konstant. Därför är utgången 30 istället för 40.

Anmärkningar: I Kotlin föredras oföränderliga variabler framför föränderliga variabler.

Datatyper i Kotlin

Datatyper är uppsättningar av relaterbara värden och beskriver de operationer som kan utföras på dem. I likhet med andra programmeringsspråk har Kotlin också sin fördefinierade uppsättning datatyper som Int, Boolean, Char, DoubleEtc.

I Kotlin betraktas varje datatyp som ett objekt.

Nu i denna Kotlin grundläggande handledning, låt oss dyka djupare in i de fördefinierade datatyperna som används i Kotlin.

Numbers :

Kotlin betjänar en uppsättning inbyggda datatyper som kallas siffror, som underkategoriseras som heltal och flytande poäng Numbers.

Heltal:

Heltal är den kategori av tal som har fyra typer:

Typ	Storlek (bitar)	Minvärde	Maxvärde
Byte	8	-128	127
Kort	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
Lång	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

Flytpunkt Numbers :

Flytpunkt Numbers är de icke-heltalsnummer som har vissa decimalvärden.

Float: Float är ett 32-bitars flyttalsvärde med enkel precision.

Exempel: var: Float x = 3.25600

Double: Double är ett 64-bitars dubbel – precisionsflyttalsvärde.

Exempel: var: Double y = 2456.345587

Booleans:

Booleans datatyp i Kotlin är signifikant för att representera de logiska värdena. Det finns bara två möjliga värden i Boolean som är antingen sant eller falskt.

Till exempel: valdag = sant

Val dag2 = falskt

Karaktär :

Tecken i Kotlin representeras med hjälp av nyckelordet char. I Kotlin representerar enstaka citattecken deklarationen av röding. I java används röding ibland som siffror som inte är möjligt i kotlin.

Till exempel:

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

Kotlin-typkonvertering eller Kotlin-typgjutning

Typkonvertering är en procedur för att konvertera en typ av datavariabel till en annan datatypvariabel. Det är enormt, även känt som Type Casting.

Eminent, i Java, implicit typ av typkonvertering eller implicit typ av typcasting av en mindre datatyp till en större datatyp stöds.

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

Men i kotlin stöds inte implicit konvertering av en mindre datatyp till en större datatyp alls, eftersom en int datatyp inte kan konverteras till lång datatyp implicit.

For Example : var abc = 15
Val bcd : Long = abc // error

I Kotlin görs dock typkonvertering explicit. Här kommer vägledning för hjälpfunktioner som guidar konverteringen av en datatypsvariabel till en annan.

Det finns vissa hjälpfunktioner som är förägda för konvertering av en datatyp till en annan:

toInt()

toByte()

för kort()

toChar()

toLong()

att flyta()

tillDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

Kotlin Operatorer

Operators är betydelsefulla och specialtecken eller symboler som säkerställer operationerna i operander som har variabler och värden. I Kotlin finns det en uppsättning operatorer som används i olika operationer som aritmetiska operationer, tilldelningsoperationer, jämförelseoperationer, etc.

Aritmetik Operators:

Aritmetiska operatorer används för addition, subtraktion, multiplikation, division och modul.

Operator	Betydelse
+	Addition (används även för strängsammansättning)
-	Subtraktion Operator
*	Multiplikation Operator
/	division Operator
%	modul Operator

Till exempel:

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

Här är resultatet av följande kod 45.

Jämförelse Operators:

Jämförelseoperator används för att jämföra två värden, två variabler eller två tal. Den används med symbolen större än ( > ), mindre än symbolen ( < ) och lika med symbolen ( ==), inte lika med symbolen ( != ), större än lika med symbolen ( >= ), mindre än lika med symbolen symbol(<= ). Det resulterar alltid i sant eller falskt.

Till exempel:

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

Uppdrag Operators:

Uppdrag Operators används för att tilldela de aritmetiskt styrda värdena. Den används med symboler som +=, -=, *=, /=, %=.

Till exempel:

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

Öka och minska Operators:

Öka och minska operatorer används för att öka och minska värdena på variabeln eller talet. Den används med hjälp av symboler som ++ och —.

Det finns två typer av inkrement och dekrement som är pre-increment ++a, post-increment a++, pre-decrement –b, post-decrement b–.

Till exempel:

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

Kotlin Arrays

En Array är den homogena uppsättningen av datatyper och är en av de mest grundläggande datatyperna som används för att lagra samma typer av data i den sammanhängande minnesplatsen. En array är viktig för organisationen av data i alla programmeringsspråk så att flera data lagrade på en enda plats är lätta att söka eller sortera.

I Kotlin är arrayer ett föränderligt samarbete av samma datatyper snarare än att vara infödda datatyper.

Här är vissa egenskaper hos en array i Kotlin

• Storleken på arrayen kan inte ändras när den väl har deklarerats.
• Arrayer i Kotlin är föränderliga.
• Matriser lagras i angränsande minnesplatser.
• En array kan nås med hjälp av index som a[1], a[2], et – cetera.
• Indexet för en array börjar med noll som är a[0].

I Kotlin kan en array definieras på två olika metoder

Genom att använda arrayOf()-funktionen:

I Kotlin är det en stor användning av biblioteksfunktioner. En sådan biblioteksfunktion är arrayOf()-funktionen, som används för att definiera en array genom att överföra variablernas värden till funktionen.

Till exempel: Implicit typdeklaration av array med arrayOf()-funktionen

val x = arrayOf(1,2,3,4,5,6,7,8,9)

Till exempel: Skriv explicit deklaration av array med arrayOf()-funktionen.

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

Genom att använda Array Constructor:

I Kotlin finns det en klass med namnet Array. Därför är det möjligt att använda en array av konstruktorn för att skapa en array. Arrayen i konstruktorn har två huvudparametrar.

Vad är indexet för en array i Kotlin?

Funktionen där ett arrayindex är acceptabelt för att returnera indexets initiala värde.

Till exempel:

val abc = Array(7 , { i -> i*1})

Här är värdet på array 7 och lambda-uttryck används för att initiera elementets värden.

Det finns också olika metoder för att komma åt och modifiera arrayerna med hjälp av vissa funktioner. Därför finns det två medlemsfunktioner get() och set(), som används för att komma åt klassmatrisens objekt.

Till exempel:

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

Här är utgången 10 eftersom värdet vid index 0 för array är 10

Notera: get() tar bara enstaka värden

Till exempel:

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

Effekt: 30 40

Här är utsignalen 30 och 40 eftersom värdet vid index 2 för array är 30 och vid index 3 är det 40.

Obs: set() tar flera värden av en array.

Kotlin Strings

En sträng är en grundläggande datatyp i alla programmeringsspråk. En sträng är inget annat än en sekvens av tecken. Klassen String representerar teckensträngar. I Kotlin är alla strängar objekt av klassen String, vilket innebär att strängliteraler implementeras som instanser av klassen.

Syntax:

 Val myString = "Hey there!"

Kotlin samling

En samling innehåller flera objekt av liknande typ, och dessa objekt i samlingen kallas element eller objekt. Insamling kan hjälpa till att lagra, hämta, manipulera och samla data.

Typer av samlingar:

Oföränderlig samling

Den här typen av samling stöder skrivskyddade funktioner. Man kan inte modifiera dess element.

Metoder inkluderar:

• List – listOf() och listOf ()
• Set – setOf()
• Karta – mapOf()

Föränderlig samling

Den stöder både läs- och skrivfunktioner.

Metoder inkluderar

• List – mutableListOf(),arrayListOf() och ArrayList
• Set – mutableSetOf(), hashSetOf()
• Karta – mutableMapOf(), hashMapOf() och HashMap

Kotlin funktioner

Funktioner i alla programmeringsspråk är en grupp liknande uttalanden som är avsedda att utföra en specifik uppgift. Funktioner gör att ett program kan dela upp det i olika små kodblock. Denna uppdelning av kod ökar läsbarheten av koden, återanvändbarheten av koden och gör ett program lätt att hantera.

Som Kotlin är känt som ett statiskt maskinskrivet språk. Här används nyckelordet "roligt" för att deklarera en funktion. I Kotlin finns det två typer av funktioner som enbart beror på dess tillgänglighet i standardbiblioteket eller användardefinitionen. Dom är:

• Standard biblioteksfunktion
• Användardefinierad funktion

Låt oss nu diskutera dem i detalj med Kotlin-kodexempel.

Standard biblioteksfunktion

De är inbyggda biblioteksfunktioner som kan definieras implicit och tillgängliga för användning.

Till exempel 2:

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

Produktion:

3.0

sqrt() är en funktion definierad i biblioteket som returnerar kvadratroten ur ett tal.

print()-funktionen skriver ut meddelande till en standardutgångsström.

Användardefinierad funktion

Som namnet antyder skapas dessa funktioner vanligtvis av användare, och de kan användas för avancerad programmering.

Här deklareras funktioner med nyckelordet "roligt".

Till exempel 3:

fun functionName(){
//body of the code
}

Här anropar vi funktionen för att köra koder inuti kroppen functionName()

Exempel på Kotlin-funktioner:

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

Produktion:

summa = 17

kod efter summa

Undantagshantering i Kotlin

Undantag i programmering definieras som ett körtidsproblem som uppstår i programmet, vilket leder till att det avslutas. Det här problemet kan uppstå på grund av mindre minnesutrymme, array out of bond, förhållanden som division med noll. För att stävja dessa typer av problem vid kodexekvering används undantagshantering.

Undantagshantering definieras som tekniken som hanterar körtidsproblemen och även upprätthåller programflödet under körning.

Kotlin använder uttrycket 'kasta' för att kasta ett undantagsobjekt. Här är alla undantagsklasser ättlingar till klassen Throwable.

Kasta MyException ("kastar undantag")

Det finns fyra typer av undantag i undantagshantering. Dom är:

• try – Detta block innehåller satser som kan skapa undantaget. Den följs alltid av antingen fångst eller slutligen eller båda.
• catch – den fångar ett undantag som kastas från försöksblocket.
• slutligen – Den kontrollerar alltid om undantaget hanteras eller inte.
• kast – Det används för att göra ett undantag uttryckligen.

Försök fånga:

I try-catch-block i undantagshantering omsluter try-block koden, vilket kan kasta ett undantag och catch-block fångar uttrycket och hanterar det.

Syntax för try catch block:

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

Syntax för försök med slutligen block

try{    
//code with exception    
}finally{  
// code finally block  
}   

Slutligen:

I Kolin kontrollerar slutligen block alltid om undantaget hanteras eller inte, vilket gör det till en mycket viktig uppgift om undantagshantering.

Till exempel 4:

I det här kodavsnittet inträffar undantaget och det hanteras.

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("finally block executes")  
    }  
    println("write next code")  
}  

Produktion:

java.lang.ArithmeticException: / by zero
finally block executes
write next code

Kasta:

Kasta block ger ett uttryckligt undantag. Dessutom används det för att kasta anpassade undantag.

Syntax:

Throw SomeException()

Throw SomeException()

Exempelvis:

fun main(args: Array<String>) {
    try{
        println("Exception is not thrown yet")
        throw Exception("Everything is not well")
        println("Exception is thrown")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

Produktion:

Kotlin Null Säkerhet

De typer av system som stöder Kotlin skiljer i stort sett mellan de referenser som kan ha nollbara referenser, och de som inte kan ha nollbara referenser. Kotlin är ett nollsäkerhetsspråk som syftar till att eliminera nollpekarens undantag eller nollreferens från koden, som medvetet kallas A Billjon Dollar Misstag.

Den mest konventionella stötestenen av många programmeringsspråk är att när man får åtkomst till en medlem av en nollreferens resulterar det i ett NullPointerException, vilket kan bero på !! operatör eller denna konstruktor som används någon annanstans och skickas vid en annan kodpunkt. Den nullbara egenskapen kräver bekräftelse för nollkontrollen varje gång innan den används.

I Kotlin skiljer systemet mellan nollreferenser och inte nollreferenser.

Till exempel kan en strängvariabel inte innehålla null:

Till exempel 5:

fun main(args: Array<String>){
    var x: String = "GURU99 is the only place where you will get maximum technical content!" // Not Null by default
    println("x is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks for visiting GURU99" 
// Nullable Variable
    println("y is : $y")
    y = null
    println("y is : $y")
}

Produktion:

Kotlin OOPs

Den objektorienterade programmeringsmetoden gör att ett komplext kodavsnitt kan delas upp i mindre kodblock genom att skapa objekt. Dessa objekt delar ömsesidigt två egenskaper: tillstånd och beteende.

Här är några av OOPs-elementen som vi kommer att diskutera med Kotlin-kodexempel:

• Klass och objekt
• konstruktörer
• Arv
• Abstrakt klass

Klass i Kotlin

Det första innan vi skapar ett objekt måste vi definiera en klass som också är känd som ritningen för objektet.

Syntax:

class ClassName {
    // property
    // member function
    ... .. ...
}

Objekt i Kotlin

När vi definierar en klass definierar vi bara specifikationerna för objektet, ingen annan parameter som minne eller lagring tilldelas.

Syntax:

var obj1 = ClassName()

Konstruktörer i Kotlin

En konstruktor är ett sätt att initiera klassegenskaper. Det är en medlemsfunktion som kallas när ett objekt instansieras. Men i Kotlin fungerar det annorlunda.

Det finns två typer av konstruktörer i Kotlin:

Primär konstruktor: Optimerat sätt att initiera en klass

Syntax:

class myClass(valname: String,varid: Int) {  
    // class body  
}  

Sekundär konstruktor: Hjälper till att lägga till initieringslogik

Kotlin Arv

Arv uppstår när vissa egenskaper i moderklassen förvärvas av den underordnade klassen. Arv är tillåtet när två eller flera klasser har samma egenskaper.

Syntax:

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

Abstrakt klass i Kotlin

En abstrakt klass är en klass som inte kan instansieras, men vi kan ärva underklasser från dem. Nyckelordet 'abstract' används för att deklarera en abstrakt klass.

Till exempel 6:

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

Produktion:

Kotlins nutid och framtid

Nuet:

• Många företag gillar Netflix, Pinterest och Corda använder Kotlin för att skapa kraftfulla Android appar.
• På kort tid på ett år, 2016 till 2017, blev Kotlin mycket populär med fantastiska programmeringsfunktioner.
• 2017 tillkännagav Google Kotlin som ett officiellt programmeringsspråk för Android-utveckling.
• Du kan snabbt byta ut Java kod med Kotlin eftersom den är 100 % interoperabel med Java och Android.

Framtiden:

• Spelutveckling över plattformar
• Utveckling av plattformsoberoende mobilappar
• Skript och mikrotjänster på tjänstesidan
• Maskininlärning & dataanalys

Sammanfattning

• Kotlin är ett programmeringsspråk som föreslagits av JetBrains 2010 för appar med flera plattformar under Apache 2.0-licensen.
• Namnet Kotlin kommer från namnet Kotlin Island i en liknande korrespondens av Java efter namnet på en ö som heter java.
• Under 2016 lanserades Kotlins första version v1.0
• Kotlin-program kräver inte semikolon i sina program. Detta gör koden lätt och mer läsbar.
• Kotlin för Android developers är ett OOPs-baserat programmeringsspråk där kodlinjen kan trimmas upp till 40 %, vilket gör Kotlin till ett idealiskt val för mjukvara eller webbutveckling.
• I Kotlin ska alla variabler deklareras med nyckelord var och val.
• I likhet med andra programmeringsspråk har Kotlin också sin fördefinierade uppsättning datatyper som Int, Boolean, Char, DoubleEtc.
• I Kotlin finns det en uppsättning operatorer som används i olika operationer som aritmetiska operationer, tilldelningsoperationer, jämförelseoperationer, etc.
• I Kotlin är arrayer ett föränderligt samarbete av samma datatyper snarare än att vara infödda datatyper.
• I Kotlin definieras arrayer med två metoder – ArrayOF () och Constructors.
• Kotlin är ett nollsäkerhetsspråk som hjälper till att ta bort nollpekarens undantag eller nollreferens från koden, som medvetet kallas A Billjon Dollar Misstag.