Kotlin-tutorial voor beginners (voorbeelden)

Geschiedenis van Kotlin

Hier zijn belangrijke bezienswaardigheden uit de geschiedenis van Kotlin:

Jaar	Gebeurtenis
2016	Kotlin v1.0 werd gelanceerd
2017	Aankondiging van Google over de eersteklas ondersteuning van Kotlin in Android
2018	Kotlin v1.2 wordt geleverd met een add-on voor het distribueren van codes tussen JVM en JavaScript
2019	Google heeft Kotlin aangekondigd als zijn favoriete programmeertaal Android Applicatie-ontwikkelaars
2021	Op 20 september 2021 werd Kotlin v1.5.31 gelanceerd.

Redenen om Kotlin te gebruiken

Hier zijn enkele belangrijke redenen waarom Kotlin op grote schaal wordt gebruikt:

• Kotlin is een statisch getypeerde taal die heel gemakkelijk te lezen en te schrijven is.
• Kotlin-programma's hebben geen puntkomma's nodig in hun programma. Dit maakt de code eenvoudig en leesbaarder.
• Deze taal maakt uitwisseling en gebruik van informatie mogelijk Java op verschillende manieren. Bovendien, Java en Kotlin-code kunnen naast elkaar in hetzelfde project bestaan.
• Het typesysteem van Kotlin is bedoeld om NullPointerException uit de code te verwijderen.
• Het kost u minder tijd om nieuwe code in Kotlin te schrijven. Het is nog eenvoudiger om kotlin-code te implementeren en op schaal te onderhouden.

Kenmerken van Kotlin

Hier zijn een paar kenmerken van de Kotlin die u zeker zullen maken van het voortgangspad van de programmeertaal.

Bijgesneden codering:

Kotlin is een op OOPs gebaseerde programmeertaal waarbij de coderegels tot 40% kunnen worden ingekort, wat Kotlin een ideale keuze maakt voor software- of webontwikkeling.

Open source:

Kotlin voor Android maakt gebruik van JVM en combineert de kenmerken van OOP's en functioneel georiënteerd programmeren.

Snelle compilatie:

Het is eenvoudig om de code te compileren wanneer u met Kotlin werkt, wat resulteert in betere prestaties voor Android-ontwikkeling. Ook wordt uitgelegd welk type datafunctie in de gehele code kan worden gebruikt.

Uitbreidingsfuncties:

Kotlin kan een verscheidenheid aan uitbreidingsfuncties ondersteunen zonder wijzigingen in de code aan te brengen. het helpt bij het aantrekkelijker en mooier maken van bestaande code voor ontwikkelaars.

Bijvoorbeeld:

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

Deze code helpt bij het inkorten van het eerste en het laatste teken van de string. We kunnen het toepassen als:

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

Nul-veiligheid:

In Kotlin maakt het systeem onderscheid tussen nulreferenties en niet nulreferenties, zoals weergegeven in het onderstaande Kotlin-voorbeeld.

Een String-variabele kan bijvoorbeeld niet null bevatten:

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-code kan worden gebruikt door Java en Java codes kunnen worden gebruikt met Kotlin. Dus als je kennis hebt over OOP's programmeren, is het eenvoudig om over te stappen naar de ontwikkeling van Kotlin. Ook als er enkele applicaties in zijn geschreven Java, dan kunnen ze worden gebruikt met de omgeving van Kotlin.

Robuuste gereedschappen:

Like Java, Kotlin-code kan ook worden geschreven met behulp van IDE of met behulp van de opdrachtregelinterface. Het is gemakkelijk om met IDE te werken en syntaxisfouten worden ook dramatisch verminderd. Tegelijkertijd moet, wanneer u met een opdrachtregelinterface werkt, eerst code worden gecompileerd.

Slimme cast:

Slim casten helpt in principe om de applicatiekosten te verlagen en de snelheid of prestaties ervan te verbeteren. Het werkt aan het beheren van de efficiëntie van code met behulp van typecasting of onveranderlijke waarden.

Als de string bijvoorbeeld wordt geïdentificeerd, wordt de lengte en het aantal ervan bepaald en kan deze worden gevonden met behulp van de Smart Cast-functie:

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

Lage adoptiekosten:

Kotlin heeft de voorkeur van bedrijven vanwege de verloren adoptiekosten. Het belangrijkste is dat het gemakkelijk te leren is voor ontwikkelaars, vooral als ze een programmeerachtergrond hebben.

Kotlin-omgeving instellen

Hieronder staan ​​de stappen die u helpen bij het opzetten van een werkomgeving door Kotlin te installeren.

Stap 1) Installeren Java

Zoals we eerder hebben besproken waar Kotlin op is gebaseerd Java, dus je moet installeren Java eerst toen hij van plan was Kotlin te adopteren. Raadpleeg onze Java Installatiehandleiding.

Stap 2) Installeren Java IDE

Gelukkig zijn het er meerdere Java IDE kiezen uit. Hier hebben we downloadlinks gegeven om het u wat gemakkelijker te maken.

• Om de Eclipse, klik hier.
• Om de NetBeans, klik hier.
• Om de IntelliJ te downloaden, klik hier.

In deze Kotlin-tutorial zullen we gebruiken Eclipse.

Stap 3) Installeer Kotlin

Voor het installeren van Kotlin in Eclipse, ga naar de Help-sectie in Eclipse En klik op de knop Eclipse Marktplaats optie.

Typ nu het Kotlin-trefwoord in het zoekvak. Klik op de optie Ga om de plugin te vermelden. Het geeft je een link naar de Kotlin-plug-in, je moet de plug-in installeren via de gegeven link.

Start het programma opnieuw op Eclipse IDE, zodra de installatie is voltooid. U vindt een snelkoppelingspictogram in de rechterbovenhoek van Eclipse IDE. Het is een snelle toegangsmethode.

Een andere manier om toegang te krijgen tot Kotlin Eclipse IDE is, ga naar de Windows, Perspectives, Open Perspectives, kies dan de optie Others. Hier kunt u een lijst bekijken van plugins die later worden geïnstalleerd, zoals hieronder weergegeven.

Nadat u de Kotlin-installatie heeft geverifieerd, laten we in de volgende stap het eerste Kotlin-programma maken.

Stap 4) Eerste Kotlin-programma

Begin met je eerste Kotlin-project. Kies in het menu Bestand de optie Nieuw, selecteer vervolgens anderen en begin met een nieuw Kotlin-project uit de lijst.

Nu moet je een naam voor het project definiëren en je bent klaar om met Kotlin te werken.

Met deze eenvoudige stappen is het downloaden eenvoudig Eclipse en Kotlin op uw systeem en schrijf meteen uw eerste Kotlin-programma.

Architectuur van Kotlin

Een goed gebouwde architectuur is belangrijk voor een applicatie om zijn functies op te schalen en te voldoen aan de verwachtingen van de eindgebruikersbasis. Kotlin heeft zijn eigen bijzondere en onderscheidende architectuur om het geheugen toe te wijzen en om kwaliteitsresultaten te krijgen voor de ontwikkelaars en eindgebruikers.

De coroutines en klassen van Kotlin ontwerpen de kern op zo'n manier dat er minder boilerplate-code wordt geproduceerd, de prestaties worden versterkt en de efficiëntie wordt versterkt. Er zijn verschillende scenario's waarin de Kotlin-compiler anders kan reageren, vooral wanneer deze verschillende soorten talen aan het oormerken is.

In het architectuurdiagram is duidelijk te zien dat de code-uitvoering in drie eenvoudige stappen plaatsvindt.

1. In de eerste stap wordt het “.kt”- of kotlin-bestand aan de compiler toegevoegd.
2. In de tweede stap converteert de Kotlin-compiler de code naar bytecode.
3. In de derde stap wordt bytecode ingevoerd Java Virtuele machine en uitgevoerd door de JVM.

Wanneer een bestand met een paar bytes op JVM werkt, starten ze de onderlinge communicatie op. Daarom is de functie in Kotlin, genaamd interoperabiliteit voor Java, ook ontstaan.

De transpiratie van Kotlin naar JavaScript gebeurt wanneer Kotlin doelen JavaScript.

Wanneer de JavaHet doel van het script is gekozen, alle code van Kotlin die deel uitmaakt van de bibliotheek die met Kotlin vaart, wordt dan gemorst met JavaScript. Echter, de Java Development Kit (JDK) of een andere gebruikte Java-bibliotheek is uitgesloten.

Een niet-Kotlin-bestand wordt niet in overweging genomen tijdens een dergelijke bewerking. Tijdens het targeten JavaHet script .kt-bestand wordt door de Kotlin-compiler omgezet naar ES5.1 om een ​​consistente code te genereren voor JavaScript. Kotlin-compiler streeft naar een optimale outputgrootte, interoperabiliteit met bestaande modules, dezelfde functionaliteit met de standaardbibliotheek en output die JavaSchrift leesbaar.

Uit de discussie blijkt duidelijk dat Kotlin Compilers een efficiëntere, competentere en onafhankelijkere code kunnen creëren die verder resulteert in een goed presterend softwareproduct.

Kotlin-variabele

Variabelen worden gebruikt om gegevens op te slaan die moeten worden gemanipuleerd en waarnaar in het programma moet worden verwezen. Het is in wezen een eenheid voor het opslaan van gegevens en het labelen ervan, die wacht op een verklarende alias, zodat het programma eenvoudig te lezen en gemakkelijk te begrijpen is. Met andere woorden, we kunnen zeggen dat variabelen de containers zijn waarin informatie wordt verzameld.

In Kotlin moeten alle variabelen worden gedeclareerd. Als een variabele echter niet wordt gedeclareerd, dan verschijnt er een syntaxisfout. Bovendien bepaalt de declaratie van de variabele het type gegevens dat we in de variabele mogen opslaan. In Kotlin kunnen variabelen worden gedefinieerd met behulp van de trefwoorden val en var. Dit is de syntaxis voor het declareren van variabelen in Kotlin:

Var day = "Monday"
Var number = 3

Hier hebben we de lokale variabele dag gedeclareerd waarvan de waarde “Monday' en waarvan het type String is en een ander lokaal variabel nummer waarvan de waarde 3 is en waarvan het type Int is, omdat hier de letterlijke waarde van het type geheel getal is dat 3 is.

Lokale variabelen worden gewoonlijk gelijktijdig gedeclareerd en geïnitialiseerd. We kunnen ook bepaalde bewerkingen uitvoeren terwijl we de Kotlin-variabele initialiseren.

We kunnen een bewerking uitvoeren op de variabele van hetzelfde gegevenstype, zoals hier num1 en num2 beide van hetzelfde gegevenstype zijn, namelijk Int, terwijl day van het gegevenstype string is. Ergo, het zal een fout tonen. Hier is nog een andere techniek hoe je variabelen in Kotlin kunt definiëren.

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

Laten we eens kijken hoe de trefwoorden var en val van elkaar verschillen.

Variant:

Var is als een generieke variabele die in elke programmeertaal wordt gebruikt en die meerdere keren in één programma kan worden gebruikt. Bovendien kunt u de waarde ervan op elk gewenst moment in een programma wijzigen. Daarom staat het bekend als de veranderlijke variabele.

Hier is een voorbeeld van een veranderlijke variabele in Kotlin:

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

Hier wordt de waarde van num1, die 20 is, overschreven door de vorige waarde van num1, die 10 is. Daarom is de uitvoer van num1 + num2 40 in plaats van 30.

Waarde:

Val is als een constante variabele, en je kunt de waarde ervan later in het programma niet veranderen, en kan ook niet meerdere keren in een enkel programma worden toegewezen en kan ook maar één keer in een bepaald programma worden gebruikt. Daarom staat het bekend als een onveranderlijke variabele.

Hier is een Kotlin-programmavoorbeeld van onveranderlijke variabelen in Kotlin:

Val num1 = 10
Var num2 = 20

Hier kan de waarde van num1 die 10 is, niet worden overschreven door de nieuwe waarde van num1 die 20 is, omdat deze van het val-type is dat constant is. Daarom is de uitvoer 30 in plaats van 40.

Note: In Kotlin hebben onveranderlijke variabelen de voorkeur boven veranderlijke variabelen.

Gegevenstypen in Kotlin

Gegevenstypen zijn sets van verwante waarden en beschrijven de bewerkingen die erop kunnen worden uitgevoerd. Net als andere programmeertalen heeft Kotlin ook zijn vooraf gedefinieerde set van gegevenstypen zoals Int, Boolean, Char, Double, Etc.

In Kotlin wordt elk gegevenstype als een object beschouwd.

Laten we nu in deze basistutorial van Kotlin dieper ingaan op de vooraf gedefinieerde gegevenstypen die in Kotlin worden gebruikt.

Numbers :

Kotlin bedient een set ingebouwde gegevenstypen die bekend staan ​​als getallen, die onderverdeeld zijn in gehele getallen en drijvende-komma getallen. Numbers.

gehele getallen:

Gehele getallen zijn een categorie getallen met vier typen:

Type	Grootte (bits)	Min waarde	maximum waarde
Byte	8	-128	127
Bermuda's	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231-1)
lang	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263-1)

Drijvend punt Numbers :

Drijvend punt Numbers zijn de niet-gehele getallen die een aantal decimalen bevatten.

Float: Float is een 32-bits drijvende-kommawaarde met enkele precisie.

Voorbeeld: var: Float x = 3.25600

Double: Double is een 64-bits drijvende-kommawaarde met dubbele precisie.

Voorbeeld: var: Double y = 2456.345587

Booleaanse waarden:

Het Booleaanse gegevenstype in Kotlin is belangrijk om de logische waarden weer te geven. Er zijn slechts twee mogelijke waarden in Boolean die waar of onwaar zijn.

Bijvoorbeeld: val dag = waar

Val dag2 = onwaar

Karakter:

Karakters in Kotlin worden weergegeven met behulp van het trefwoord char. In Kotlin vertegenwoordigen enkele aanhalingstekens de declaratie van char. In Java worden char soms gebruikt als getallen, wat niet mogelijk is in Kotlin.

Bijvoorbeeld:

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

Kotlin-typeconversie of Kotlin-type gieten

Typeconversie is een procedure voor het converteren van een type gegevensvariabele naar een andere gegevenstypevariabele. Het is enorm, ook wel Type Casting genoemd.

Bij uitstek, in Java, wordt impliciete typetypeconversie of impliciete typecasting van een kleiner gegevenstype naar een groter gegevenstype ondersteund.

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

In Kotlin wordt de impliciete conversie van een kleiner gegevenstype naar een groter gegevenstype echter helemaal niet ondersteund, omdat een int-gegevenstype niet impliciet naar een lang gegevenstype kan worden geconverteerd.

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

In Kotlin gebeurt de typeconversie echter expliciet. Hier komt de begeleiding van helperfuncties die de conversie van de ene gegevenstypevariabele naar de andere begeleiden.

Er zijn bepaalde helperfuncties die vooraf in gebruik zijn voor de conversie van het ene gegevenstype naar het andere:

toInt()

naarByte()

te kort()

toChar()

te lang()

drijven()

naarDouble()

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

Kotlin Operaverdraaid

Operators zijn belangrijke en speciale tekens of symbolen die de bewerkingen in operanden met variabelen en waarden verzekeren. In Kotlin is er een set operatoren die worden gebruikt in verschillende bewerkingen zoals rekenkundige bewerkingen, toewijzingsbewerkingen, vergelijkingsbewerkingen, etc.

Rekenkunde OperaTorens:

Rekenkundige operatoren worden gebruikt voor optellen, aftrekken, vermenigvuldigen, delen en modulus.

Operator	Betekenis
+	Optelling (ook gebruikt voor aaneenschakeling van tekenreeksen)
-	Aftrekking Operator
*	Vermenigvuldiging Operator
/	Divisie Operator
%	modulus Operator

Bijvoorbeeld:

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

De uitvoer van de volgende code is 45.

Vergelijk OperaTorens:

Vergelijkingsoperator wordt gebruikt om twee waarden, twee variabelen of twee getallen te vergelijken. Het wordt gebruikt met het symbool groter dan ( > ), kleiner dan ( < ) en gelijk aan ( == ), niet gelijk aan ( != ), groter dan gelijk aan ( >= ), kleiner dan gelijk aan ( <= ). Het resulteert altijd in true of false.

Bijvoorbeeld:

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

Toewijzing OperaTorens:

Toewijzing Operators worden gebruikt om de rekenkundig bewerkte waarden toe te wijzen. Het wordt gebruikt met symbolen zoals +=, -=, *=, /=, %=.

Bijvoorbeeld:

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

Verhogen en verlagen OperaTorens:

Increment- en decrementoperatoren worden gebruikt om de waarden van de variabele of het nummer te verhogen en te verlagen. Het wordt gebruikt met behulp van symbolen zoals ++ en —.

Er zijn twee soorten verhogingen en verlagingen: pre-verhoging ++a, post-verhoging a++, pre-verlaging –b, post-verlaging b–.

Bijvoorbeeld:

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

Kotlin-arrays

Een array is de homogene set gegevenstypen en is een van de meest fundamentele gegevenstypen die wordt gebruikt om dezelfde typen gegevens op de aangrenzende geheugenlocatie op te slaan. Een array is belangrijk voor de organisatie van gegevens in elke programmeertaal, zodat meerdere gegevens die op één plek zijn opgeslagen gemakkelijk kunnen worden doorzocht of gesorteerd.

In Kotlin zijn arrays een veranderlijke samenwerking van dezelfde gegevenstypen in plaats van dat het native gegevenstypen zijn.

Hier zijn bepaalde eigenschappen van een array in Kotlin

• De grootte van de array kan na declaratie niet meer worden gewijzigd.
• Arrays in Kotlin zijn veranderlijk.
• Arrays worden opgeslagen op aangrenzende geheugenlocaties.
• Een array kan worden benaderd met behulp van indexen als a[1], a[2], enzovoort.
• De index van een array begint met nul, dat wil zeggen a[0].

In Kotlin kan een array op twee verschillende manieren worden gedefinieerd

Door de arrayOf()-functie te gebruiken:

In Kotlin wordt veel gebruik gemaakt van bibliotheekfuncties. Eén zo'n bibliotheekfunctie is de functie arrayOf(), die wordt gebruikt om een ​​array te definiëren door de waarden van de variabelen aan de functie door te geven.

Bijvoorbeeld: Impliciete typedeclaratie van array met behulp van de functie arrayOf().

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

Bijvoorbeeld: Typ expliciet de declaratie van de array met behulp van de functie arrayOf().

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

Door Array Constructor te gebruiken:

In Kotlin is er een klasse met de naam Array. Daarom is het mogelijk om een ​​array van de constructor te gebruiken om een ​​array te maken. De array in de constructor bevat twee belangrijke parameters.

Wat is de index van een array in Kotlin?

De functie waarbij een array-index acceptabel is om de beginwaarde van de index te retourneren.

Bijvoorbeeld:

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

Hier is de waarde van array 7 en wordt de lambda-expressie gebruikt om de waarden van het element te initialiseren.

Er zijn ook verschillende methoden om toegang te krijgen tot de arrays en deze te wijzigen met behulp van bepaalde functies. Daarom zijn er twee lidfuncties get() en set(), die worden gebruikt om toegang te krijgen tot de objecten van de klassearray.

Bijvoorbeeld:

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

Hier is de uitvoer 10, omdat de waarde bij index 0 van de array 10 is

Opmerking: get() accepteert slechts enkele waarden

Bijvoorbeeld:

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

Uitgang: 30 40

Hier is de uitvoer 30 en 40, aangezien de waarde bij index 2 van de array 30 is en bij index 3 40.

Opmerking: set() neemt meerdere waarden van een array.

Kotlin-snaren

Een string is een basisgegevenstype in elke programmeertaal. Een string is niets anders dan een reeks karakters. De klasse String vertegenwoordigt tekenreeksen. In Kotlin zijn alle strings objecten van de klasse String, wat betekent dat letterlijke strings worden geïmplementeerd als instanties van de klasse.

Syntax:

 Val myString = "Hey there!"

Kotlin-collectie

Een verzameling bevat meerdere objecten van een vergelijkbaar type, en deze objecten in de verzameling worden elementen of items genoemd. Verzameling kan helpen bij het opslaan, ophalen, manipuleren en aggregeren van gegevens.

Soorten collecties:

Onveranderlijke verzameling

Dit type verzameling ondersteunt alleen-lezen functionaliteiten. Je kunt de elementen ervan niet wijzigen.

Methoden zijn onder meer:

• Lijst – lijstOf() en lijstOf ()
• Set – setOf()
• Kaart – mapOf()

Veranderlijke collectie

Het ondersteunt zowel lees- als schrijffunctionaliteit.

Methoden omvatten:

• Lijst – veranderlijkeListOf(),arrayListOf() en ArrayList
• Set – veranderlijkeSetOf(), hashSetOf()
• Kaart – veranderlijkeMapOf(), hashMapOf() en HashMap

Kotlin-functies

Functies in elke programmeertaal zijn een groep soortgelijke instructies die zijn bedoeld om een ​​specifieke taak uit te voeren. Met functies kan een programma het in verschillende kleine codeblokken opsplitsen. Deze opdeling van code vergroot de leesbaarheid van de code, de herbruikbaarheid van code en maakt een programma eenvoudig te beheren.

Kotlin staat bekend als een statisch getypeerde taal. Hier wordt het trefwoord 'fun' gebruikt om een ​​functie te declareren. In Kotlin zijn er twee soorten functies die uitsluitend afhankelijk zijn van de beschikbaarheid ervan in de standaardbibliotheek of gebruikersdefinitie. Zij zijn:

• Standaard bibliotheekfunctie
• Door de gebruiker gedefinieerde functie

Laten we ze nu in detail bespreken met Kotlin-codevoorbeelden.

Standaardbibliotheekfunctie

Het zijn ingebouwde bibliotheekfuncties die impliciet kunnen worden gedefinieerd en beschikbaar zijn voor gebruik.

Bijvoorbeeld 2:

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

Output:

3.0

sqrt() is een functie die in de bibliotheek is gedefinieerd en die de vierkantswortel van een getal retourneert.

print() functie drukt bericht af naar een standaard uitvoerstroom.

Door de gebruiker gedefinieerde functie

Zoals de naam al doet vermoeden, worden deze functies meestal door gebruikers gemaakt en kunnen ze worden gebruikt voor geavanceerde programmering.

Hier worden functies gedeclareerd met het trefwoord 'fun'.

Bijvoorbeeld 3:

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

Hier roepen we de functie aan om codes uit te voeren in de hoofdtekst functionName()

Voorbeelden van Kotlin-functies:

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

Output:

som = 17

code na som

Afhandeling van uitzonderingen in Kotlin

Uitzondering in het programmeren wordt gedefinieerd als een runtimeprobleem dat zich voordoet in het programma, waardoor het wordt beëindigd. Dit probleem kan optreden als gevolg van minder geheugenruimte, een onjuiste array of omstandigheden zoals delen door nul. Om dit soort problemen bij de uitvoering van code te beteugelen, wordt uitzonderingsafhandeling gebruikt.

Uitzonderingsafhandeling wordt gedefinieerd als de techniek die de runtime-problemen afhandelt en ook de programmastroom tijdens de uitvoering in stand houdt.

Kotlin gebruikt de 'throw'-expressie om een ​​uitzonderingsobject te genereren. Hier zijn alle uitzonderingsklassen afstammelingen van klasse Throwable.

Throw MyException(“gooit uitzondering”)

Er zijn vier soorten uitzonderingen bij de afhandeling van uitzonderingen. Zij zijn:

• try – Dit blok bevat instructies die de uitzondering kunnen veroorzaken. Het wordt altijd gevolgd door catch of final, of beide.
• catch – het vangt een uitzondering op die uit het try-blok wordt gegooid.
• ten slotte – Er wordt altijd gecontroleerd of de uitzondering wordt afgehandeld of niet.
• throw – Het wordt gebruikt om expliciet een uitzondering te genereren.

Proberen te vangen:

In het try-catch-blok bij de afhandeling van uitzonderingen, omsluit try-blok de code, die een uitzondering kan genereren, en het catch-blok vangt de expressie op en verwerkt deze.

Syntaxis van try catch-blok:

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

Syntaxis van proberen met uiteindelijk blokkeren

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

Tot slot:

In Kolin controleert block ten slotte altijd of de uitzondering wordt afgehandeld of niet, waardoor het een zeer belangrijke verklaring is voor de afhandeling van uitzonderingen.

Bijvoorbeeld 4:

In dit codefragment komt de uitzondering voor en wordt deze afgehandeld.

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")  
}  

Output:

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

Gooien:

Throw-blok genereert een expliciete uitzondering. Bovendien wordt het gebruikt om aangepaste uitzonderingen te genereren.

Syntax:

Throw SomeException()

Throw SomeException()

Voorbeeld:

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")
    }
}

Output:

Kotlin Null-veiligheid

De typen systemen die Kotlin ondersteunen maken een groot onderscheid tussen de referenties die null-referenties kunnen bevatten, en de referenties die geen null-referenties kunnen bevatten. Kotlin is een null-veiligheidstaal die bedoeld is om de null pointer-uitzondering of null-referentie uit de code te elimineren, die opzettelijk bekend staat als A Billion Dollar fout.

Het meest conventionele struikelblok van velen programmeertalen is dat bij het benaderen van een lid van een null reference, het resulteert in een NullPointerException, wat kan komen door de !! operator of deze constructor die ergens anders wordt gebruikt en op een ander punt in de code wordt doorgegeven. De nullable property vereist bevestiging voor de null check elke keer voorafgaand aan het gebruik ervan.

In Kotlin maakt het systeem onderscheid tussen nulreferenties en niet-nullreferenties.

Een String-variabele kan bijvoorbeeld niet null bevatten:

Bijvoorbeeld 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")
}

Output:

Kotlin OOP's

De objectgeoriënteerde programmeeraanpak maakt het mogelijk om een ​​complex codefragment op te delen in kleinere codeblokken door objecten te creëren. Deze objecten delen twee kenmerken: status en gedrag.

Hier zijn enkele van de OOPs-elementen die we gaan bespreken met Kotlin-codevoorbeelden:

• Klasse en objecten
• constructors
• Erfenis
• Abstracte klasse

Klasse in Kotlin

Voordat we een object maken, moeten we eerst een klasse definiëren die ook wel de blauwdruk voor het object wordt genoemd.

Syntax:

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

Objecten in Kotlin

Bij het definiëren van een klasse definiëren we alleen de specificaties voor het object; er wordt geen andere parameter zoals geheugen of opslag toegewezen.

Syntax:

var obj1 = ClassName()

Constructeurs in Kotlin

Een constructor is een manier om klasse-eigenschappen te initialiseren. Het is een lidfunctie die wordt aangeroepen wanneer een object wordt geïnstantieerd. Maar bij Kotlin werkt het anders.

Er zijn twee soorten constructors in Kotlin:

Primaire constructor: geoptimaliseerde manier om een ​​klasse te initialiseren

Syntax:

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

Secundaire constructor: Helpt bij het toevoegen van initialisatielogica

Kotlin-erfenis

Overerving vindt plaats wanneer bepaalde eigenschappen van de bovenliggende klasse worden overgenomen door de onderliggende klasse. Overerving is toegestaan ​​als twee of meer klassen dezelfde eigenschappen hebben.

Syntax:

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

Abstracte klasse in Kotlin

Een abstracte klasse is een klasse die niet kan worden geïnstantieerd, maar we kunnen er wel subklassen van erven. Het trefwoord 'abstract' wordt gebruikt om een ​​abstracte klasse te declareren.

Bijvoorbeeld 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() 
} 

Output:

Het heden en de toekomst van Kotlin

Het heden:

• Veel bedrijven vinden het leuk Netflix, Pinterest en Corda gebruiken Kotlin om krachtig te creëren Android apps.
• In een korte periode van een jaar, van 2016 tot 2017, werd Kotlin zeer populair met geweldige programmeerfuncties.
• In 2017 kondigde Google Kotlin aan als officiële programmeertaal voor Android-ontwikkeling.
• Je kunt snel vervangen Java codeer met Kotlin omdat het 100% interoperabel is met Java en Android.

De toekomst:

• Cross-platform game-ontwikkeling
• Cross-platform ontwikkeling van mobiele apps
• Scripting en microservices aan de servicezijde
• machine learning & gegevensanalyse

Samenvatting

• Kotlin is een programmeertaal die in 2010 door JetBrains werd voorgesteld voor multi-platform apps onder de Apache 2.0-licentie.
• De naam Kotlin is afgeleid van de naam Kotlin Island in een soortgelijke correspondentie van Java naar de naam van een eiland genaamd Java.
• In 2016 werd de eerste versie van Kotlin v1.0 gelanceerd
• Kotlin-programma's hebben geen puntkomma's nodig in hun programma. Dit maakt de code eenvoudig en leesbaarder.
• Kotlin voor Android ontwikkelaars is een op OOPs gebaseerde programmeertaal waarbij de coderegels tot 40% kunnen worden ingekort, wat Kotlin een ideale keuze maakt voor software- of webontwikkeling.
• In Kotlin moeten alle variabelen worden gedeclareerd met behulp van de trefwoorden var en val.
• Net als andere programmeertalen heeft Kotlin ook een vooraf gedefinieerde set gegevenstypen zoals Int, Boolean, Char, Double, Etc.
• In Kotlin bestaat er een reeks operatoren die worden gebruikt in verschillende bewerkingen, zoals rekenkundige bewerkingen, toewijzingsbewerkingen, vergelijkingsbewerkingen, enzovoort.
• In Kotlin zijn arrays een veranderlijke samenwerking van dezelfde gegevenstypen in plaats van dat het native gegevenstypen zijn.
• In Kotlin worden arrays gedefinieerd met behulp van twee methoden: ArrayOF () en Constructors.
• Kotlin is een null-veiligheidstaal die helpt bij het verwijderen van de null pointer-uitzondering of null-referentie uit de code, die opzettelijk A wordt genoemd Billion Dollar fout.