interface MyInterface {
    fun bar()
    fun foo() {
      // デフォルト実装を持てる
    }
}

// classとobjectは１つまたは複数のinterfaceを実装できる
class Child : MyInterface {
   override fun bar() {
      // オーバーライドする内容
   }
}

interface MyInterface {
    // バッキングフィールドはないので値は与えられない
    val property: Int // abstract

    // getterの実装を与えることはできる
    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        // 値はなくてもオーバーライドされる前提でプロパティにアクセスできる
        print(property)
    }
}

class Child : MyInterface {
    // abstractになってるpropetryをオーバーライド
    override val property: Int = 29
}

interface A {
  fun foo() { print("A") }
  fun bar()
}

interface B {
  fun foo() { print("B") }
  fun bar() { print("bar") }
}

class C : A {
  // Aのbar()をオーバーライド
  override fun bar() { print("bar") }

  // foo()の方はAのデフォルト実装を利用
}

class D : A, B {
  // AもBもfoo()の実装を持ってるんで、どっち使うかわからん。
  // なのでオーバーライド必須。
  override fun foo() {
    super<A>.foo()    // Aのfoo()を呼び出す
    super<B>.foo()    // Bのfoo()を呼び出す
  }

  // bar()の方はBしか実装がないから、オーバーライドしなけりゃそっち使うよ。
}

package foo

// privateだとこのファイル内だけでしか見えない
private fun foo() {}

// publicなのでこのプロパティはどこからでも見える
public var bar: Int = 5
    private set    // setterはこのファイル内からしか見えない

// internalは同じモジュール内なら見える
internal val baz = 6

open class Outer {
    private val a = 1
    protected val b = 2
    internal val c = 3
    val d = 4  // 何も指定しなければpublic

    protected class Nested {
        public val e: Int = 5
    }
}

class Subclass : Outer() {
    // a は見えない
    // b, c, d は見える
    // Nested と e は見える
}

class Unrelated(o: Outer) {
    // o.a, o.b は見えない
    // o.c は見える。 o.d も同じモジュールなので見える
    // Outer.Nested は見えない。なので Nested::e も見えない。
}

class C private constructor(a: Int) { ... }

// MutableList<Int>にswapを付け足す
fun MutableList<Int>.swap(index1: Int, index2: Int) {
  val tmp = this[index1]
  this[index1] = this[index2]
  this[index2] = tmp
}

val list = mutableListOf(1, 2, 3)
// こんな感じで使える
list.swap(0, 2) // swapメソッドの中のthisはlistを指す

// ジェネリクス関数としても追加できる
fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
  val tmp = this[index1]
  this[index1] = this[index2]
  this[index2] = tmp
}

open class C

class D: C() // Cを継承

// 拡張でCにfooメソッドを付け足す
fun C.foo() = "c"
// 拡張でDにfooメソッドを付け足す
fun D.foo() = "d"

// Cクラスのインスタンスを受け取る
fun printFoo(c: C) {
    // 拡張の場合、cはCクラスなのでC.foo()を呼び出すように静的に解決される。
    // オーバーライドされたメソッドのように動的に解決されるわけじゃない。
    println(c.foo())
}

// Cの子供のDを渡す。Dに拡張で足したD.foo()が呼び出される・・・よね？
// 残念でした〜！！C.foo()が呼びだされまーす！！
printFoo(D()) // "c"が表示される

class C {
    fun foo() { println("正社員") }
}

// Cクラスのメンバーを派遣で置き替えたいんだけど・・・
// ダメです！！常に正社員が優先です！！
fun C.foo() { println("派遣") }

val c = C()
c.foo()    // "正社員"って表示される。拡張で上書きはできない。

// Nullableに拡張関数を追加
fun Any?.toString(): String {
    // thisはnullの可能性がある！！
    if (this == null) return "null"
    // nullチェックした後ならもうnullじゃないことがコンパイラには分かるから、
    // thisは勝手にnullでない参照に置き換わる。
    return toString() // これはthis.toString()と同じだけど、thisは既にAny?でなくAny
}

// List<T>にlastIndexプロパティを付け足す
val <T> List<T>.lastIndex: Int
  get() = size - 1

val Foo.bar = 1 // error: 拡張プロパティの初期化はできない！！

class MyClass {
  companion object { }  // "Companion"って呼んでね♥︎
}

// MyClassのコンパニオンオブジェクトにfoo()を付け足す
fun MyClass.Companion.foo() {
  // ...
}

// コンパニオンオブジェクトの他のメンバと同じように呼び出せる。
// 呼び出すときはCompanionって付けなくてもいい。貴方に影ながら付き添います。
MyClass.foo()

package foo.bar

fun Baz.goo() { ... }

package com.example.usage

import foo.bar.goo // "goo"って名前の全ての拡張をインポートする
                   // または
import foo.bar.*   // "foo.bar"の全てをインポートする
// Baz.gooだけを狙い撃ちでインポートってのはできないっぽい

fun usage(baz: Baz) {
  baz.goo()
)

// Java
Collections.swap(
    list,
    Collections.binarySearch(list, Collections.max(otherList)),
    Collections.max(list)
    );

// Java
swap(list, binarySearch(list, max(otherList)), max(list))

// Java（もしこうなら）
list.swap(list.binarySearch(otherList.max()), list.max())