Kotlin gehört zu den beliebtesten Programmiersprachen und das aus guten Gründen. Wenn du dich noch mit Java oder Javascript herumschlägst, solltest du dir Kotlin anschauen. Warum? Das zeigen dir die folgenden Syntax-Vergleiche. Du erfährst nicht nur, was Kotlin besser macht, sondern steigst auch leichter in die Jetbrains-Sprache ein.

Passend dazu und was Javascript damit zu tun hat: Deswegen ist Kotlin so unfassbar beliebt

Bevor wir uns komplexere Beispiele angucken, werfen wir den ersten Blick auf die grundlegende Syntax. Im Beispiel-Code fällt bereits im Kleinen auf, dass Kotlin meistens mit weniger auskommt als äquivalenter Java-Code. Zum Beispiel ist das Semikolon optional – kann aber auch hingeschrieben werden, falls man sich daran gewöhnt hat. Okay, ein Zeichen verkürzt den Code nicht entscheidend. Deswegen schauen wir uns ein paar weitere Code-Schnipsel an. Hier wurden bewusst einige Besonderheiten eingebaut, damit ihr bereits einige Kniffe der Sprache lernt.

Starten wir mit der Definition einer neuen Funktion mit und ohne Rückgabewert. Die Sichtbarkeit public ist bei Kotlin ein Standard-Wert und muss nicht explizit hingeschrieben werden.

Java

// Mit Rückgabewert
public int abs(int a) {
  if(a < 0) return -a;
  return a;
}
// Ohne Rückgabewert
private void printWithPrefix(String text) {
  System.out.println("Output: " + text);
}

Kotlin

// Mit Rückgabewert
fun abs(a: Int): Int {
  if(a < 0) return -a  
  return a
}
// Oder äquivalent und kürzer
fun abs(a: Int) = if (a < 0) -a else a

// Ohne Rückgabewert
private fun printWithPrefix(text: String) {
  println("Output: $text")
}

Bei der Definition einer neuen Variable muss ein var vor den Namen gesetzt werden, wenn sie veränderbar sein soll. Das Gegenstück ist val.

Java

// Beispiel 1
public int a = 0;
// Beispiel 2
private int a = 0;
// Beispiel 3
final public int a = 0;
// Beispiel 4
public int a;

Kotlin

// Beispiel 1 (Typ ist bei Bsp. 1-3 optional)
var a: Int = 0
var a = 0
// Beispiel 2
private var a: Int = 0
// Beispiel 3
val a: Int = 0
// Beispiel 4 (Hier muss der Typ angegeben werden)
var a: Int

Bei dem oberen Beispiel der Funktion printWithPrefix wird deutlich, dass Strings mit Variablen in Kotlin deutlich leichter verknüpft werden können: Benötigt wird lediglich das Dollar-Zeichen. Kombinieren wir das jedoch mit geschweiften Klammern, können sogar ganze Funktionsaufrufe in einem String eingesetzt werden.

var age = 29
var s = "Ich bin $age Jahre alt"
println("${s.replace("bin", "war")}, bin jetzt aber ${++age} geworden.")
// Ausgabe: Ich war 29 Jahre alt, bin jetzt aber 30 geworden.

In Java ist folgender Code ohne Compiler-Fehler möglich:

public String s = null;
System.out.println(s.length());

Doch beim Ausführen dieses Java-Programms gibt es natürlich die allseits gehasste Null-Pointer-Exception. Vor allem bei komplexeren Java-Programmen ist das ein echtes Problem. Solche Fehler treten dann alles andere als selten auf. Wenn der Entwickler nicht jeden Fall bedacht hat, wann eine Variable vielleicht doch eine Null-Referenz besitzen kann, dann werden solche Exceptions immer wieder auftreten. Kotlin löst das Problem ganz einfach: Variablen dürfen ohne weiteres keine Null-Referenz haben – außer ihr fügt ein Fragezeichen an.

var s: String = null // Compiler-Fehler
var sNull: String? = null // Ok
println(sNull.length) // Compiler-Fehler: sNull könnte Null sein

Bedeutet: Unter Kotlin können erstmal keine Null-Pointer-Exceptions mehr zur Laufzeit auftreten – außer ihr lasst sie explizit zu. Doch wie könnt ihr nun auf Null-Variablen zugreifen? Wir definieren uns folgende Variablen:

var s0: String? = null
var s1: String? = "Doch nicht null"

Dann kann wie folgt drauf zugegriffen werden:

// Möglichkeit 1
var s0Length: String? = null;
if(s0 != null) s0Length = s0.length
// Möglichkeit 2
// s1Length ist Null, wenn s1 == null, sonst wird hinterer Teil ausgeführt
var s1Length = s1?.length
// Das lässt sich beliebig lang fortsetzen
var example = s1?.elementAtOrNull(10)?.dec()
// Möglichkeit 3
var s0Length = s0!!.length // Wirft NullPointerException, wenn s0 == null

Ein kleiner Ausblick auf Lambda-Funktionen: Angenommen eine Funktion, die auf einer Variablen v aufgerufen wird, die auch Null sein kann, liefert ein Ergebnis zurück. Mit dem Ergebnis wollt ihr nun weiter arbeiten, vorausgesetzt v ist nicht Null. Dann hilft euch Kotlin mit let:

Java

public String s = "";
if(s != null) {
  if(s.isEmpty()) {
    System.out.println("String s ist nicht null aber leer.");
  }
}

Kotlin

var s: String? = ""
s?.let{ if(it.isEmpty()) println("String s ist nicht null aber leer.") }

Das Keyword „it“ ist nichts anderes als die Variable s, die let an den Scope zwischen den geschweiften Klammern weitergibt. Jedoch wird der Scope nur ausgeführt, wenn s nicht Null ist. Der Einsatz dieser Funktion wirkt hier zwar noch banal, in der Realität ist sie jedoch unfassbar nützlich und spart immer wieder Code ein.

Typecasting – in Java ist das häufig mit redundantem Code verbunden. Erst muss der Variablen-Type geprüft werden, dann muss die Variable nochmal extra gecastet werden. In Kotlin ist letzteres nicht notwendig.

Java

public int getStringLength(Object obj) {
  if(obj instanceof String){
    // obj muss explizit zum String gecastet werden!
    return ((String) obj).length();
  }
  return null;
}

Kotlin

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
      // obj wird automatisch zum String
      return obj.length
  }
  return null
}

In den folgenden Fällen wird „obj“ auch automatisch zum String:

fun getStringLength(obj: Any): Int? {
  if (obj !is String) return null
  return obj.length
}
// Oder auch hier auf der rechten Seite der if-Anweisung
fun getStringLength(obj: Any): Int? {
  if (obj is String && !obj.isEmpty())
    return obj.length
  return null
}

Das Switch-Case-Konstrukt gibt es in Kotlin nicht. Ersetzt wird es durch die innovative When-Verschachtelung.

val x = 2
when (x) {
  1 -> println("x == 1")
  Integer.parseInt("2") -> println("x == 2")
  in 3..5 -> println("x liegt zwischen 3 und 5")
  else -> {
    println("x ist etwas anderes")
  }
}
// Oder ihr nutzt when statt if
val s = "t3n"
when {
  s.contains("n") -> println("$s contains n")
  x == 3 -> println("$s hat kein n, x ist aber 3")
  else -> println("Irgendwas anderes")
}

Keine Lust, den immer wieder gleichen Code zu schreiben? Dann kannst du sogenannte Daten-Klassen verwenden. Dort werden die folgenden Funktionen automatisch vom Compiler erstellt:

• equals()
• hashCode()
• toString() in der Form "Company(name=t3n, location=Hanover, hasWebsite=true)"
• Setter und Getter
• copy()

Das sorgt für einen immens reduzierten Code im Vergleich zu Java.

Java

public class Company {

  private String name;
  private String location;
  private boolean hasWebsite;

  public String getName(){
    return this.name;
  }

  public void setName(String name){
    this.name = name;
  }

  /* Und die anderen Setter und Getter ... */

  @Override
  public boolean equals(Object obj){
    if(obj == null || getClass() != obj.getClass())
      return false;
    if(this == obj)
      return true;
    Car other = (Car) obj;
    /* Vergleiche jede einzelne Eigenschaft miteinander */
    
  }

  @Override
  public String toString() { /* ...... */ }
}

Kotlin

Mehr als diese eine Zeile Code ist dafür nicht nötig:

data class Company(private var name: String, private var location: String, private var hasWebsite: Boolean)

Wie innovativ und leicht lesbar Kotlin-Code an vielen weiteren Stellen ist, zeigen die weiteren Beispiele.

// Filtern einer Liste
val a = list.filter{ it > 0 }

// Auf Maps zugreifen (ohne 'mutable' ist Map nicht veränderbar)
val map = mutableMapOf("x" to 1, "y" to 2, "z" to 3)
map["y"] = 5
print(map["y"]) // gibt 5 aus

// Über ganze Map iterieren
for((key, value) in map) {
  println("$key -> $value")
}

// Nützlicher Einsatz von Ranges
for (i in 1..10){} // Schleife läuft von i=1 bis i=10
for (i in 1 until 10){} // Schleife läuft von i=1 bis i=9
for (i in 1..10 step 2){}
for (i in 10 downTo 1){}

// Erstell eine Liste
val list = listOf(1, 2, 3) // nicht veränderbar
val mutableList = mutableListOf(1, 2, 3) // veränderbar
mutableList += listOf(4, 5) // mutableList = [1, 2, 3, 4 , 5]

// Erweitere beliebige Klassen mit neuen Funktionen
fun String.removeLastChar(): String = this.substring(0, this.length - 1)

Das war so ziemlich die wichtigste Syntax von Kotlin. Doch nur durchlesen reicht nicht – probier es selbst aus. Wenn du von Java kommst, schnapp dir ein kleines Java-Projekt oder ein paar Klassen und schreib sie einfach mal in Kotlin um.

Was du noch über Kotlin wissen solltest:

• Kotlin wird offiziell von Android unterstützt
• Bessere Kotlin-Unterstützung und Java 8 mit Android Studio 3.0