Kotlin - Kurzanleitung
Kotlin ist eine neue Open-Source-Programmiersprache wie Java, JavaScript usw. Es handelt sich um eine stark statisch typisierte Hochsprache, die funktionale und technische Teile an derselben Stelle kombiniert. Derzeit zielt Kotlin auf Java und JavaScript ab. Es läuft auf JVM.
Kotlin wird von anderen Programmiersprachen wie Java, Scala, Groovy, Gosu usw. beeinflusst. Die Syntax von Kotlin ist JAVA möglicherweise nicht genau ähnlich. Intern ist Kotlin jedoch auf die vorhandene Java-Klassenbibliothek angewiesen, um wunderbare Ergebnisse für die Programmierer zu erzielen . Kotlin bietet Entwicklern auf der ganzen Welt Interoperabilität, Codesicherheit und Klarheit.
Vorteile und Nachteile
Im Folgenden finden Sie einige Vorteile der Verwendung von Kotlin für Ihre Anwendungsentwicklung.
Easy Language- Kotlin ist eine funktionale Sprache und sehr leicht zu lernen. Die Syntax ist Java ziemlich ähnlich, daher ist es sehr leicht, sich daran zu erinnern. Kotlin ist ausdrucksstärker, wodurch Ihr Code lesbarer und verständlicher wird.
Concise- Kotlin basiert auf JVM und ist eine funktionale Sprache. Dadurch wird viel Kesselplattencode reduziert, der in anderen Programmiersprachen verwendet wird.
Runtime and Performance - Bessere Leistung und kleine Laufzeit.
Interoperability - Kotlin ist ausgereift genug, um eine interoperable Anwendung auf weniger komplexe Weise zu erstellen.
Brand New- Kotlin ist eine brandneue Sprache, die Entwicklern einen Neuanfang ermöglicht. Es ist kein Ersatz für Java, obwohl es über JVM entwickelt wurde. Es wird als erste offizielle Sprache der Android-Entwicklung akzeptiert. Kotlin kann definiert werden als - Kotlin = JAVA + extra aktualisierte neue Funktionen.
Im Folgenden sind einige der Nachteile von Kotlin aufgeführt.
Namespace declaration- Mit Kotlin können Entwickler die Funktionen auf der obersten Ebene deklarieren. Wenn jedoch an vielen Stellen Ihrer Anwendung dieselbe Funktion deklariert wird, ist es schwer zu verstehen, welche Funktion aufgerufen wird.
No Static Declaration - Kotlin verfügt nicht über den üblichen statischen Handhabungsmodifikator wie Java, was dem herkömmlichen Java-Entwickler Probleme bereiten kann.
Wenn Sie Kotlin jedoch weiterhin offline in Ihrem lokalen System verwenden möchten, müssen Sie die folgenden Schritte ausführen, um Ihren lokalen Arbeitsbereich zu konfigurieren.
Step 1 - Java 8-Installation.
Kotlin läuft daher auf JVM. Es ist wirklich notwendig, JDK 8 für Ihre lokale Kotlin-Entwicklung zu verwenden. Informationen zum Herunterladen und Installieren von JDK 8 oder einer der oben genannten Versionen finden Sie auf der offiziellen Website von oracle . Möglicherweise müssen Sie die Umgebungsvariable für JAVA so einstellen, dass sie ordnungsgemäß funktioniert. Um Ihre Installation unter Windows zu überprüfen, klicken Sie in der Eingabeaufforderung auf "java –version". Als Ausgabe wird die auf Ihrem System installierte Java-Version angezeigt.
Step 2 - IDE-Installation.
Es gibt eine Reihe von IDE über das Internet verfügbar. Sie können jede Ihrer Wahl verwenden. Den Download-Link der verschiedenen IDE finden Sie in der folgenden Tabelle.
| IDE Name | Installationslink |
|---|---|
| NetBeans | https://netbeans.org/downloads/ |
| Finsternis | https://www.eclipse.org/downloads/ |
| Intellij | https://www.jetbrains.com/idea/download/#section = windows |
Es wird immer empfohlen, die aktuelle Softwareversion zu verwenden, um die maximale Funktionalität daraus zu ziehen.
Step 3 - Eclipse konfigurieren.
Öffnen Sie Eclipse und gehen Sie zu "Eclipse Market Place". Sie finden den folgenden Bildschirm.
Suchen Sie im Suchfeld nach Kotlin und installieren Sie es auf Ihrem lokalen System. Je nach Internetgeschwindigkeit kann dies einige Zeit dauern. Möglicherweise müssen Sie Eclipse nach erfolgreicher Installation neu starten.
Step 4 - Kotlin-Projekt.
Sobald Eclipse erfolgreich neu gestartet und Kotlin installiert wurde, können Sie ein Kotlin-Projekt im laufenden Betrieb erstellen. Gehe zuFile → New → Others und wählen Sie "Kotlin-Projekt" aus der Liste.
Sobald die Projekteinrichtung abgeschlossen ist, können Sie eine Kotlin-Datei im Ordner „SRC“ erstellen. Klicken Sie mit der linken Maustaste auf den Ordner "Src" und klicken Sie auf "Neu". Sie erhalten eine Option für die Kotlin-Datei, andernfalls müssen Sie möglicherweise nach den "anderen" suchen. Sobald die neue Datei erstellt wurde, sieht Ihr Projektverzeichnis wie folgt aus.
Ihre Entwicklungsumgebung ist jetzt bereit. Fügen Sie den folgenden Code in die Datei „Hello.kt“ ein.
fun main(args: Array<String>) {
println("Hello, World!")
}Führen Sie es als Kotlin-Anwendung aus und sehen Sie die Ausgabe in der Konsole, wie im folgenden Screenshot gezeigt. Zum besseren Verständnis und zur Verfügbarkeit verwenden wir unser Coding Ground Tool.
Hello, World!Kotlin ist eine Programmiersprache und verfügt über eine eigene Architektur, um Speicher zuzuweisen und dem Endbenutzer eine qualitativ hochwertige Ausgabe zu liefern. Im Folgenden sind die verschiedenen Szenarien aufgeführt, in denen der Kotlin-Compiler unterschiedlich funktioniert, wenn er auf andere Arten von Sprachen wie Java und JavaScript abzielt.
Der Kotlin-Compiler erstellt einen Bytecode und dieser Bytecode kann auf der JVM ausgeführt werden, was genau dem von Java generierten Bytecode entspricht .classDatei. Immer wenn zwei bytecodierte Dateien auf der JVM ausgeführt werden, können sie miteinander kommunizieren. Auf diese Weise wird in Kotlin für Java eine interoperable Funktion eingerichtet.
Immer wenn Kotlin auf JavaScript abzielt, konvertiert der Kotlin-Compiler das .ktDatei in ES5.1 und generiert einen kompatiblen Code für JavaScript. Der Kotlin-Compiler kann plattformbasierte Kompatibilitätscodes über LLVM erstellen.
In diesem Kapitel lernen wir die grundlegenden Datentypen kennen, die in der Programmiersprache Kotlin verfügbar sind.
Zahlen
Die Darstellung von Zahlen in Kotlin ist Java ziemlich ähnlich, Kotlin erlaubt jedoch keine interne Konvertierung verschiedener Datentypen. In der folgenden Tabelle sind verschiedene variable Längen für verschiedene Zahlen aufgeführt.
| Art | Größe |
|---|---|
| Doppelt | 64 |
| Schweben | 32 |
| Lange | 64 |
| Int | 32 |
| Kurz | 16 |
| Byte | 8 |
Im folgenden Beispiel sehen wir, wie Kotlin mit verschiedenen Datentypen arbeitet. Bitte geben Sie den folgenden Codesatz in unsere Codierungsgrundlage ein.
fun main(args: Array<String>) {
val a: Int = 10000
val d: Double = 100.00
val f: Float = 100.00f
val l: Long = 1000000004
val s: Short = 10
val b: Byte = 1
println("Your Int Value is "+a);
println("Your Double Value is "+d);
println("Your Float Value is "+f);
println("Your Long Value is "+l);
println("Your Short Value is "+s);
println("Your Byte Value is "+b);
}Wenn Sie den obigen Code im Codierungsbereich ausführen, wird die folgende Ausgabe in der Webkonsole generiert.
Your Int Value is 10000
Your Double Value is 100.0
Your Float Value is 100.0
Your Long Value is 1000000004
Your Short Value is 10
Your Byte Value is 1Zeichen
Kotlin repräsentiert die Verwendung von Zeichen char. Zeichen sollte in einem einfachen Anführungszeichen wie deklariert werden‘c’. Bitte geben Sie den folgenden Code in unseren Codierungsgrund ein und sehen Sie, wie Kotlin die Zeichenvariable interpretiert. Zeichenvariable kann nicht wie Zahlenvariable deklariert werden. Die Kotlin-Variable kann auf zwei Arten deklariert werden - eine mit“var” und eine andere Verwendung “val”.
fun main(args: Array<String>) {
val letter: Char // defining a variable
letter = 'A' // Assigning a value to it
println("$letter")
}Der obige Code liefert die folgende Ausgabe im Browser-Ausgabefenster.
ABoolescher Wert
Boolean ist wie andere Programmiersprachen sehr einfach. Wir haben nur zwei Werte für Boolean - entweder wahr oder falsch. Im folgenden Beispiel werden wir sehen, wie Kotlin Boolean interpretiert.
fun main(args: Array<String>) {
val letter: Boolean // defining a variable
letter = true // Assinging a value to it
println("Your character value is "+"$letter")
}Der obige Code liefert die folgende Ausgabe im Browser.
Your character value is trueSaiten
Zeichenfolgen sind Zeichenarrays. Wie Java sind sie von Natur aus unveränderlich. Wir haben zwei Arten von Zeichenfolgen in Kotlin - eine heißtraw String und ein anderer heißt escaped String. Im folgenden Beispiel werden wir diese Zeichenfolgen verwenden.
fun main(args: Array<String>) {
var rawString :String = "I am Raw String!"
val escapedString : String = "I am escaped String!\n"
println("Hello!"+escapedString)
println("Hey!!"+rawString)
}Das obige Beispiel für einen maskierten String ermöglicht es, nach der ersten print-Anweisung zusätzlichen Zeilenabstand bereitzustellen. Es folgt die Ausgabe im Browser.
Hello!I am escaped String!
Hey!!I am Raw String!Arrays
Arrays sind eine Sammlung homogener Daten. Kotlin unterstützt wie Java Arrays unterschiedlicher Datentypen. Im folgenden Beispiel werden verschiedene Arrays verwendet.
fun main(args: Array<String>) {
val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
println("Hey!! I am array Example"+numbers[2])
}Der obige Code liefert die folgende Ausgabe. Die Indizierung des Arrays ähnelt anderen Programmiersprachen. Hier suchen wir nach einem zweiten Index, dessen Wert "3" ist.
Hey!! I am array Example3Sammlungen
Die Erfassung ist ein sehr wichtiger Teil der Datenstruktur, der Ingenieuren die Softwareentwicklung erleichtert. Kotlin hat zwei Arten von Sammlungen - eine istimmutable collection (was bedeutet, Listen, Karten und Sets, die nicht bearbeitet werden können) und eine andere ist mutable collection(Diese Art der Sammlung kann bearbeitet werden). Es ist sehr wichtig, die Art der in Ihrer Anwendung verwendeten Sammlung zu berücksichtigen, da das Kotlin-System keinen spezifischen Unterschied zwischen ihnen darstellt.
fun main(args: Array<String>) {
val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List
val readOnlyView: List<Int> = numbers // immutable list
println("my mutable list--"+numbers) // prints "[1, 2, 3]"
numbers.add(4)
println("my mutable list after addition --"+numbers) // prints "[1, 2, 3, 4]"
println(readOnlyView)
readOnlyView.clear() // ⇒ does not compile
// gives error
}Der obige Code liefert die folgende Ausgabe im Browser. Es gibt einen Fehler, wenn wir versuchen, die veränderbare Liste der Sammlung zu löschen.
main.kt:9:18: error: unresolved reference: clear
readOnlyView.clear() // -> does not compile
^In der Sammlung bietet Kotlin einige nützliche Methoden wie first(), last(), filter()usw. Alle diese Methoden sind selbstbeschreibend und einfach zu implementieren. Darüber hinaus folgt Kotlin bei der Implementierung der Sammlung der gleichen Struktur wie Java. Es steht Ihnen frei, eine Sammlung Ihrer Wahl wie Map und Set zu implementieren.
Im folgenden Beispiel haben wir Map und Set mit verschiedenen integrierten Methoden implementiert.
fun main(args: Array<String>) {
val items = listOf(1, 2, 3, 4)
println("First Element of our list----"+items.first())
println("Last Element of our list----"+items.last())
println("Even Numbers of our List----"+items.
filter { it % 2 = = 0 }) // returns [2, 4]
val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
println(readWriteMap["foo"]) // prints "1"
val strings = hashSetOf("a", "b", "c", "c")
println("My Set Values are"+strings)
}Der obige Code liefert die folgende Ausgabe im Browser.
First Element of our list----1
Last Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]Bereiche
Ranges ist ein weiteres einzigartiges Merkmal von Kotlin. Wie Haskell bietet es einen Operator, mit dem Sie einen Bereich durchlaufen können. Intern wird es mit implementiertrangeTo() und seine Operatorform ist (..).
Im folgenden Beispiel sehen wir, wie Kotlin diesen Bereichsoperator interpretiert.
fun main(args: Array<String>) {
val i:Int = 2
for (j in 1..4)
print(j) // prints "1234"
if (i in 1..10) { // equivalent of 1 < = i && i < = 10
println("we found your number --"+i)
}
}Der obige Code liefert die folgende Ausgabe im Browser.
1234we found your number --2Im vorherigen Kapitel haben wir verschiedene Arten von Datentypen kennengelernt, die im Kotlin-System verfügbar sind. In diesem Kapitel werden wir verschiedene Arten von Kontrollflussmechanismen diskutieren, die im Kotlin verfügbar sind.
Ansonsten
Kotlin ist eine funktionale Sprache, daher wie jede funktionale Sprache in Kotlin “if”ist ein Ausdruck, es ist kein Schlüsselwort. Der Ausdruck“if”gibt bei Bedarf einen Wert zurück. Wie andere Programmiersprachen,“if-else”Der Block wird als anfänglicher Bedingungsprüfungsoperator verwendet. Im folgenden Beispiel werden zwei Variablen verglichen und die erforderliche Ausgabe entsprechend bereitgestellt.
fun main(args: Array<String>) {
val a:Int = 5
val b:Int = 2
var max: Int
if (a > b) {
max = a
} else {
max = b
}
print("Maximum of a or b is " +max)
// As expression
// val max = if (a > b) a else b
}Der obige Code liefert die folgende Ausgabe als Ergebnis im Browser. Unser Beispiel enthält auch eine weitere Codezeile, in der die Verwendung beschrieben wird“If” Aussage als Ausdruck.
Maximum of a or b is 5Verwendung von Wann
Wenn Sie mit anderen Programmiersprachen vertraut sind, haben Sie möglicherweise von dem Begriff switch-Anweisung gehört, der im Grunde ein bedingter Operator ist, wenn mehrere Bedingungen auf eine bestimmte Variable angewendet werden können. “when”Der Operator vergleicht den Variablenwert mit den Verzweigungsbedingungen. Wenn die Verzweigungsbedingung erfüllt ist, wird die Anweisung in diesem Bereich ausgeführt. Im folgenden Beispiel erfahren Sie mehr über das „Wann“ in Kotlin.
fun main(args: Array<String>) {
val x:Int = 5
when (x) {
1 -> print("x = = 1")
2 -> print("x = = 2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}Der obige Code liefert die folgende Ausgabe im Browser.
x is neither 1 nor 2Im obigen Beispiel entspricht der Kotlin-Compiler dem Wert von xmit den gegebenen Zweigen. Wenn es keinem der Zweige entspricht, wird der else-Teil ausgeführt. In der Praxis entspricht when mehreren if-Blöcken. Kotlin bietet dem Entwickler eine weitere Flexibilität, bei der der Entwickler mehrere Überprüfungen in derselben Zeile bereitstellen kann, indem er "," in den Überprüfungen angibt. Lassen Sie uns das obige Beispiel wie folgt modifizieren.
fun main(args: Array<String>) {
val x:Int = 5
when (x) {
1,2 -> print(" Value of X either 1,2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}Führen Sie dasselbe im Browser aus, wodurch die folgende Ausgabe im Browser angezeigt wird.
x is neither 1 nor 2Für Schleife
Loop ist eine solche Erfindung, die die Flexibilität bietet, jede Art von Datenstruktur zu durchlaufen. Wie andere Programmiersprachen bietet Kotlin jedoch auch viele Arten von Looping-Methoden an“For”ist der erfolgreichste. Die Implementierung und Verwendung der For-Schleife ähnelt konzeptionell der Java-for-Schleife. Das folgende Beispiel zeigt, wie wir dasselbe in realen Beispielen verwenden können.
fun main(args: Array<String>) {
val items = listOf(1, 2, 3, 4)
for (i in items) println("values of the array"+i)
}Im obigen Code haben wir eine Liste mit dem Namen "items" deklariert. Mit der for-Schleife durchlaufen wir diese definierte Liste und drucken ihren Wert im Browser. Es folgt die Ausgabe.
values of the array1
values of the array2
values of the array3
values of the array4Im Folgenden finden Sie ein weiteres Beispiel für Code, bei dem wir einige Bibliotheksfunktionen verwenden, um unsere Entwicklungsarbeit einfacher als je zuvor zu gestalten.
fun main(args: Array<String>) {
val items = listOf(1, 22, 83, 4)
for ((index, value) in items.withIndex()) {
println("the element at $index is $value")
}
}Sobald wir den obigen Code in unserem Codierungsgrund kompiliert und ausgeführt haben, wird die folgende Ausgabe im Browser ausgegeben.
the element at 0 is 1
the element at 1 is 22
the element at 2 is 83
the element at 3 is 4While-Schleife und Do-While-Schleife
While und Do-While funktionieren genauso wie in anderen Programmiersprachen. Der einzige Unterschied zwischen diesen beiden Schleifen besteht darin, dass im Fall einer Do-while-Schleife die Bedingung am Ende der Schleife getestet wird. Das folgende Beispiel zeigt die Verwendung vonWhile loop.
fun main(args: Array<String>) {
var x:Int = 0
println("Example of While Loop--")
while(x< = 10) {
println(x)
x++
}
}Der obige Code liefert die folgende Ausgabe im Browser.
Example of While Loop--
0
1
2
3
4
5
6
7
8
9
10Kotlin hat auch eine andere Schleife namens Do-While-Schleife, in der der Schleifenkörper einmal ausgeführt wird, nur dann wird die Bedingung überprüft. Das folgende Beispiel zeigt die Verwendung vonDo-while loop.
fun main(args: Array<String>) {
var x:Int = 0
do {
x = x + 10
println("I am inside Do block---"+x)
} while(x <= 50)
}Der obige Code liefert die folgende Ausgabe im Browser. Im obigen Code führt der Kotlin-Compiler den DO-Block aus und führt dann die Zustandsüberprüfung während des Blocks durch.
I am inside Do block---10
I am inside Do block---20
I am inside Do block---30
I am inside Do block---40
I am inside Do block---50
I am inside Do block---60Verwendung von Return, Break, Continue
Wenn Sie mit einer Programmiersprache vertraut sind, müssen Sie eine Vorstellung von verschiedenen Schlüsselwörtern haben, die uns helfen, einen guten Kontrollfluss in der Anwendung zu implementieren. Im Folgenden sind die verschiedenen Schlüsselwörter aufgeführt, mit denen die Schleifen oder andere Arten von Steuerungsabläufen gesteuert werden können.
Return- Return ist ein Schlüsselwort, das von der aufgerufenen Funktion einen Wert an die aufrufende Funktion zurückgibt. Im folgenden Beispiel implementieren wir dieses Szenario mithilfe unserer Kotlin-Codierungsgrundlage.
fun main(args: Array<String>) {
var x:Int = 10
println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int {
return 2*x;
}Im obigen Code rufen wir eine andere Funktion auf, multiplizieren die Eingabe mit 2 und geben den resultierenden Wert an die aufgerufene Funktion zurück, die unsere Hauptfunktion ist. Kotlin definiert die Funktion auf eine andere Art und Weise, die wir in einem nachfolgenden Kapitel betrachten werden. Im Moment reicht es zu verstehen, dass der obige Code die folgende Ausgabe im Browser generiert.
The value of X is--20Continue & Break- Fortfahren und Unterbrechen sind der wichtigste Teil eines logischen Problems. Das Schlüsselwort "break" beendet den Controller-Fluss, wenn eine Bedingung fehlgeschlagen ist, und "continue" bewirkt das Gegenteil. All diese Vorgänge erfolgen mit sofortiger Sichtbarkeit. Kotlin ist intelligenter als andere Programmiersprachen, bei denen der Entwickler mehr als ein Etikett als Sichtbarkeit verwenden kann. Der folgende Code zeigt, wie wir dieses Label in Kotlin implementieren.
fun main(args: Array<String>) {
println("Example of Break and Continue")
myLabel@ for(x in 1..10) { // appling the custom label
if(x = = 5) {
println("I am inside if block with value"+x+"\n-- hence it will close the operation")
break@myLabel //specifing the label
} else {
println("I am inside else block with value"+x)
continue@myLabel
}
}
}Der obige Code liefert die folgende Ausgabe im Browser.
Example of Break and Continue
I am inside else block with value1
I am inside else block with value2
I am inside else block with value3
I am inside else block with value4
I am inside if block with value5
-- hence it will close the operationWie Sie sehen können, setzt der Controller die Schleife fort, bis der Wert von x ist 5. Sobald der Wert von x erreicht 5, beginnt die Ausführung des if-Blocks und sobald die break-Anweisung erreicht ist, beendet der gesamte Kontrollfluss die Programmausführung.
In diesem Kapitel lernen wir die Grundlagen der objektorientierten Programmierung (OOP) mit Kotlin kennen. Wir werden etwas über die Klasse und ihr Objekt lernen und wie man mit diesem Objekt spielt. Nach der Definition von OOP ist eine Klasse eine Blaupause einer Laufzeitentität, und das Objekt ist ihr Status, der sowohl sein Verhalten als auch seinen Status umfasst. In Kotlin besteht die Klassendeklaration aus einem Klassenkopf und einem Klassenkörper, die ähnlich wie Java von geschweiften Klammern umgeben sind.
Class myClass { // class Header
// class Body
}Wie Java ermöglicht Kotlin auch das Erstellen mehrerer Objekte einer Klasse, und Sie können die Klassenmitglieder und Funktionen einschließen. Wir können die Sichtbarkeit der Variablen der Klassenmitglieder mithilfe verschiedener Schlüsselwörter steuern, die wir in Kapitel 10 - Sichtbarkeitskontrolle lernen werden. Im folgenden Beispiel erstellen wir eine Klasse und ihr Objekt, über die wir auf verschiedene Datenelemente dieser Klasse zugreifen.
class myClass {
// property (data member)
private var name: String = "Tutorials.point"
// member function
fun printMe() {
print("You are at the best Learning website Named-"+name)
}
}
fun main(args: Array<String>) {
val obj = myClass() // create obj object of myClass class
obj.printMe()
}Der obige Code liefert die folgende Ausgabe im Browser, in dem wir printMe () von myClass mit einem eigenen Objekt aufrufen.
You are at the best Learning website Named- Tutorials.pointVerschachtelte Klasse
Wenn eine Klasse in einer anderen Klasse erstellt wurde, wird sie per Definition als verschachtelte Klasse bezeichnet. In Kotlin ist die verschachtelte Klasse standardmäßig statisch, daher kann auf sie zugegriffen werden, ohne ein Objekt dieser Klasse zu erstellen. Im folgenden Beispiel sehen wir, wie Kotlin unsere verschachtelte Klasse interpretiert.
fun main(args: Array<String>) {
val demo = Outer.Nested().foo() // calling nested class method
print(demo)
}
class Outer {
class Nested {
fun foo() = "Welcome to The TutorialsPoint.com"
}
}Der obige Code liefert die folgende Ausgabe im Browser.
Welcome to The TutorialsPoint.comInnere Klasse
Wenn eine verschachtelte Klasse als „innere“ Klasse markiert ist, wird sie als innere Klasse bezeichnet. Auf eine innere Klasse kann das Datenelement der äußeren Klasse zugreifen. Im folgenden Beispiel greifen wir auf das Datenelement der äußeren Klasse zu.
fun main(args: Array<String>) {
val demo = Outer().Nested().foo() // calling nested class method
print(demo)
}
class Outer {
private val welcomeMessage: String = "Welcome to the TutorialsPoint.com"
inner class Nested {
fun foo() = welcomeMessage
}
}Der obige Code liefert die folgende Ausgabe im Browser, in dem wir die verschachtelte Klasse mit dem Standardkonstruktor aufrufen, der zum Zeitpunkt der Kompilierung von Kotlin-Compilern bereitgestellt wurde.
Welcome to the TutorialsPoint.comAnonyme innere Klasse
Anonyme innere Klasse ist ein ziemlich gutes Konzept, das das Leben eines Programmierers sehr einfach macht. Wann immer wir eine Schnittstelle implementieren, kommt das Konzept des anonymen inneren Blocks ins Spiel. Das Konzept des Erstellens eines Schnittstellenobjekts unter Verwendung einer Laufzeitobjektreferenz wird als anonyme Klasse bezeichnet. Im folgenden Beispiel erstellen wir eine Schnittstelle und erstellen ein Objekt dieser Schnittstelle mithilfe des Mechanismus der anonymen inneren Klasse.
fun main(args: Array<String>) {
var programmer :Human = object:Human // creating an instance of the interface {
override fun think() { // overriding the think method
print("I am an example of Anonymous Inner Class ")
}
}
programmer.think()
}
interface Human {
fun think()
}Der obige Code liefert die folgende Ausgabe im Browser.
I am an example of Anonymous Inner ClassGeben Sie Aliase ein
Typ-Aliase sind eine Eigenschaft des Kotlin-Compilers. Es bietet die Flexibilität, einen neuen Namen eines vorhandenen Typs zu erstellen, und keinen neuen Typ. Wenn der Typname zu lang ist, können Sie leicht einen kürzeren Namen einfügen und diesen für die zukünftige Verwendung verwenden. Typ-Aliase sind für komplexe Typen sehr hilfreich. In der neuesten Version hat Kotlin die Unterstützung für Typ-Aliase widerrufen. Wenn Sie jedoch eine alte Version von Kotlin verwenden, können Sie diese wie folgt verwenden:
typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>In diesem Kapitel lernen wir Konstruktoren in Kotlin kennen. Kotlin hat zwei Arten von Konstruktoren - eine ist dieprimary constructor und der andere ist der secondary constructor. Eine Kotlin-Klasse kann einen Primärkonstruktor und einen oder mehrere Sekundärkonstruktoren haben. Der Java-Konstruktor initialisiert die Mitgliedsvariablen. In Kotlin initialisiert der primäre Konstruktor jedoch die Klasse, während der sekundäre Konstruktor dabei hilft, zusätzliche Logik einzuschließen, während diese initialisiert wird. Der primäre Konstruktor kann auf Klassenheaderebene deklariert werden, wie im folgenden Beispiel gezeigt.
class Person(val firstName: String, var age: Int) {
// class body
}Im obigen Beispiel haben wir den primären Konstruktor in der Klammer deklariert. Unter den beiden Feldern ist der Vorname schreibgeschützt, da er als "val" deklariert ist, während das Feldalter bearbeitet werden kann. Im folgenden Beispiel verwenden wir den primären Konstruktor.
fun main(args: Array<String>) {
val person1 = Person("TutorialsPoint.com", 15)
println("First Name = ${person1.firstName}") println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}Der obige Code initialisiert automatisch die beiden Variablen und liefert die folgende Ausgabe im Browser.
First Name = TutorialsPoint.com
Age = 15Wie bereits erwähnt, können mit Kotlin ein oder mehrere sekundäre Konstruktoren für Ihre Klasse erstellt werden. Dieser sekundäre Konstruktor wird mit dem Schlüsselwort "Konstruktor" erstellt. Dies ist immer dann erforderlich, wenn Sie mehr als einen Konstruktor in Kotlin erstellen möchten oder wenn Sie mehr Logik in den primären Konstruktor aufnehmen möchten. Dies ist nicht möglich, da der primäre Konstruktor möglicherweise von einer anderen Klasse aufgerufen wird. Schauen Sie sich das folgende Beispiel an, in dem wir einen sekundären Konstruktor erstellt haben und das obige Beispiel verwenden, um denselben zu implementieren.
fun main(args: Array<String>) {
val HUman = HUman("TutorialsPoint.com", 25)
print("${HUman.message}"+"${HUman.firstName}"+
"Welcome to the example of Secondary constructor, Your Age is-${HUman.age}")
}
class HUman(val firstName: String, var age: Int) {
val message:String = "Hey!!!"
constructor(name : String , age :Int ,message :String):this(name,age) {
}
}Note - Es können beliebig viele sekundäre Konstruktoren erstellt werden. Alle diese Konstruktoren sollten jedoch den primären Konstruktor direkt oder indirekt aufrufen.
Der obige Code liefert die folgende Ausgabe im Browser.
Hey!!! TutorialsPoint.comWelcome to the example of Secondary constructor, Your Age is- 25In diesem Kapitel lernen wir die Vererbung kennen. Per Definition wissen wir alle, dass Vererbung bedeutet, einige Eigenschaften der Mutterklasse in die Kinderklasse aufzunehmen. In Kotlin heißt die Basisklasse "Any". Dies ist die Superklasse der in Kotlin deklarierten Standardklasse "any". Wie alle anderen OOPS bietet Kotlin diese Funktionalität auch mit einem Schlüsselwort an, das als bekannt ist“:”.
Alles in Kotlin ist standardmäßig endgültig, daher müssen wir das Schlüsselwort "open" vor der Klassendeklaration verwenden, damit es erben kann. Schauen Sie sich das folgende Beispiel für die Vererbung an.
import java.util.Arrays
open class ABC {
fun think () {
print("Hey!! i am thiking ")
}
}
class BCD: ABC(){ // inheritence happend using default constructor
}
fun main(args: Array<String>) {
var a = BCD()
a.think()
}Der obige Code liefert die folgende Ausgabe im Browser.
Hey!! i am thikingWas ist nun, wenn wir die think () -Methode in der untergeordneten Klasse überschreiben möchten? Dann müssen wir das folgende Beispiel betrachten, in dem wir zwei Klassen erstellen und eine ihrer Funktionen in die untergeordnete Klasse überschreiben.
import java.util.Arrays
open class ABC {
open fun think () {
print("Hey!! i am thinking ")
}
}
class BCD: ABC() { // inheritance happens using default constructor
override fun think() {
print("I Am from Child")
}
}
fun main(args: Array<String>) {
var a = BCD()
a.think()
}Der obige Code ruft die geerbte Methode der untergeordneten Klasse auf und liefert die folgende Ausgabe im Browser. Wie Java erlaubt auch Kotlin keine Mehrfachvererbungen.
I Am from ChildIn diesem Kapitel lernen wir die Benutzeroberfläche in Kotlin kennen. In Kotlin funktioniert die Schnittstelle genau wie Java 8, dh sie kann sowohl eine Methodenimplementierung als auch eine Deklaration abstrakter Methoden enthalten. Eine Schnittstelle kann von einer Klasse implementiert werden, um ihre definierte Funktionalität zu verwenden. Ein Beispiel mit einer Schnittstelle haben wir bereits in Kapitel 6 - Abschnitt „Anonyme innere Klasse“ vorgestellt. In diesem Kapitel erfahren Sie mehr darüber. Das Schlüsselwort "Schnittstelle" wird verwendet, um eine Schnittstelle in Kotlin zu definieren, wie im folgenden Code gezeigt.
interface ExampleInterface {
var myVar: String // abstract property
fun absMethod() // abstract method
fun sayHello() = "Hello there" // method with default implementation
}Im obigen Beispiel haben wir eine Schnittstelle mit dem Namen "ExampleInterface" erstellt und darin befinden sich einige abstrakte Eigenschaften und Methoden. Schauen Sie sich die Funktion "sayHello ()" an, bei der es sich um eine implementierte Methode handelt.
Im folgenden Beispiel implementieren wir die obige Schnittstelle in einer Klasse.
interface ExampleInterface {
var myVar: Int // abstract property
fun absMethod():String // abstract method
fun hello() {
println("Hello there, Welcome to TutorialsPoint.Com!")
}
}
class InterfaceImp : ExampleInterface {
override var myVar: Int = 25
override fun absMethod() = "Happy Learning "
}
fun main(args: Array<String>) {
val obj = InterfaceImp()
println("My Variable Value is = ${obj.myVar}")
print("Calling hello(): ")
obj.hello()
print("Message from the Website-- ")
println(obj.absMethod())
}Der obige Code liefert die folgende Ausgabe im Browser.
My Variable Value is = 25
Calling hello(): Hello there, Welcome to TutorialsPoint.Com!
Message from the Website-- Happy LearningWie bereits erwähnt, unterstützt Kotlin nicht mehrere Vererbungen. Dasselbe kann jedoch erreicht werden, indem mehr als zwei Schnittstellen gleichzeitig implementiert werden.
Im folgenden Beispiel erstellen wir zwei Schnittstellen und implementieren später beide Schnittstellen in einer Klasse.
interface A {
fun printMe() {
println(" method of interface A")
}
}
interface B {
fun printMeToo() {
println("I am another Method from interface B")
}
}
// implements two interfaces A and B
class multipleInterfaceExample: A, B
fun main(args: Array<String>) {
val obj = multipleInterfaceExample()
obj.printMe()
obj.printMeToo()
}Im obigen Beispiel haben wir zwei Beispielschnittstellen A, B erstellt und in der Klasse "multipleInterfaceExample" zwei zuvor deklarierte Schnittstellen implementiert. Der obige Code liefert die folgende Ausgabe im Browser.
method of interface A
I am another Method from interface BIn diesem Kapitel lernen wir verschiedene Modifikatoren kennen, die in der Kotlin-Sprache verfügbar sind. Access modifierwird verwendet, um die Verwendung der in der Anwendung verwendeten Variablen, Methoden und Klassen einzuschränken. Wie andere OOP-Programmiersprachen ist dieser Modifikator an mehreren Stellen anwendbar, z. B. im Klassenheader oder in der Methodendeklaration. In Kotlin stehen vier Zugriffsmodifikatoren zur Verfügung.
Privat
Die Klassen, Methoden und Pakete können mit einem privaten Modifikator deklariert werden. Sobald etwas als privat deklariert ist, ist es in seinem unmittelbaren Umfang zugänglich. Beispielsweise kann auf ein privates Paket innerhalb dieser bestimmten Datei zugegriffen werden. Auf eine private Klasse oder Schnittstelle kann nur von ihren Datenelementen usw. zugegriffen werden.
private class privateExample {
private val i = 1
private val doSomething() {
}
}Im obigen Beispiel die Klasse “privateExample” und auf die Variable i kann nur in derselben Kotlin-Datei zugegriffen werden, wo sie erwähnt wird, da sie alle im Deklarationsblock als privat deklariert sind.
Geschützt
Protected ist ein weiterer Zugriffsmodifikator für Kotlin, der derzeit nicht für die Deklaration auf oberster Ebene verfügbar ist, da kein Paket geschützt werden kann. Eine geschützte Klasse oder Schnittstelle ist nur für ihre Unterklasse sichtbar.
class A() {
protected val i = 1
}
class B : A() {
fun getValue() : Int {
return i
}
}Im obigen Beispiel die Variable “i” wird als geschützt deklariert und ist daher nur für seine Unterklasse sichtbar.
Intern
Intern ist ein neu hinzugefügter Modifikator, der in Kotlin eingeführt wurde. Wenn etwas als intern markiert ist, befindet sich dieses bestimmte Feld im internen Feld. Ein internes Paket ist nur innerhalb des Moduls sichtbar, unter dem es implementiert ist. Eine interne Klassenschnittstelle ist nur für andere Klassen sichtbar, die im selben Paket oder im Modul vorhanden sind. Im folgenden Beispiel wird gezeigt, wie eine interne Methode implementiert wird.
class internalExample {
internal val i = 1
internal fun doSomething() {
}
}Im obigen Beispiel wird die Methode mit dem Namen "doSomething" und die Variable als intern erwähnt. Daher können diese beiden Felder nur innerhalb des Pakets aufgerufen werden, unter dem sie deklariert sind.
Öffentlichkeit
Auf den öffentlichen Modifikator kann von überall im Projektarbeitsbereich zugegriffen werden. Wenn kein Zugriffsmodifikator angegeben ist, befindet er sich standardmäßig im öffentlichen Bereich. In all unseren vorherigen Beispielen haben wir keinen Modifikator erwähnt, daher sind alle im öffentlichen Bereich. Im Folgenden finden Sie ein Beispiel, um mehr darüber zu erfahren, wie eine öffentliche Variable oder Methode deklariert wird.
class publicExample {
val i = 1
fun doSomething() {
}
}Im obigen Beispiel haben wir keinen Modifikator erwähnt, daher sind alle diese Methoden und Variablen standardmäßig öffentlich.
In diesem Kapitel erfahren Sie mehr über eine weitere neue Funktion von Kotlin namens "Extension". Mit der Erweiterung können wir einige Methodenfunktionen hinzufügen oder entfernen, ohne sie zu erben oder zu ändern. Erweiterungen werden statistisch aufgelöst. Die vorhandene Klasse wird nicht geändert, es wird jedoch eine aufrufbare Funktion erstellt, die mit einer Punktoperation aufgerufen werden kann.
Funktionserweiterung
In der Funktionserweiterung ermöglicht Kotlin das Definieren einer Methode außerhalb der Hauptklasse. Im folgenden Beispiel sehen wir, wie die Erweiterung auf Funktionsebene implementiert wird.
class Alien {
var skills : String = "null"
fun printMySkills() {
print(skills)
}
}
fun main(args: Array<String>) {
var a1 = Alien()
a1.skills = "JAVA"
//a1.printMySkills()
var a2 = Alien()
a2.skills = "SQL"
//a2.printMySkills()
var a3 = Alien()
a3.skills = a1.addMySkills(a2)
a3.printMySkills()
}
fun Alien.addMySkills(a:Alien):String{
var a4 = Alien()
a4.skills = this.skills + " " +a.skills
return a4.skills
}Im obigen Beispiel haben wir keine Methode innerhalb der "Alien" -Klasse mit dem Namen "addMySkills ()". Wir implementieren dieselbe Methode jedoch weiterhin an einer anderen Stelle außerhalb der Klasse. Dies ist die Magie der Erweiterung.
Der obige Code generiert die folgende Ausgabe im Browser.
JAVA SQLObjekterweiterung
Kotlin bietet einen weiteren Mechanismus zur Implementierung der statischen Funktionalität von Java. Dies kann mit dem Schlüsselwort „Begleitobjekt“ erreicht werden. Mit diesem Mechanismus können wir ein Objekt einer Klasse innerhalb einer Factory-Methode erstellen und später diese Methode einfach unter Verwendung der Referenz des Klassennamens aufrufen. Im folgenden Beispiel erstellen wir ein „Begleitobjekt“.
fun main(args: Array<String>) {
println("Heyyy!!!"+A.show())
}
class A {
companion object {
fun show():String {
return("You are learning Kotlin from TutorialsPoint.com")
}
}
}Der obige Code liefert die folgende Ausgabe im Browser.
Heyyy!!! You are learning Kotlin from TutorialsPoint.comDas obige Beispiel scheint in Java statisch zu sein. In Echtzeit erstellen wir jedoch ein Objekt als Mitgliedsvariable derselben Klasse. Aus diesem Grund ist es auch in der Erweiterungseigenschaft enthalten und kann alternativ als Objekterweiterung bezeichnet werden. Grundsätzlich erweitern Sie das Objekt derselben Klasse, um einige der Elementfunktionen zu verwenden.
In diesem Kapitel erfahren Sie mehr über Datenklassen der Programmiersprache Kotlin. Eine Klasse kann immer dann als Datenklasse markiert werden, wenn sie als "Daten" markiert ist. Diese Art von Klasse kann verwendet werden, um die Basisdaten auseinander zu halten. Abgesehen davon bietet es keine anderen Funktionen.
Alle Datenklassen müssen einen Primärkonstruktor haben, und alle Primärkonstruktoren sollten mindestens einen Parameter haben. Immer wenn eine Klasse als Daten markiert ist, können wir einige der eingebauten Funktionen dieser Datenklasse verwenden, z. B. "toString ()", "hashCode ()" usw. Jede Datenklasse kann keinen Modifikator wie abstrakt und offen oder intern haben. Die Datenklasse kann auch auf andere Klassen erweitert werden. Im folgenden Beispiel erstellen wir eine Datenklasse.
fun main(args: Array<String>) {
val book: Book = Book("Kotlin", "TutorialPoint.com", 5)
println("Name of the Book is--"+book.name) // "Kotlin"
println("Puclisher Name--"+book.publisher) // "TutorialPoint.com"
println("Review of the book is--"+book.reviewScore) // 5
book.reviewScore = 7
println("Printing all the info all together--"+book.toString())
//using inbuilt function of the data class
println("Example of the hashCode function--"+book.hashCode())
}
data class Book(val name: String, val publisher: String, var reviewScore: Int)Der obige Code liefert die folgende Ausgabe im Browser, in dem wir eine Datenklasse für einige der Daten erstellt haben und über die Hauptfunktion auf alle Datenelemente zugegriffen haben.
Name of the Book is--"Kotlin"
Puclisher Name--"TutorialPoint.com"
Review of the book is--5
Printing all the info all together--(name-Kotlin, publisher-TutorialPoint.com, reviewScore-7)
Example of the hashCode function---1753517245In diesem Kapitel lernen wir einen anderen Klassentyp kennen, der als "versiegelte" Klasse bezeichnet wird. Dieser Klassentyp wird verwendet, um eine eingeschränkte Klassenhierarchie darzustellen. Mit Sealed können die Entwickler einen Datentyp eines vordefinierten Typs verwalten. Um eine versiegelte Klasse zu erstellen, müssen wir das Schlüsselwort "versiegelt" als Modifikator für diese Klasse verwenden. Eine versiegelte Klasse kann eine eigene Unterklasse haben, aber alle diese Unterklassen müssen zusammen mit der versiegelten Klasse in derselben Kotlin-Datei deklariert werden. Im folgenden Beispiel sehen wir, wie eine versiegelte Klasse verwendet wird.
sealed class MyExample {
class OP1 : MyExample() // MyExmaple class can be of two types only
class OP2 : MyExample()
}
fun main(args: Array<String>) {
val obj: MyExample = MyExample.OP2()
val output = when (obj) { // defining the object of the class depending on the inuputs
is MyExample.OP1 -> "Option One has been chosen"
is MyExample.OP2 -> "option Two has been chosen"
}
println(output)
}Im obigen Beispiel haben wir eine versiegelte Klasse mit dem Namen "MyExample", die nur von zwei Typen sein kann - eine ist "OP1" und eine andere ist "OP2". In der Hauptklasse erstellen wir ein Objekt in unserer Klasse und weisen seinen Typ zur Laufzeit zu. Da diese "MyExample" -Klasse versiegelt ist, können wir zur Laufzeit die "when" -Klausel anwenden, um die endgültige Ausgabe zu implementieren.
In der versiegelten Klasse müssen wir keine unnötige "else" -Anweisung verwenden, um den Code zu komplexieren. Der obige Code liefert die folgende Ausgabe im Browser.
option Two has been chosenWie Java bietet Kotlin eine höhere Ordnung der Variablentypisierung, die als Generics bezeichnet wird. In diesem Kapitel erfahren Sie, wie Kotlin Generics implementiert und wie wir als Entwickler die in der Generics-Bibliothek bereitgestellten Funktionen nutzen können. In Bezug auf die Implementierung sind Generika Java ziemlich ähnlich, aber der Kotlin-Entwickler hat zwei neue Schlüsselwörter eingeführt“out” und “in” um Kotlin-Codes für den Entwickler lesbarer und einfacher zu machen.
In Kotlin sind eine Klasse und ein Typ völlig unterschiedliche Konzepte. Gemäß dem Beispiel ist List eine Klasse in Kotlin, während List <String> ein Typ in Kotlin ist. Das folgende Beispiel zeigt, wie Generika in Kotlin implementiert werden.
fun main(args: Array<String>) {
val integer: Int = 1
val number: Number = integer
print(number)
}Im obigen Code haben wir eine "Ganzzahl" deklariert und diese Variable später einer Zahlenvariablen zugewiesen. Dies ist möglich, weil "Int" eine Unterklasse der Number-Klasse ist. Daher erfolgt die Typkonvertierung automatisch zur Laufzeit und erzeugt die Ausgabe als "1".
Lassen Sie uns etwas mehr über Generika in Kotlin lernen. Es ist besser, einen generischen Datentyp zu wählen, wenn wir uns nicht sicher sind, welchen Datentyp wir in der Anwendung verwenden werden. Im Allgemeinen wird in Kotlin Generika durch definiert<T>Dabei steht „T“ für Vorlage, die vom Kotlin-Complier dynamisch bestimmt werden kann. Im folgenden Beispiel sehen wir, wie generische Datentypen in der Programmiersprache Kotlin verwendet werden.
fun main(args: Array<String>) {
var objet = genericsExample<String>("JAVA")
var objet1 = genericsExample<Int>(10)
}
class genericsExample<T>(input:T) {
init {
println("I am getting called with the value "+input)
}
}Im obigen Code erstellen wir eine Klasse mit dem generischen Rückgabetyp, der als dargestellt wird <T>. Schauen Sie sich die Hauptmethode an, bei der wir ihren Wert beim Ausführen dynamisch definiert haben, indem wir den Werttyp beim Erstellen des Objekts dieser Klasse beweisen. So werden Generika vom Kotlin-Compiler interpretiert. Wir werden die folgende Ausgabe im Browser erhalten, sobald wir diesen Code in unserem Codierungsgrund ausführen.
I am getting called with the value JAVA
I am getting called with the value 10Wenn wir den generischen Typ einem seiner Supertypen zuweisen möchten, müssen wir das Schlüsselwort "out" verwenden, und wenn wir den generischen Typ einem seiner Untertypen zuweisen möchten, müssen wir "in" verwenden. Stichwort. Im folgenden Beispiel verwenden wir das Schlüsselwort "out". Ebenso können Sie versuchen, das Schlüsselwort "in" zu verwenden.
fun main(args: Array<String>) {
var objet1 = genericsExample<Int>(10)
var object2 = genericsExample<Double>(10.00)
println(objet1)
println(object2)
}
class genericsExample<out T>(input:T) {
init {
println("I am getting called with the value "+input)
}
}Der obige Code liefert die folgende Ausgabe im Browser.
I am getting called with the value 10
I am getting called with the value 10.0
genericsExample@28d93b30
genericsExample@1b6d3586Kotlin unterstützt “delegation” Entwurfsmuster durch Einführung eines neuen Schlüsselworts “by”. Mit diesem Schlüsselwort oder dieser Delegierungsmethode ermöglicht Kotlin der abgeleiteten Klasse, über ein bestimmtes Objekt auf alle implementierten öffentlichen Methoden einer Schnittstelle zuzugreifen. Das folgende Beispiel zeigt, wie dies in Kotlin geschieht.
interface Base {
fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
override fun printMe() { println(x) } //implementation of the method
}
class Derived(b: Base) : Base by b // delegating the public method on the object b
fun main(args: Array<String>) {
val b = BaseImpl(10)
Derived(b).printMe() // prints 10 :: accessing the printMe() method
}Im Beispiel haben wir eine Schnittstelle "Base" mit ihrer abstrakten Methode "printme ()". In der BaseImpl-Klasse implementieren wir dieses "printme ()" und später von einer anderen Klasse verwenden wir diese Implementierung mit dem Schlüsselwort "by".
Der obige Code liefert die folgende Ausgabe im Browser.
10Eigentumsdelegation
Im vorherigen Abschnitt haben wir das Entwurfsmuster für die Delegierung mithilfe des Schlüsselworts "by" kennengelernt. In diesem Abschnitt erfahren Sie, wie Sie Eigenschaften mit einigen in der Kotlin-Bibliothek genannten Standardmethoden delegieren.
Delegation bedeutet, die Verantwortung auf eine andere Klasse oder Methode zu übertragen. Wenn eine Eigenschaft an einigen Stellen bereits deklariert ist, sollten wir denselben Code wiederverwenden, um sie zu initialisieren. In den folgenden Beispielen verwenden wir einige von Kotlin bereitgestellte Standarddelegierungsmethoden und einige Standardbibliotheksfunktionen, während wir die Delegierung in unseren Beispielen implementieren.
Verwenden von Lazy ()
Lazy ist eine Lambda-Funktion, die eine Eigenschaft als Eingabe verwendet und im Gegenzug eine Instanz von angibt Lazy<T>Dabei ist <T> im Grunde der Typ der verwendeten Eigenschaften. Schauen wir uns Folgendes an, um zu verstehen, wie es funktioniert.
val myVar: String by lazy {
"Hello"
}
fun main(args: Array<String>) {
println(myVar +" My dear friend")
}Im obigen Code übergeben wir eine Variable "myVar" an die Lazy-Funktion, die im Gegenzug den Wert ihrem Objekt zuweist und diesen an die Hauptfunktion zurückgibt. Es folgt die Ausgabe im Browser.
Hello My dear friendDelegetion.Observable ()
Observable () verwendet zwei Argumente, um das Objekt zu initialisieren, und gibt dasselbe an die aufgerufene Funktion zurück. Im folgenden Beispiel wird gezeigt, wie die Observable () -Methode verwendet wird, um die Delegierung zu implementieren.
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("Welcome to Tutorialspoint.com") {
prop, old, new ->
println("$old -> $new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}Der obige Code liefert die folgende Ausgabe im Browser.
first -> secondIm Allgemeinen ist die Syntax der Ausdruck, nachdem das Schlüsselwort "by" delegiert wurde. Dasget() und set() Methoden der Variablen p wird an seine delegiert getValue() und setValue() Methoden, die in der Delegate-Klasse definiert sind.
class Example {
var p: String by Delegate()
}Für den obigen Code folgt die Delegatenklasse, die generiert werden muss, um den Wert in der Variablen zuzuweisen p.
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
}
}Während des Lesens wird die Methode getValue () aufgerufen und beim Festlegen der Variablen setValue () wird die Methode aufgerufen.
Kotlin ist eine statisch typisierte Sprache, daher spielen Funktionen eine große Rolle. Wir sind mit der Funktion ziemlich vertraut, da wir in allen Beispielen die Funktion verwenden. Die Funktion wird mit dem Schlüsselwort "fun" deklariert. Wie jedes andere OOP benötigt es auch einen Rückgabetyp und eine Optionsargumentliste.
Im folgenden Beispiel definieren wir eine Funktion namens MyFunction. Von der Hauptfunktion aus rufen wir diese Funktion auf und übergeben ein Argument.
fun main(args: Array<String>) {
println(MyFunction("tutorialsPoint.com"))
}
fun MyFunction(x: String): String {
var c:String = "Hey!! Welcome To ---"
return (c+x)
}Der obige Code liefert die folgende Ausgabe im Browser.
Hey!! Welcome To ---tutorialsPoint.comDie Funktion sollte wie folgt deklariert werden:
fun <nameOfFunction>(<argument>:<argumentType>):<ReturnType>Im Folgenden sind einige der verschiedenen in Kotlin verfügbaren Funktionstypen aufgeführt.
Lambda-Funktion
Lambda ist eine High-Level-Funktion, die den Code der Kesselplatte drastisch reduziert, während eine Funktion deklariert und definiert wird. Mit Kotlin können Sie Ihr eigenes Lambda definieren. In Kotlin können Sie Ihr Lambda deklarieren und dieses Lambda an eine Funktion übergeben.
Schauen Sie sich das folgende Beispiel an.
fun main(args: Array<String>) {
val mylambda :(String)->Unit = {s:String->print(s)}
val v:String = "TutorialsPoint.com"
mylambda(v)
}Im obigen Code haben wir unser eigenes Lambda namens "mylambda" erstellt und eine Variable an dieses Lambda übergeben, das vom Typ String ist und den Wert "TutorialsPoint.com" enthält.
Der obige Code liefert die folgende Ausgabe im Browser.
TutorialsPoint.comInline-Funktion
Das obige Beispiel zeigt die Grundlagen des Lambda-Ausdrucks, den wir in der Kotlin-Anwendung verwenden können. Jetzt können wir ein Lambda an eine andere Funktion übergeben, um unsere Ausgabe zu erhalten, wodurch die aufrufende Funktion zu einer Inline-Funktion wird.
Schauen Sie sich das folgende Beispiel an.
fun main(args: Array<String>) {
val mylambda:(String)->Unit = {s:String->print(s)}
val v:String = "TutorialsPoint.com"
myFun(v,mylambda) //passing lambda as a parameter of another function
}
fun myFun(a :String, action: (String)->Unit) { //passing lambda
print("Heyyy!!!")
action(a)// call to lambda function
}Der obige Code liefert die folgende Ausgabe im Browser. Mit der Inline-Funktion haben wir ein Lambda als Parameter übergeben. Jede andere Funktion kann mit dem Schlüsselwort "inline" zu einer Inline-Funktion gemacht werden.
Heyyy!!!TutorialsPoint.comKotlin enthält viele Funktionen anderer Programmiersprachen. Sie können mehrere Variablen gleichzeitig deklarieren. Diese Technik wird als Destructuring-Deklaration bezeichnet.
Es folgt die grundlegende Syntax der Destrukturierungsdeklaration.
val (name, age) = personIn der obigen Syntax haben wir ein Objekt erstellt und alle zusammen in einer einzigen Anweisung definiert. Später können wir sie wie folgt verwenden.
println(name)
println(age)Lassen Sie uns nun sehen, wie wir dasselbe in unserer realen Anwendung verwenden können. Betrachten Sie das folgende Beispiel, in dem wir eine Student-Klasse mit einigen Attributen erstellen und diese später zum Drucken der Objektwerte verwenden.
fun main(args: Array<String>) {
val s = Student("TutorialsPoint.com","Kotlin")
val (name,subject) = s
println("You are learning "+subject+" from "+name)
}
data class Student( val a :String,val b: String ){
var name:String = a
var subject:String = b
}Der obige Code liefert die folgende Ausgabe im Browser.
You are learning Kotlin from TutorialsPoint.comDie Ausnahmebehandlung ist ein sehr wichtiger Bestandteil einer Programmiersprache. Diese Technik verhindert, dass unsere Anwendung zur Laufzeit die falsche Ausgabe generiert. In diesem Kapitel erfahren Sie, wie Sie mit Laufzeitausnahmen in Kotlin umgehen. Die Ausnahmen in Kotlin sind den Ausnahmen in Java ziemlich ähnlich. Alle Ausnahmen sind Nachkommen der Klasse "Throwable". Das folgende Beispiel zeigt, wie die Ausnahmebehandlungstechnik in Kotlin verwendet wird.
fun main(args: Array<String>) {
try {
val myVar:Int = 12;
val v:String = "Tutorialspoint.com";
v.toInt();
} catch(e:Exception) {
e.printStackTrace();
} finally {
println("Exception Handeling in Kotlin");
}
}Im obigen Code haben wir einen String deklariert und diesen String später in die Ganzzahl eingebunden, was eigentlich eine Laufzeitausnahme ist. Daher erhalten wir die folgende Ausgabe im Browser.
val myVar:Int = 12;
Exception Handeling in KotlinNote - Wie Java führt auch Kotlin den finally-Block nach der Ausführung des catch-Blocks aus.