Wie wir alle wissen, hat Google Kotlin als first class Programmiersprache für Android erklärt. Das bedeutet vollen Support für die Programmiersprache und absolut keine Nachteile für die Entwicklung damit. - Im Gegenteil!

What you'll learn

• Warum Kotlin sinnvoll und beliebt ist
• Ein kleines Kotlin Syntax Basiswissen
• Was Kotlin besonders effektiv bei der Android-Entwicklung macht

Wie es die offizielle Seite zusammenfasst:

• Keine Semikolons notwendig, Variablendeklaration als mutable und immutable

 var hello: String = "Hello" // mutable, also veränderbar

 val hi: String = "hi" // immutable, also final und nicht veränderbar

 private val world: String = "World" // privater Zugriff nur innerhalb der Klasse

 private val aNumber: Int = 2
 private val aBoolean: Boolean = true
 private val aFloat: Float = 2.1f
 private val aDouble: Double = 2.1
 ...

• (Versuchte) Eliminierung von Null-Pointer Exceptions mit Optional Deklarierung per ?

val user: User? = null // optional: named parameters! Wegfall "new"

user = User(name = "Alice")

user?.name = "Bob" // User hat jetzt einen neuen Namen

user = null

user.name = "Charlie" // Compiler-Error

user!!.name = "Charlie" // "force Unwrap", wenn möglich vermeiden; wäre hier eine Nullpointer Exception!

user?.let {
  // guard, hier drinnen ist "it" der user (ähnlich this in java) und "it" ist nicht mehr nullable!
    it.name = "Alice"
}

• Typinferenz, Typenherleitung spart viel Schreibarbeit

var hello = "Hello" // String, sonst: var hello: String = "Hello"

val one = 1 // Int, sonst: val one: Int = 1

val lon = 34.6 // Double, sonst: val lon: Double = 34.6

val isIt = true // Boolean, sonst: val isIt: Boolean = true

val woho = ["1", "2". "3"] // [String], sonst: val woho: List<String> = ["1","2","3"]

• Klassen: Anlegen mit Keyword class. Vererbung und Implementierung von Interfaces durch :

class User(val name: String, val age: Int) { ...} // Finale Klasse mit Konstruktor Variablen

class User: Human, InteractionListener { ...} // erbt von Human, implementiert InteractionListener

open class Human { ...} // vererbbare Klasse

• Besonders schnell und einfach zu verwenden: data classes mit equals(), toString() und hashCode() - Funktionen

data class User(val name: String, val age: Int)

• Funktionen machen Spaß: Deklaration mit fun und dem Typen Unit als Ersatz für void in Java. Somit die Standard return Value einer Funktion, die keinen Rückgabewert hat.

Es gilt daher gleichbedeutend

private fun doSomething(): Unit {
    print("Hello World")
    return Unit
}

und

// prägnantere, gewöhnlichere Schreibweise:
private fun doSomething() {
    print("Hello World")
}

• Statische Funktionen innerhalb einer Klasse oder für sich stehend:

object Utils {
  fun doSomething(){}
}

• Extensions ermöglichen die Erweiterung von anderen Klassen um Funktionen

fun String.isHelloWorld(): Boolean { // erweitert die String Klasse
        return if (this == "Hello World") true  // this bezieht sich auf die String Klasse
        else false
}

oder kürzer

fun String.isHelloWorld(): Boolean {
        return (this == "Hello World")
}

oder noch kürzer

fun String.isHelloWorld() = this == "Hello World"

Ein gutes Beispiel ist auch .apply auf ein beliebiges Objekt, das Funktionen innerhalb des Objekts in einem Block aufrufen kann:

val user = User().apply {
    name = Bob
    age = 24

    doSomething()
    doEvenMore()
}

• Kotlin ermöglicht einen funktionalen Programmierungs-Stil. So können Codekonstrukte entstehen mit minimierten Seiteneffekten. Im Folgenden sind die typischsten Anwendungsfälle:

Filter

listOf(1,2,3,4,5,6).filter{ it < 4 } // liefert [1,2,3]

Map

listOf(1,2,3).map { it + 1 } // liefert [2,3,4]

Reduce

listOf(1,2,3).reduce{ total, item -> total + item} // liefert 6

ForEach

listOf(1,2,3).forEach{ print(it) } // liefert 123

// das gleiche mit function reference
listOf(1,2,3).forEach(::print) // liefert 123

• Und vieles weitere mehr, unter anderem können mit diesen Boardmitteln auch eigene Operatoren selbst geschrieben und eigene DSLs entwickelt werden.

• Lambda Expressions sind anonyme Funktionen, die keine Deklaration benötigen. Sie ermöglichen es Funktionen als Parameter zu übergeben.

// Eine Funktion die einen String-Input entgegennimmt
// und prüft ob "hello" enthalten ist und die Anzahl an gefundenen "l"s ausgibt.
fun evaluatateLs(input: String, evaluation: (hasHello: Boolean, lCount: Int) -> Unit) {
     val lowerCasedInput = input.toLowerCase().trim()

     evaluation(lowerCasedInput.contains("hello"), lowerCasedInput.count { it == 'l' })
 }
 // it = Parameter-Value innerhalb des Lambdas, ähnlich aber nicht gleich `this` in java

// Aufruf
fun testIt(){
 evaluatateLs("heLlo WorLd") { hasHello, lCount ->
           assertTrue(hasHello)
           assertEquals(3, lCount)
       }
}

Auto Convert

Gerade für Einsteiger sehr praktisch: Android Studio bietet die Möglichkeit, ganze Java-Files in Kotlin-Files zu konvertierten. Dabei geht der Konverter nach bestimmten Regeln vor.

Außerdem können Codeabschnitte aus einem Java File on the fly konvertiert werden, wenn der Code nach dem Ausschneiden in ein Kotlin File eingefügt wird.

⚠️ Bitte beachte aber unbedingt, dass dieser Code daher eher eine Ahnung davon gibt, wie er in Kotlin geschrieben sein könnte.

1. Kotlin REPL (Read, Eval, Print, Loop) kann benutzt werden für kleinere Codeausschnitte, um mal schnell etwas zu coden und zu testen. öffnet sich sofort und muss nicht auf einem Device ausgeführt werden.
2. Wer sich mit Bytecode auskennt und vergleichen will, ob der Kotlin Bytecode das macht, was er soll, kann sich jederzeit den Bytecode anzeigen lassen.

Warum man mit Kotlin gerade in der Android Entwicklung besonders profitiert:

• Wie wir sehen und noch sehen werden ist der IDE Support hervorragend
• Google liebt mitlerweile Kotlin. Aus diesem Grund in den Developer Guides auch die Vorauswahl Kotlin (Beispiel).
• Für so gut wie alles Wichtige gibt es meist Extension Functions, die das Leben leichter machen.

Java:

button.setOnClickListener(new OnClickListener(){ // java ist in diesem Fall sehr "verbose"
  @Override
  public void onClick(View view){
    // do something
  }
});

Kotlin:

    button.onClick {
      // do something
    }

• Das ergibt weniger Code, der aber besser beschreibt was er macht
• Weniger Nullpointer Exceptions
• Funktionale Programmierung entschlackt oft den Code und entfernt dabei die meisten for-Schleifen

In unserer ersten Coding-Übung legen wir innerhalb unserem erstellten Utils-File eine Klasse User an.

1. Dieser User soll einen veränderlichen login Namen tragen können: "loginName" (String)
2. Dieser User soll außerdem einen festen Identifier haben "identifier" (Int)
3. Eine optionale, veränderliche Url für ein Avatar Bild "avatarUrl" (String) runden sein Profil ab.
4. Innerhalb der Klasse fügen wir jetzt eine print() Methode (fun print(){}) hinzu
   Diese solle Log.e("PRINT", loginName) enthalten, um aus dem Namen des Users auf der Konsole eine Ausgabe zu erzeugen. Importiere dazu mit import android.util.Log die Funktion Log.

In dem File MainActivity unter setContentView(..) erstellen wir jetzt codeseitig einen neuen User mit beliebigem Namen.
Sorge dafür, dass dort die print()-Methode des Users aufgerufen wird.

Über den "Run" Button von Android Studio kannst du dann testen, ob alles funktioniert.
Schaue in der Logcat nach "PRINT". Falls die Logcat viel zu voll ist, suche explizit nach Print und stelle die Ausgabe auf Error.

Wie du siehst, ist die Logcat praktisch für das sehr einfache Debugging auf dem Gerät.

Das war's erstmal.

Jetzt bist du bereit um mit der UI-Entwicklung weiter zu machen.

Mache nun weiter mit den UI Essentials.