Warum Sie komplett auf Kotlin / Sudo Null wechseln sollten IT News

Ich möchte Ihnen etwas über die Programmiersprache Kotlin erzählen und warum Sie sie für Ihr nächstes Projekt in Betracht ziehen sollten. Früher habe ich Java bevorzugt, aber im letzten Jahr habe ich mich beim Programmieren in Kotlin wiedergefunden, wann immer es möglich war, und jetzt kann ich mir wirklich keine Situation vorstellen, in der Java die beste Wahl wäre.

Es wird von der Firma entwickelt Düsenhirneund die Tatsache, dass es diese Menschen sind, die an der Schaffung eines solchen Sets stehen IDE, wie IntelliJ und ReSharper, spiegelt sich vollständig in Kotlin wider. Es ist pragmatisch und prägnant und macht das Programmieren zu einem angenehmen und effizienten Erlebnis.

Obwohl Kotlin wie in kompiliert JavaScriptund bald ein Maschinensprachewerde ich mich auf seine Hauptumgebung konzentrieren – die JVM.

Hier sind also ein paar Gründe, warum Sie vollständig auf Kotlin umsteigen sollten (die Nummerierung ist zufällig, in keiner bestimmten Reihenfolge):

0# Interaktion mit Java

Kotlin ist zu 100 % mit Java kompatibel. Mit Kotlin können Sie buchstäblich an Ihren alten Java-Projekten weiterarbeiten. Alle Ihre bevorzugten Java-Frameworks sind weiterhin verfügbar, und jedes Framework, das Sie in Kotlin schreiben, wird von Ihrem hartgesottenen Java-liebenden Freund problemlos übernommen.

eines# Vertraute Syntax

Kotlin ist keine ausgefallene Sprache, die in der Wissenschaft geboren wurde. Seine Syntax ist jedem Programmierer aus der Umgebung vertraut Hoppla, und kann von vornherein mehr oder weniger klar sein. Natürlich gibt es etwas Unterschiede zu Java, wie neu gestaltete Konstruktoren oder Variablendeklarationen val var. Das folgende Snippet enthält den größten Teil der grundlegenden Syntax:

class Foo { val b: String = “b” // val bedeutet nicht veränderbar var i: Int = 0 // var bedeutet veränderbar fun hello() { val str = “Hello” print(“$str World”) } fun sum( x: Int, y: Int): Int { return x + y } fun maxOf(a: Float, b: Float) = if (a > b) a else b }

2# String-Interpolation

Es ist, als ob eine intelligentere und besser lesbare Version der String.format()-Funktion von Java in die Sprache eingebaut wurde:

val x = 4 val y = 7 print(“Summe von $x und $y ist ${x + y}”) // Summe von 4 und 7 ist 11

3# Geben Sie Rückschluss ein

Kotlin wird Ihre Typen ableiten, wenn Sie glauben, dass dies die Lesbarkeit verbessert:

val a = “abc” // Typ abgeleitet von String val b = 4 // Typ abgeleitet von Int val c: Double = 0.7 // Typ explizit deklariert val d: List = ArrayList() // Typ explizit deklariert

vier # “Smarte” Transformationen. (Intelligente Besetzungen)

Der Kotlin-Compiler verfolgt Ihre Logik und führt nach Möglichkeit automatisch eine Typumwandlung durch, was bedeutet, dass Instanzprüfungen und explizite Konvertierungen beseitigt werden:

if (obj is String) { print(obj.toUpperCase()) // obj ist jetzt als String bekannt }

5# Intuitive Gleichheiten

Sie können den expliziten Aufruf von equals() beenden, da der Operator == jetzt auf strukturelle Gleichheit prüft:

val john1 = Person(“John”) val john2 = Person(“John”) john1 == john2 // true (strukturelle Gleichheit) john1 === john2 // false (referenzielle Gleichheit)

6# Standardargumente

Es müssen nicht mehrere identische Methoden mit unterschiedlichen Argumenten definiert werden:

fun build(title: String, width: Int = 800, height: Int = 600) { Frame(title, width, height) }

7# Benannte Argumente

In Kombination mit Standardargumenten machen benannte Argumente die Verwendung überflüssig Bauherren:

build(“PacMan”, 400, 300) // äquivalent build(title = “PacMan”, width = 400, height = 300) // äquivalent build(width = 400, height = 300, title = “PacMan”) // gleichwertig

acht# Beim Ausdruck

Als Ersatz für die switch-Anweisung wird ein viel bequemerer und flexiblerer Ausdruck verwendet Wenn:

when (x) { 1 -> print(“x ist 1”) 2 -> print(“x ist 2”) 3, 4 -> print(“x ist 3 oder 4”) in 5..10 -> print (“x ist 5, 6, 7, 8, 9 oder 10”) else -> print(“x liegt außerhalb des Bereichs”) }

Es funktioniert als Ausdruck und als Anweisung, mit oder ohne Argument:

val res: Boolean = when { obj == null -> false obj is String -> true else -> throw IllegalStateException() }

9# Eigenschaften

Benutzerdefiniertes Set- und Get-Verhalten kann zu öffentlichen Feldern hinzugefügt werden, was es uns ermöglicht, den Code nicht mehr mit bedeutungslosen Inhalten zu überladen Getter und Setter.

class Frame { var width: Int = 800 var height: Int = 600 val Pixel: Int get() = width * height }

zehn# Datenklasse

Es ist ein POJO (Plain Old Java Object) mit den Funktionen toString(), equals(), hashCode() und copy() und benötigt im Gegensatz zu Java nicht fast 100 Codezeilen:

Datenklasse Person(val name: String, var email: String, var age: Int) val john = Person(“John”, “john@gmail.com”, 112)

elf# Bedienerüberlastung

Der vordefinierte Satz von Operatoren kann zur Verbesserung der Lesbarkeit überladen werden:

Datenklasse Vec(val x: Float, val y: Float) { operator fun plus(v: Vec) = Vec(x + vx, y + vy) } val v = Vec(2f, 3f) + Vec(4f, 1f )

12 # Destrukturierende Deklarationen

Einige Objekte können destrukturiert werden, was zum Beispiel beim Iterieren von Karten nützlich ist:

for ((key, value) in map) { print(“Key: $key”) print(“Value: $value”) }

13# Bereiche

Um die Lesbarkeit zu verbessern:

for (i in 1..100) { … } for (i in 0 until 100) { … } for (i in 2..10 step 2) { … } for (i in 10 downTo 1 ) { … } wenn (x in 1..10) { … }

vierzehn# Erweiterungsfunktionen

Erinnern Sie sich, als Sie zum ersten Mal eine Liste in Java sortieren mussten? Sie konnten die Funktion sort() nicht finden und mussten sich daher mit Collections.sort() vertraut machen. Und später, als Sie String groß schreiben mussten, haben Sie Ihre eigene Hilfsfunktion geschrieben, weil Sie StringUtils.capitalize() nicht kannten.

Wenn es doch nur eine Möglichkeit gäbe, alten Klassen neue Funktionen hinzuzufügen; dann könnte Ihre IDE Ihnen helfen, die benötigte Funktion mit Codevervollständigung zu finden. In Kotlin können Sie genau das tun:

fun String.replaceSpaces(): String {return this.replace(‘ ‘, ‘_’) } val formatted = str.replaceSpaces()

Die Standardbibliothek erweitert die Funktionalität der ursprünglichen Java-Typen, insbesondere für String:

str.removeSuffix(.txt”) str.capitalize() str.substringAfterLast(“/”) str.replaceAfter(“:”, “classified”)

fünfzehn# Null Sicherheit

Java ist das, was wir nennen sollten fast statisch typisierte Sprache. Darin befindet sich eine Variable vom Typ String nicht garantiert bezieht sich auf einen String – er kann auf null verweisen. Obwohl wir daran gewöhnt sind, macht es die Sicherheit der statischen Typprüfung zunichte, und als Ergebnis müssen Java-Entwickler in ständiger Angst vor Fehlern leben. NPE (NullzeigerAusnahme).

Kotlin löst dieses Problem, indem es zwischen Nicht-Null- und Nullable-Typen unterscheidet. Typen sind standardmäßig nicht null und können durch Hinzufügen von ? wie zum Beispiel:

var a: String = “abc” a = null // Fehler beim Kompilieren var b: String? = “xyz” b = null // kein Problem

Kotlin zwingt Sie, sich vor NPE zu schützen, wenn Sie auf einen Nullable-Typ zugreifen:

val x = b.length // Kompilierfehler: b könnte null sein

Und obwohl es umständlich erscheinen mag, ist es dank einiger Funktionen von Kotlin eigentlich ganz einfach. Wir haben immer noch eine intelligente Umwandlung, die nullfähige Typen wo immer möglich in Nicht-Null-Typen konvertiert:

if (b == null) return val x = b.length // kein Problem

Wir können auch den sicheren Aufruf ?. verwenden, der auf null prüft, anstatt eine NPE zu werfen:

val x = b?.length // Typ von x ist nullable Int

Sichere Aufrufe können verkettet werden, um die verschachtelten If-Not-Null-Prüfungen zu vermeiden, die wir manchmal in anderen Sprachen schreiben, und wenn wir einen Nicht-Null-Standardwert wollen, verwenden wir den elvis-Operator ? ::

val name = ship?.captain?.name ?: “unbekannt”

Wenn Ihnen das alles nicht zusagt und der NPE-Bedarf extrem hoch ist, dann sagen Sie es ausdrücklich:

val x = b?.length ?: throw NullPointerException() // wie unten val x = b!!.length // wie oben

16# Verbesserte Lambdas

Es ist ein gutes Lambda-System – es balanciert perfekt zwischen Lesbarkeit und Komplexität aus, dank eines gut durchdachten Designs mit einer einfachen Syntax:

val sum = { x: Int, y: Int -> x + y } // Typ: (Int, Int) -> Int val res = sum(4,7) // res == 11

Und hier sind die smarten Lösungen:

  1. Methodenklammern können verschoben oder weggelassen werden, wenn das Lambda zuletzt kommt oder das einzige Argument der Methode ist.

  2. Wenn wir uns dafür entscheiden, ein Lambda-Argument mit einem Argument nicht zu deklarieren, wird es implizit unter dem Namen it deklariert.

Diese Tatsachen zusammen machen die folgenden drei Zeilen äquivalent:

numbers.filter({ x -> x.isPrime() }) numbers.filter { x -> x.isPrime() } numbers.filter { it.isPrime() }

Und es erlaubt uns, prägnanten funktionalen Code zu schreiben – sehen Sie sich nur diese Schönheit an:

Personen .filter { it.age >= 18 } .sortedBy { it.name } .map { it.email } .forEach { print(it) }

Das Lambda-System von Kotlin in Kombination mit Erweiterungsfunktionen macht es ideal zum Erstellen DSL. Schauen Sie sich an Anko als Beispiel für eine DSL, die darauf abzielt, die Android-Entwicklung zu verbessern:

verticalLayout { padding = dip(30) editText { hint = „Name“ textSize = 24f } editText { hint = „Password“ textSize = 24f } button(“Login“) { textSize = 26f } }

17# IDE-Unterstützung

Sie haben einige Optionen, wenn Sie mit Kotlin beginnen möchten, aber ich empfehle dringend, das mit Kotlin gelieferte IntelliJ zu verwenden – seine Fähigkeiten zeigen den vollen Vorteil, dass sowohl die Sprache als auch die IDE von denselben Leuten entwickelt werden.

Als kleines, aber aufschlussreiches Beispiel ist hier, was herauskam, als ich zum ersten Mal versuchte, Java-Code aus Stack Overflow zu kopieren und einzufügen:

IntelliJ bemerkt, wenn Sie Java-Code in eine Kotlin-Datei einfügen

Morgen gibt es eine offene Lektion „Classes and Objects Fundamentals“, in der wir uns mit den Prinzipien des Entwerfens von Klassen und deren Implementierung in Kotlin befassen. Lassen Sie uns verstehen, wie objektorientierte Programmierung von innen funktioniert, erstellen Sie unsere eigenen Strukturen und schauen Sie sich die Möglichkeiten der Kotlin-Sprache an. Lassen Sie uns ein Objektdatenmodell entwerfen. Registrieren Verknüpfung.

Similar Posts

Leave a Reply

Your email address will not be published.