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

Wie es die offizielle Seite zusammenfasst:

 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
 ...

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

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"]

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

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

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

object Utils {
  fun doSomething(){}
}

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

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

// 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:

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
    }

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.