Prägnanz vs. Lesbarkeit

import java.util.*

fun main(args: Array<String>) {
    val name = if (args.size > 0) args[0] else "Publikum"
    val zuschauer = Gast(name, title = Title.wertes)

    println(zuschauer)
    println("Hallo ${zuschauer.title} ${zuschauer.name}")
}

class Gast(val name: String,
           var zeit: Date = Date(),
           val title: Title)
enum class Title { Herr, Frau, wertes }                

Java/Kotlin Interop

Mischen von Java & Kotlin-Code

bei problemlosem, gleichzeitigen Zugriff in beide Richtungen

Tooling: Design Goals

Automatische Konvertierung
Java → Kotlin

Type inference

Data Classes

Werte-Container

... exakt dasselbe mit Java

public final class Gast {
  @NotNull
  private final String name;
  @NotNull
  private Date zeit;
  @Nullable
  private final Title title;

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

  @NotNull
  public final Date getZeit() {
    return this.zeit;
  }

  public final void setZeit(@NotNull Date date) {
    checkParameterIsNotNull(date, "<set-?>");
    this.zeit = date;
  }

  @Nullable
  public final Title getTitle() {
    return this.title;
  }

  public Gast(@NotNull String name,
              @NotNull Date zeit,
              @Nullable Title title) {
    checkParameterIsNotNull(name, "name");
    checkParameterIsNotNull(zeit, "zeit");
    this.name = name;
    this.zeit = zeit;
    this.title = title;
  }

  public Gast(String string, Date date,
              Title title, int n) {
    if ((n & 2) != 0) {
      date = new Date();
    }
    this(string, date, title);
  }

  @NotNull
  public final String component1() {
    return this.name;
  }

  @NotNull
  public final Date component2() {
    return this.zeit;
  }

  @Nullable
  public final Title component3() {
    return this.title;
  }

  @NotNull
  public final Gast copy(@NotNull String name,
                         @NotNull Date zeit,
                         @Nullable Title title) {
    checkParameterIsNotNull(name, "name");
    checkParameterIsNotNull(zeit, "zeit");
    return new Gast(name, zeit, title);
  }

  public String toString() {
    return "Gast(name=" + this.name +
           ", zeit=" + this.zeit +
           ", title=" + this.title + ")";
  }

  public int hashCode() {
    String s = this.name;
    Date d = this.zeit;
    Title t = this.title;
    return ((s != null ? s.hashCode() : 0) * 31
          + (d != null ? d.hashCode() : 0)) * 31
          + (t != null ? t.hashCode() : 0);
  }

  public boolean equals(Object object) {
    if (this == object) return true;

    if (!(object instanceof Gast))
        return false;

    Gast gast = (Gast)object;
    if (!areEqual(this.name, gast.name)
        || !areEqual(this.zeit, gast.zeit)
        || !areEqual(this.title, gast.title))
        return false;

    return true;
  }
}

Extension methods

fun String.lastChar() = this.get(this.length - 1)

// Verwendung
val c = "Hallo Zuschauer!".lastChar()

Extension properties

// Extension property für das Android EditText Widget
var EditText.stringValue: String
    get() = text.toString()
    set(str) { setText(str)  }

// Verwendung
nameField.stringValue = "Max Muster"

Utilities „frei Haus“

List<String> list = Arrays.asList("a","b","c");
for (int index = 0; index < list.size(); index++) {
    if (index % 2 == 0)
        System.out.println(index + " -> " + list.get(index));
}

val list = listOf("a", "b", "c")
for (index in list.indices.filter { it % 2 == 0 }) {
    println("$index -> ${list.get(index)}")
}

First-class immutables

open class ExtendableClass {
    open fun overridableMethod() { … }
}

class Derived: ExtendableClass() {
    override fun overridableMethod() { … }
}

The
billion-dollar
mistake

Nullwert-Sicherheit

Effizienter Umgang mit Nullwert-Typen

Effizienter Umgang mit Nullwert-Typen

null-Werte aus Java-Code

Alle Rückgabewerte aus Java-Code als T? zu verstehen
wäre zwar richtig, aber extrem unkomfortabel.

Daher besitzt Kotlin das Konzept sog. Platform Types T!.

↓

Beispiel: static-Feld

kein direktes static in Kotlin, sondern companion object

Ausdrücke & Konventionen

Im Mai 2017 – die Antwort

Kotlin Extensions aktivieren

Virtuelle Properties
für UI-Elemente

import kotlinx.android.synthetic.main.mylayout.*

edit_title.setText(mItem.title)
enable_box.isChecked = true
create_entry.setOnClickListener { createElement() }

Ein einfacher Import erlaubt typsicheren Zugriff auf alle
darin enthaltene View-Elemente direkt als simples Property.
Ohne zusätzlichen Code, Annotations oder Runtime!

Hello Android: Code part #1

Hello Android: Code part #2

Higher-order functions – Beispiel

class FirstClassFunction(
        val f1: (String) -> Int,
        val f2: (Int) -> Boolean) {

    fun strToBool(str: String): Boolean {
        val f: (String) -> Boolean = higherOrderFun()
        return f(str)
    }

    private fun higherOrderFun(): (String) -> Boolean {
        return { x -> f2(f1(x)) }
    }
}

fun main(args: Array<String>) {
    val c = FirstClassFunction(
                Integer::parseInt,
                { it % 2 == 0 }
            )
    val strings = listOf("2", "7", "8")
    println(strings.map(c::strToBool))
}

GUI & null – Typische Konstellation

Operatoren

Über Namenskonventionen. Feste Menge & Präzedenz

Typsichere DSLs über „Empfänger“-Objekt

Es ist möglich, Funktionssignaturen zu definieren, die Lambda-Ausdrücke erwarten bei denen this auf Zielobjekte eines bestimmten Typs zeigen.

Darüber sind typsichere DSLs möglich:

Gradle Kotlin DSL – build.gradle.kts

Inlining

Infix Notation

Im Browser ausprobieren

→ http://try.kotl.in/

Quellen & Materalien