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

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

Type inference

fun noTypeInfer(vals: List<Int>): Unit {
  val distinct: Set<Int> = vals.toSet()
  val first: Int = vals[0]
  val negs: List<Int> = vals.filter(
    fun(n: Int): Boolean {
        return n < 0
    }
  )
}

fun typeInfer(vals: List<Int>){
  val distinct = vals.toSet()
  val first = vals[0]
  val negs = vals.filter(
     fun(n) = n < 0


  )
}

Data Classes

data class Gast(
    val name: String,
    var zeit: Date = Date(),
    val title: Title?
)

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

Ausdrücke & Konventionen

Idiome

fun isEven(i: Int) = if (i.mod(2) == 0) "gerade" else "ungerade"

private fun toJSON(aha: Aha): JSONObject {
    with(JSONObject()) {
        put(JSON_ID, aha.id.toString())
        put(JSON_TITLE, aha.title)
        put(JSON_USEFUL, aha.isUseful)
        return this
    }
}

Konventionen - Operatoren

First-class immutables

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

The
billion-dollar
mistake

Nullwert-Sicherheit

var nullable: String? = null
var nonNullable: String = "Hi!"

// Ab hier compiliert nichts mehr …
nonNullable = nullable
nonNullable = null
nullable.isEmpty()

Effizienter Umgang mit Nullwert-Typen

nullable = nullable?.toUpperCase()

nonNullable = nullable ?: ""

// equals/orEmpty für String?
nonNullable = nullable.orEmpty()
val b = nullable.equals("foo")

if (nullable != null) {
   nonNullable = nullable.trim()
}

//NPE-Gefahr voraus!
nullable!!.trim(3)
nonNullable = nullable!!

Effizienter Umgang mit Nullwert-Typen

TextView child = null;
if (toolbar != null && toolbar.getChildAt(0) instanceof TextView) {
    child = (TextView) toolbar.getChildAt(0);
}
textView = child != null ? child : new TextView(getBaseContext());

if (textView instanceof EditText) {
    ((EditText) textView).selectAll();
}

val child = toolbar?.getChildAt(0) as? TextView
textView = child ?: TextView(baseContext)

if (child is EditText) {
    child.selectAll()
}

1. Android Studio Plugin installieren

2. Kotlin im Projekt aktivieren

3. Kotlin Extensions aktivieren (optional)

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!

Extension methods / properties

// Extension method  für ein Android Fragment
fun Fragment.toast(message: String, duration: Int = Toast.LENGTH_SHORT) {
  Toast.makeText(this.getActivity(), message, duration).show()
}

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

// Verwendung
toast("Hallo Zuschauer!")
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[index]}")
}

Fokus: Tooling

Automatische Konvertierung
Java → Kotlin

Hello Android: Code part #1

Hello Android: Code part #2

Android & null – Typische Konstellation

class EditPersonActivity : FragmentActivity() {

    var person: Person
    var anrede: String
    var imm: InputMethodManager
    …

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val personId = savedInstanceState?.getInt("value",0)

        person = PersonManager.load(id)
        anrede = resources.getString(R.string.anrede)
        imm = getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
    }
}

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.filter(c::strToBool)) // Kotlin 1.1+
}

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:

class HTML {
    fun body() { ... }
}

fun html(init: HTML.() -> Unit): HTML {
  val html = HTML()
  html.init()
  return html
}

html {
    body()
}

Anko: Android-DSL für XML

relativeLayout {
    lparams(width = matchParent, height = matchParent)
    backgroundResource = R.drawable.background_activated

    checkBox {
        enabled = false
        gravity = Gravity.CENTER
        padding = dip(4)
        lparams(width = wrapContent, height =  wrapContent)  {
            alignParentRight()
        }
    }

    textView {
        textResource = R.string.aha_title
        rightPadding = dip(4)
        leftPadding = dip(4)
        lparams(width = matchParent, height =  wrapContent) {
            leftOf(cb)
        }
    }
}

Infix Notation

infix fun Int.shl(x: Int): Int {
   …
}

1 shl 2       // als Equivalent zu 1.shl(2)

Im Browser ausprobieren

→ http://try.kotl.in/

Quellen & Materalien