Kotlin-Programmier-Tutorial

Geschichte von Kotlin

Hier sind wichtige Meilensteine ​​aus der Geschichte von Kotlin:

Jahr	Event
2016	Kotlin v1.0 wurde gestartet
2017	Ankündigung von Google zur erstklassigen Unterstützung von Kotlin in Android
2018	Kotlin v1.2 enthält ein Add-on zur Verteilung von Codes zwischen JVM und JavaSkript
2019	Google hat Kotlin als seine bevorzugte Programmiersprache für angekündigt Android Anwendungsentwickler
2021	Am 20. September 2021 wurde Kotlin v1.5.31 gestartet.

Gründe für die Verwendung von Kotlin

Hier sind einige wichtige Gründe, warum Kotlin weit verbreitet ist:

• Kotlin ist eine statisch typisierte Sprache, die sehr einfach zu lesen und zu schreiben ist.
• Kotlin-Programme benötigen keine Semikolons in ihrem Programm. Dies macht den Code einfach und lesbarer.
• Diese Sprache ermöglicht den Austausch und die Nutzung von Informationen aus Java auf verschiedene Weise. Darüber hinaus Java und Kotlin-Code können im selben Projekt koexistieren.
• Das Typsystem von Kotlin zielt darauf ab, NullPointerException aus dem Code zu eliminieren.
• Sie benötigen weniger Zeit, um neuen Code in Kotlin zu schreiben. Es ist noch einfacher, Kotlin-Code bereitzustellen und im großen Maßstab zu verwalten.

Funktionen von Kotlin

Hier sind einige Funktionen von Kotlin, die Ihnen den Fortschritt der Programmiersprache verdeutlichen.

Gekürzte Codierung:

Kotlin ist eine OOPs-basierte Programmiersprache, bei der die Codezeile um bis zu 40 % gekürzt werden kann, was Kotlin zu einer idealen Wahl für die Software- oder Webentwicklung macht.

Open Source:

Kotlin für Android nutzt JVM und kombiniert die Funktionen von OOPs und funktionsorientierter Programmierung.

Schnelle Zusammenstellung:

Beim Arbeiten mit Kotlin lässt sich der Code leichter kompilieren, was zu einer besseren Leistung bei der Android-Entwicklung führt. Außerdem wird erklärt, welche Art von Datenfunktion im gesamten Code verwendet werden kann.

Erweiterungsfunktionen:

Kotlin kann eine Vielzahl von Erweiterungsfunktionen unterstützen, ohne dass Änderungen am Code vorgenommen werden müssen. Es hilft dabei, vorhandenen Code für Entwickler attraktiver und großartiger zu machen.

Zum Beispiel:

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

Dieser Code hilft beim Kürzen des ersten und letzten Zeichens der Zeichenfolge. Wir können ihn wie folgt anwenden:

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

Null Sicherheit:

In Kotlin unterscheidet das System zwischen Null-Referenzen und Nicht-Null-Referenzen, wie im folgenden Kotlin-Beispiel gezeigt.

Beispielsweise darf eine String-Variable keinen Nullwert enthalten:

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 kann verwendet werden von Java und Java Codes können mit Kotlin verwendet werden. Wenn Sie also Kenntnisse über Hoppla Programmierung ist es einfach, auf Kotlin-Entwicklung umzusteigen. Auch wenn einige Anwendungen in Java, dann können sie mit der Kotlin-Umgebung verwendet werden.

Robuste Werkzeuge:

Like JavaKotlin-Code kann auch mithilfe der IDE oder der Befehlszeilenschnittstelle geschrieben werden. Das Arbeiten mit der IDE ist einfach und die Anzahl der Syntaxfehler wird drastisch reduziert. Gleichzeitig muss der Code beim Arbeiten mit einer Befehlszeilenschnittstelle zuerst kompiliert werden.

Intelligente Besetzung:

Smart Casting trägt grundsätzlich dazu bei, die Anwendungskosten zu senken und deren Geschwindigkeit bzw. Leistung zu verbessern. Es verwaltet die Effizienz von Code mithilfe von Typumwandlung oder unveränderlichen Werten.

Wenn beispielsweise die Zeichenfolge identifiziert wird, können Länge und Anzahl mithilfe der Smart Cast-Funktion ermittelt werden:

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

Niedrige Einführungskosten:

Kotlin wird von Unternehmen aufgrund der geringeren Einführungskosten bevorzugt. Am wichtigsten ist, dass es für Entwickler leicht zu erlernen ist, insbesondere wenn sie über einen Programmierhintergrund verfügen.

Einrichtung der Kotlin-Umgebung

Im Folgenden finden Sie die Schritte, die Ihnen beim Einrichten einer Arbeitsumgebung durch die Installation von Kotlin helfen.

Schritt 1) ​​Installieren Java

Wie wir bereits besprochen haben, basiert Kotlin auf Java, Sie müssen also installieren Java wenn Sie planen, Kotlin einzuführen. Lesen Sie unsere Java Installations-Tutorial.

Schritt 2) ​​Installieren Java IDEs

Zum Glück gibt es mehrere Java IDEs wählen von. Hier haben wir Download-Links bereitgestellt, um Ihnen die Arbeit etwas zu erleichtern.

• Zum laden der Eclipse, hier klicken.
• Zum laden der NetBeans, hier klicken.
• Um IntelliJ herunterzuladen, hier klicken.

In diesem Kotlin-Tutorial werden wir verwenden Eclipse.

Schritt 3) Installieren Sie Kotlin

Zur Installation von Kotlin in Eclipse, gehen Sie zum Abschnitt „Hilfe“ in Eclipse Und klicken Sie auf die Eclipse Marktplatz-Option.

Geben Sie nun das Schlüsselwort Kotlin in das Suchfeld ein. Klicken Sie auf die Option „Los“, um das Plugin aufzulisten. Sie erhalten einen Link zum Kotlin-Plugin. Sie müssen das Plugin über den angegebenen Link installieren.

Bitte starten Sie das neu Eclipse IDE, sobald die Installation abgeschlossen ist. In der oberen rechten Ecke finden Sie ein Verknüpfungssymbol Eclipse IDE. Es handelt sich um eine Schnellzugriffsmethode.

Eine andere Möglichkeit, auf Kotlin zuzugreifen Eclipse IDE ist, gehen Sie zu Windows, Perspektiven, Perspektiven öffnen, dann die Option Andere wählen. Hier können Sie eine Liste der später installierten Plugins überprüfen, wie unten angegeben.

Nachdem Sie die Kotlin-Installation überprüft haben, erstellen wir im nächsten Schritt das erste Kotlin-Programm.

Schritt 4) Erstes Kotlin-Programm

Beginnen Sie mit Ihrem ersten Kotlin-Projekt. Wählen Sie im Menü „Datei“ die Option „Neu“, wählen Sie dann „Andere“ aus und beginnen Sie mit einem neuen Kotlin-Projekt aus der Liste.

Jetzt müssen Sie einen Namen für das Projekt festlegen und schon können Sie mit Kotlin arbeiten.

Mit diesen einfachen Schritten ist das Herunterladen ganz einfach Eclipse und Kotlin auf Ihrem System und schreiben Sie gleich Ihr erstes Kotlin-Programm.

ArchiTektur von Kotlin

Eine gut aufgebaute Architektur ist wichtig, damit eine Anwendung ihre Funktionen erweitern und die Erwartungen der Endbenutzerbasis erfüllen kann. Kotlin verfügt über eine eigene, besondere und unverwechselbare Architektur, um den Speicher zuzuweisen und qualitativ hochwertige Ergebnisse für Entwickler und Endbenutzer zu erzielen.

Kotlins Coroutinen und Klassen strukturieren den Kern so, dass weniger Boilerplate-Code entsteht, die Leistung verbessert und die Effizienz gesteigert wird. Es gibt eine Vielzahl von Szenarien, in denen der Kotlin-Compiler unterschiedlich reagieren kann, insbesondere wenn er verschiedene Arten von Sprachen vorsieht.

Im Architekturdiagramm ist deutlich zu erkennen, dass die Codeausführung in drei einfachen Schritten erfolgt.

1. Im ersten Schritt wird dem Compiler eine „.kt“- oder Kotlin-Datei hinzugefügt.
2. Im zweiten Schritt wandelt der Kotlin-Compiler den Code in Bytecode um.
3. Im dritten Schritt wird der Bytecode eingefügt Java Virtuelle Maschine und von der JVM ausgeführt.

Wenn ein paar bytecodierte Dateien auf JVM laufen, entfachen sie die gegenseitige Kommunikation untereinander, weshalb die Funktion in Kotlin namens Interoperabilität für Java-Ok-Geburt

Das Durchsickern von Kotlin zu JavaDas Skript wird ausgeführt, wenn Kotlin JavaSkript.

Wenn das JavaDas Ziel des Skripts wird ausgewählt. Jeder Kotlin-Code, der Teil der mit Kotlin laufenden Bibliothek ist, wird dann mit JavaSkript. Allerdings Java Development Kit (JDK) oder jede verwendete Java-Bibliothek ist ausgeschlossen.

Eine Nicht-Kotlin-Datei wird bei einem solchen Vorgang nicht berücksichtigt. Beim Targeting JavaDie .kt-Datei des Skripts wird vom Kotlin-Compiler in ES5.1 konvertiert, um einen konsistenten Code für JavaSkript. Der Kotlin-Compiler bemüht sich um eine optimale Ausgabegröße, Interoperabilität mit vorhandenen Modulen, dieselbe Funktionalität wie die Standardbibliothek und eine Ausgabe, die JavaSkript lesbar.

Aus der Diskussion geht klar hervor, dass Kotlin-Compiler einen effizienteren, kompetenteren und unabhängigeren Code erstellen können, der wiederum zu einem leistungsstarken Softwareprodukt führt.

Kotlin-Variable

Variablen werden zum Speichern von Daten verwendet, die im Programm manipuliert und referenziert werden sollen. Es handelt sich im Grunde genommen um eine Einheit zum Speichern und Beschriften von Daten, die auf einen Expository-Alias ​​wartet, damit das Programm einfach zu lesen und leicht zu verstehen ist. Mit anderen Worten können wir sagen, dass Variablen die Container zum Sammeln von Informationen sind.

In Kotlin sollten alle Variablen deklariert werden. Wenn jedoch eine Variable nicht deklariert ist, handelt es sich um einen Syntaxfehler. Außerdem bestimmt die Deklaration der Variable den Datentyp, den wir in der Variable speichern dürfen. In Kotlin können Variablen mit den Schlüsselwörtern val und var definiert werden. Hier ist die Syntax zum Deklarieren von Variablen in Kotlin:

Var day = "Monday"
Var number = 3

Hier haben wir die lokale Variable day deklariert, deren Wert „Monday' und deren Typ String ist, und eine weitere lokale Variable number, deren Wert 3 ist und deren Typ Int ist, da hier das Literal vom Typ Integer ist, also 3.

Lokale Variablen werden üblicherweise gleichzeitig deklariert und initialisiert. Wir können auch bestimmte Vorgänge ausführen, während wir die Kotlin-Variable initialisieren.

Wir können eine Operation an der Variable desselben Datentyps durchführen, da hier num1 und num2 beide vom gleichen Datentyp Int sind, während day vom Datentyp String ist. Daher wird ein Fehler angezeigt. Hier ist eine weitere Technik, wie Sie Variablen in Kotlin definieren können.

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

Sehen wir uns an, wie sich die Schlüsselwörter var und val voneinander unterscheiden.

Var:

Var ist wie eine generische Variable, die in jeder Programmiersprache verwendet wird und in einem einzigen Programm mehrfach verwendet werden kann. Darüber hinaus können Sie den Wert jederzeit in einem Programm ändern. Daher wird sie als veränderliche Variable bezeichnet.

Hier ist ein Beispiel für eine veränderbare Variable in Kotlin:

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

Hier wird der Wert von num1, der 20 beträgt, durch den vorherigen Wert von num1, der 10 beträgt, überschrieben. Daher ist die Ausgabe von num1 + num2 40 statt 30.

Wert:

Val ist wie eine konstante Variable, deren Wert Sie später im Programm nicht mehr ändern können. Sie kann weder in einem einzigen Programm mehrfach zugewiesen werden, noch kann sie in einem bestimmten Programm nur einmal verwendet werden. Daher wird sie als unveränderliche Variable bezeichnet.

Hier ist ein Kotlin-Programmbeispiel für unveränderliche Variablen in Kotlin:

Val num1 = 10
Var num2 = 20

Hier kann der Wert von num1, der 10 ist, nicht durch den neuen Wert von num1, der 20 ist, überschrieben werden, da es sich um einen konstanten Werttyp handelt. Daher beträgt die Ausgabe 30 statt 40.

Hinweis: In Kotlin werden unveränderliche Variablen gegenüber veränderlichen Variablen bevorzugt.

Datentypen in Kotlin

Datentypen sind Sätze von zuordenbaren Werten und beschreiben die Operationen, die an ihnen durchgeführt werden können. Ähnlich wie andere Programmiersprachen hat auch Kotlin einen vordefinierten Satz von Datentypen wie Int, Boolean, Char, Double, usw.

In Kotlin wird jeder Datentyp als Objekt betrachtet.

Lassen Sie uns nun in diesem Kotlin-Basis-Tutorial tiefer in die vordefinierten Datentypen eintauchen, die in Kotlin verwendet werden.

Numbers :

Kotlin stellt eine Reihe integrierter Datentypen bereit, die als Zahlen bezeichnet werden und in Integer und Floating-Point unterteilt werden können. Numbers.

Ganzzahlen:

Ganze Zahlen sind eine Kategorie von Zahlen, die in vier Typen unterteilt ist:

Typ	Größe (Bit)	Min. Wert	Maximalwert
Byte	8	-128	127
kurz	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)

Gleitkomma Numbers :

Gleitkomma Numbers sind die nicht ganzzahligen Zahlen, die einige Dezimalwerte enthalten.

Float: Float ist ein 32-Bit-Gleitkommawert mit einfacher Genauigkeit.

Beispiel: var: Float x = 3.25600

Double: Double ist ein 64-Bit-Gleitkommawert mit doppelter Genauigkeit.

Beispiel: var: Double y = 2456.345587

Boolesche Werte:

Der Datentyp „Booleans“ in Kotlin ist für die Darstellung der logischen Werte von Bedeutung. Im booleschen Wert gibt es nur zwei mögliche Werte, nämlich wahr oder falsch.

Zum Beispiel: Val Tag = wahr

Wert Tag2 = falsch

Charakter:

Zeichen werden in Kotlin mithilfe des Schlüsselworts char dargestellt. In Kotlin stellen einfache Anführungszeichen die Deklaration von char dar. In Java werden char manchmal als Zahlen verwendet, was in Kotlin nicht möglich ist.

Zum Beispiel:

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

Kotlin-Typkonvertierung oder Kotlin-Typ-Casting

Typkonvertierung ist ein Verfahren zum Konvertieren eines Datenvariablentyps in einen anderen Datentypvariablen. Es ist enorm, auch bekannt als Type Casting.

Vor allem in Java, implizite Typkonvertierung oder implizite Typumwandlung eines kleineren Datentyps zu einem größeren Datentyp wird unterstützt.

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

Allerdings wird in Kotlin die implizite Konvertierung eines kleineren Datentyps in einen größeren Datentyp überhaupt nicht unterstützt, d. h. der Datentyp int kann nicht implizit in einen Datentyp long konvertiert werden.

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

In Kotlin erfolgt die Typkonvertierung jedoch explizit. Hier kommt die Anleitung von Hilfsfunktionen, die die Konvertierung einer Datentypvariablen in eine andere steuern.

Es gibt bestimmte Hilfsfunktionen, die für die Konvertierung eines Datentyps in einen anderen vorgesehen sind:

toInt()

toByte()

zu kurz()

toChar()

zu lang()

schweben()

zuDouble()

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

Kotlin Operatoren

OperaTore sind wichtige und spezielle Zeichen oder Symbole, die Operationen in Operanden sicherstellen, die Variablen und Werte haben. In Kotlin gibt es eine Reihe von Operatoren, die in verschiedenen Operationen wie Rechenoperationen, Zuweisungsoperationen, Vergleichsoperationen usw. verwendet werden.

Arithmetik OperaToren:

Arithmetische Operatoren werden für Addition, Subtraktion, Multiplikation, Division und Modul verwendet.

OperaDo.	Bedeutung
+	Addition (wird auch zur Zeichenfolgenverkettung verwendet)
-	Subtraktion OperaDo.
*	Vervielfältigen OperaDo.
/	Anwendungen OperaDo.
%	Modul OperaDo.

Zum Beispiel:

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

Hier ist die Ausgabe des folgenden Codes 45.

Vergleich OperaToren:

Der Vergleichsoperator wird verwendet, um zwei Werte, zwei Variablen oder zwei Zahlen zu vergleichen. Er wird mit dem Größer-als-Symbol (>), Kleiner-als-Symbol (<) und dem Gleich-Symbol (==), Ungleich-Symbol (!=), Größer-gleich-Symbol (>=), Kleiner-gleich-Symbol (<=) verwendet. Das Ergebnis ist immer „wahr“ oder „falsch“.

Zum Beispiel:

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

Zuordnung OperaToren:

Zuordnung Operators werden verwendet, um die arithmetisch betriebenen Werte zuzuweisen. Sie werden mit Symbolen wie +=, -=, *=, /=, %= verwendet.

Zum Beispiel:

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

Inkrement und Dekrement OperaToren:

Inkrement- und Dekrementoperatoren werden verwendet, um die Werte der Variablen oder Zahl zu erhöhen oder zu verringern. Sie werden mithilfe von Symbolen wie ++ und — verwendet.

Es gibt zwei Arten von Inkrementen und Dekrementen: vor dem Inkrementieren ++a, nach dem Inkrementieren a++, vor dem Dekrementieren –b und nach dem Dekrementieren b–.

Zum Beispiel:

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

Kotlin-Arrays

Ein Array ist der homogene Satz von Datentypen und einer der grundlegendsten Datentypen, der zum Speichern derselben Datentypen an einem zusammenhängenden Speicherort verwendet wird. Ein Array ist für die Organisation von Daten in jeder Programmiersprache von Bedeutung, sodass mehrere an einem einzigen Ort gespeicherte Daten einfach durchsucht oder sortiert werden können.

In Kotlin sind Arrays eine veränderbare Zusammenarbeit derselben Datentypen und keine nativen Datentypen.

Hier sind bestimmte Eigenschaften eines Arrays in Kotlin

• Die Größe des Arrays kann nach der Deklaration nicht mehr geändert werden.
• Arrays in Kotlin sind veränderbar.
• Arrays werden an zusammenhängenden Speicherorten gespeichert.
• Auf ein Array kann mithilfe von Indizes wie a[1], a[2] usw. zugegriffen werden.
• Der Index eines Arrays beginnt bei Null, also a[0].

In Kotlin kann ein Array auf zwei verschiedene Arten definiert werden

Mit der Funktion arrayOf():

In Kotlin werden häufig Bibliotheksfunktionen genutzt. Eine solche Bibliotheksfunktion ist die Funktion arrayOf(), die zum Definieren eines Arrays verwendet wird, indem die Werte der Variablen an die Funktion übergeben werden.

Zum Beispiel: Implizite Typdeklaration eines Arrays mit der Funktion arrayOf()

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

Zum Beispiel: Geben Sie die Array-Deklaration explizit mit der Funktion arrayOf() ein.

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

Mit dem Array-Konstruktor:

In Kotlin gibt es eine Klasse mit dem Namen Array. Daher ist es möglich, ein Array des Konstruktors zum Erstellen eines Arrays zu verwenden. Das Array im Konstruktor enthält zwei Hauptparameter.

Was ist der Index eines Arrays in Kotlin?

Die Funktion, bei der ein Array-Index den Anfangswert des Index zurückgeben kann.

Zum Beispiel:

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

Hier ist der Wert des Arrays 7 und der Lambda-Ausdruck wird verwendet, um die Werte des Elements zu initialisieren.

Es gibt auch verschiedene Methoden, um mithilfe bestimmter Funktionen auf die Arrays zuzugreifen und diese zu ändern. Daher gibt es zwei Mitgliedsfunktionen get() und set(), die für den Zugriff auf die Objekte des Klassenarrays verwendet werden.

Zum Beispiel:

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

Hier ist die Ausgabe 10, da der Wert am Index 0 des Arrays 10 ist

Hinweis: get() akzeptiert nur einzelne Werte

Zum Beispiel:

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

Ausgabe: 30 40

Hier ist die Ausgabe 30 und 40, da der Wert am Index 2 des Arrays 30 und am Index 3 40 ist.

Hinweis: set() akzeptiert mehrere Werte eines Arrays.

Kotlin-Strings

Ein String ist ein grundlegender Datentyp in jeder Programmiersprache. Ein String ist nichts anderes als eine Folge von Zeichen. Die String-Klasse repräsentiert Zeichenfolgen. In Kotlin sind alle Strings Objekte der String-Klasse, was bedeutet, dass String-Literale als Instanzen der Klasse implementiert werden.

Syntax:

 Val myString = "Hey there!"

Kotlin-Sammlung

Eine Sammlung enthält mehrere Objekte eines ähnlichen Typs. Diese Objekte in der Sammlung werden als Elemente oder Elemente bezeichnet. Die Sammlung kann dabei helfen, Daten zu speichern, abzurufen, zu bearbeiten und zu aggregieren.

Arten von Sammlungen:

Unveränderliche Sammlung

Diese Art von Sammlung unterstützt schreibgeschützte Funktionen. Man kann seine Elemente nicht ändern.

Methoden umfassen:

• Liste – listOf() und listOf ()
• Set – setOf()
• Karte – mapOf()

Veränderbare Sammlung

Es unterstützt sowohl Lese- als auch Schreibfunktionen.

Zu den Methoden gehören

• Liste – mutableListOf(), arrayListOf() und ArrayList
• Set – mutableSetOf(), hashSetOf()
• Karte – mutableMapOf(), hashMapOf() und HashMap

Kotlin-Funktionen

Funktionen sind in jeder Programmiersprache eine Gruppe ähnlicher Anweisungen, die dazu bestimmt sind, eine bestimmte Aufgabe auszuführen. Funktionen ermöglichen es einem Programm, ihn in verschiedene kleine Codeblöcke zu unterteilen. Diese Aufteilung des Codes erhöht die Lesbarkeit des Codes, die Wiederverwendbarkeit des Codes und erleichtert die Verwaltung eines Programms.

Kotlin ist als statisch typisierte Sprache bekannt. Hier wird das Schlüsselwort „fun“ verwendet, um eine Funktion zu deklarieren. In Kotlin gibt es zwei Arten von Funktionen, die ausschließlich von ihrer Verfügbarkeit in der Standardbibliothek oder Benutzerdefinition abhängen. Sie sind:

• Standardbibliotheksfunktion
• Benutzerdefinierte Funktion

Lassen Sie uns sie nun anhand von Kotlin-Codebeispielen ausführlich besprechen.

Standardbibliotheksfunktion

Dabei handelt es sich um integrierte Bibliotheksfunktionen, die implizit definiert und zur Verwendung verfügbar sind.

Zum Beispiel 2:

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

Ausgang:

3.0

sqrt() ist eine in der Bibliothek definierte Funktion, die die Quadratwurzel einer Zahl zurückgibt.

Die Funktion print() druckt die Nachricht in einen Standardausgabestream.

Benutzerdefinierte Funktion

Wie der Name schon sagt, werden diese Funktionen normalerweise von Benutzern erstellt und können für die erweiterte Programmierung verwendet werden.

Hier werden Funktionen mit dem Schlüsselwort „fun“ deklariert.

Zum Beispiel 3:

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

Hier rufen wir die Funktion auf, um Codes innerhalb des Körpers auszuführen. functionName()

Beispiele für Kotlin-Funktionen:

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

Ausgang:

Summe = 17

Code nach Summe

Ausnahmebehandlung in Kotlin

Eine Ausnahme in der Programmierung wird als ein Laufzeitproblem definiert, das im Programm auftritt und zum Abbruch des Programms führt. Dieses Problem kann aufgrund von weniger Speicherplatz, fehlender Bindung des Arrays oder Bedingungen wie Division durch Null auftreten. Um diese Art von Problemen bei der Codeausführung einzudämmen, wird die Ausnahmebehandlung verwendet.

Unter Ausnahmebehandlung versteht man die Technik, die Laufzeitprobleme behandelt und außerdem den Programmfluss während der Ausführung aufrechterhält.

Kotlin verwendet den Ausdruck „throw“, um ein Ausnahmeobjekt auszulösen. Hier sind alle Ausnahmeklassen Nachkommen der Klasse Throwable.

Throw MyException („löst Ausnahme aus“)

Bei der Ausnahmebehandlung gibt es vier Arten von Ausnahmen. Sie sind:

• try – Dieser Block enthält Anweisungen, die möglicherweise die Ausnahme erzeugen. Es folgt immer entweder „catch“ oder „finally“ oder beides.
• Catch – es fängt eine Ausnahme ab, die vom Try-Block ausgelöst wird.
• final – Es prüft immer, ob die Ausnahme behandelt wird oder nicht.
• throw – Wird verwendet, um explizit eine Ausnahme auszulösen.

Versuchen Sie es mit Fang:

Im Try-Catch-Block bei der Ausnahmebehandlung schließt der Try-Block den Code ein, der möglicherweise eine Ausnahme auslöst, und der Catch-Block fängt den Ausdruck ab und verarbeitet ihn.

Syntax des Try-Catch-Blocks:

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

Syntax von „try“ mit „finally“-Block

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

Schließlich:

In Kolin prüft der Block „finally“ immer, ob die Ausnahme behandelt wird oder nicht, was ihn zu einer sehr wichtigen Anweisung zur Ausnahmebehandlung macht.

Zum Beispiel 4:

In diesem Codeausschnitt tritt die Ausnahme auf und wird behandelt.

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

Ausgang:

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

Werfen:

Der Throw-Block löst eine explizite Ausnahme aus. Darüber hinaus wird es zum Auslösen benutzerdefinierter Ausnahmen verwendet.

Syntax:

Throw SomeException()

Throw SomeException()

Ejemplo:

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

Ausgang:

Kotlin Null Safety

Bei den Systemtypen, die Kotlin unterstützen, wird hauptsächlich zwischen Referenzen unterschieden, die Nullable-Referenzen enthalten können, und solchen, die keine Nullable-Referenzen enthalten können. Kotlin ist eine Null-Sicherheitssprache, die darauf abzielt, die Nullzeiger-Ausnahme oder Null-Referenz aus dem Code zu eliminieren, der bewusst als A bezeichnet wird BillIon-Dollar-Fehler.

Der konventionellste Stolperstein von vielen Programmiersprachen ist, dass beim Zugriff auf ein Mitglied einer Nullreferenz eine NullPointerException auftritt, was daran liegen könnte, dass der Operator !! oder dieser Konstruktor an einer anderen Stelle verwendet und an einer anderen Stelle des Codes übergeben wurde. Die Nullable-Eigenschaft erfordert jedes Mal vor ihrer Verwendung eine Bestätigung der Nullprüfung.

In Kotlin unterscheidet das System zwischen Null-Referenzen und Nicht-Null-Referenzen.

Beispielsweise darf eine String-Variable keinen Nullwert enthalten:

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

Ausgang:

Kotlin OOPs

Der objektorientierte Programmieransatz ermöglicht es, einen komplexen Codeausschnitt durch die Erstellung von Objekten in kleinere Codeblöcke aufzuteilen. Diese Objekte haben zwei gemeinsame Eigenschaften: Status und Verhalten.

Hier sind einige der OOPs-Elemente, die wir anhand von Kotlin-Codebeispielen besprechen werden:

• Klasse und Objekte
• Konstruktoren
• Erbe
• Abstrakte Klasse

Klasse in Kotlin

Bevor wir ein Objekt erstellen, müssen wir zunächst eine Klasse definieren, die auch als Blaupause für das Objekt bezeichnet wird.

Syntax:

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

Objekte in Kotlin

Beim Definieren einer Klasse definieren wir nur die Spezifikationen für das Objekt, es werden keine anderen Parameter wie Speicher oder Speicherplatz zugewiesen.

Syntax:

var obj1 = ClassName()

Konstrukteure in Kotlin

Ein Konstruktor ist eine Möglichkeit, Klasseneigenschaften zu initialisieren. Es handelt sich um eine Mitgliedsfunktion, die aufgerufen wird, wenn ein Objekt instanziiert wird. Aber in Kotlin funktioniert es anders.

Es gibt zwei Arten von Konstruktoren in Kotlin:

Primärer Konstruktor: Optimierte Methode zum Initialisieren einer Klasse

Syntax:

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

Sekundärer Konstruktor: Hilft beim Hinzufügen der Initialisierungslogik

Kotlin-Vererbung

Die Vererbung erfolgt, wenn einige Eigenschaften der übergeordneten Klasse von der untergeordneten Klasse übernommen werden. Vererbung ist zulässig, wenn zwei oder mehr Klassen dieselben Eigenschaften haben.

Syntax:

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

Abstrakte Klasse in Kotlin

Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann, von der wir jedoch Unterklassen erben können. Das Schlüsselwort „abstract“ wird zum Deklarieren einer abstrakten Klasse verwendet.

Zum Beispiel 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() 
} 

Ausgang:

Die Gegenwart und Zukunft von Kotlin

Das Geschenk:

• Viele Unternehmen mögen Netflix, Pinterest und Corda nutzen Kotlin, um leistungsstarke Inhalte zu erstellen Android Apps.
• In einem kurzen Zeitraum von einem Jahr, von 2016 bis 2017, erfreute sich Kotlin mit seinen erstaunlichen Programmierfunktionen großer Beliebtheit.
• Im Jahr 2017 kündigte Google Kotlin als offizielle Programmiersprache für die Android-Entwicklung an.
• Sie können schnell ersetzen Java Code mit Kotlin, da es 100% interoperabel ist mit Java , Android.

Die Zukunft:

• Plattformübergreifende Spieleentwicklung
• Plattformübergreifende Entwicklung mobiler Apps
• Serviceseitiges Scripting und Microservices
• Maschinelles Lernen & Datenanalyse

Zusammenfassung

• Kotlin ist eine 2010 von JetBrains vorgeschlagene Programmiersprache für Multiplattform-Apps unter der Apache 2.0-Lizenz.
• Der Name Kotlin leitet sich vom Namen der Insel Kotlin ab, in einer ähnlichen Entsprechung von Java nach dem Namen einer Insel namens Java.
• Im Jahr 2016 wurde die erste Version von Kotlin v1.0 veröffentlicht
• Kotlin-Programme benötigen keine Semikolons in ihrem Programm. Dies macht den Code einfach und lesbarer.
• Kotlin für Android Developers ist eine OOPs-basierte Programmiersprache, bei der die Codezeile um bis zu 40 % gekürzt werden kann, was Kotlin zu einer idealen Wahl für Software- oder Webentwicklung macht.
• In Kotlin sollten alle Variablen mit den Schlüsselwörtern var und val deklariert werden.
• Ähnlich wie andere Programmiersprachen verfügt auch Kotlin über vordefinierte Datentypen wie Int, Boolean, Char, Double, usw.
• In Kotlin gibt es eine Reihe von Operatoren, die in verschiedenen Operationen wie Rechenoperationen, Zuweisungsoperationen, Vergleichsoperationen usw. verwendet werden.
• In Kotlin sind Arrays eine veränderbare Zusammenarbeit derselben Datentypen und keine nativen Datentypen.
• In Kotlin werden Arrays mit zwei Methoden definiert – ArrayOF() und Constructors.
• Kotlin ist eine Null-Sicherheitssprache, die dabei hilft, die Nullzeiger-Ausnahme oder Null-Referenz aus dem Code zu entfernen, der bewusst als A bezeichnet wird BillIon-Dollar-Fehler.