[Kotlin] added type aliases, inline classes, delegation, delegated properties, singleton, functions

Author: Catherine22

KotlinFromScratch/.idea/kotlinc.xml

@@ -0,0 +1,97 @@
+import kotlin.properties.Delegates
+import kotlin.reflect.KProperty
+
+class DelegatedProperties {
+    fun test() {
+        println("Standard delegates - Lazy")
+        val lazyValue: String by lazy {
+            println("computed")
+            "Hello"
+        }
+        println("Call lazy value at the first time: $lazyValue")
+        println("Call lazy value again: $lazyValue")
+
+        // skip Lazy, read more in singleton_kotlin/
+        println("")
+        println("Observable")
+        val user = User()
+        user.name = "first"
+        user.name = "second"
+
+
+        println("")
+        println("Storing Properties in a Map")
+        val classmate = Classmate(
+            mapOf(
+                "name" to "John Doe",
+                "age" to 25
+            )
+        )
+        println("name: ${classmate.name}, age: ${classmate.age}")
+        println("")
+        println("Storing Properties in a mutable map")
+        val mutableClasses = MutableClassmate(
+            mutableMapOf(
+                "name" to "John Doe",
+                "age" to 25
+            )
+        )
+        mutableClasses.age = 29
+        println("name: ${mutableClasses.name}, age: ${mutableClasses.age}")
+
+
+        println("")
+        println("Implement properties including standard delegates once for all")
+        val e = Example()
+        println(e.p)
+        e.p = "new"
+
+
+        println("")
+        println("Local delegated properties")
+        f {Foo()}
+
+    }
+
+    private fun f(computeFoo: () -> Foo) {
+        val memorizedFoo by lazy(computeFoo)
+        if (memorizedFoo.isValid()) {
+            memorizedFoo.doSomething()
+        }
+    }
+
+    class Example {
+        var p: String by Delegate()
+    }
+
+    class Delegate {
+        operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
+            return "$thisRef, thank you for delegating '${property.name}' to me!"
+        }
+
+        operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
+            println("'$value' has been assigned to '${property.name}' in $thisRef.")
+        }
+    }
+
+    class User {
+        var name: String by Delegates.observable("<no name>") { _, oldValue, newValue ->
+            println("$oldValue -> $newValue")
+        }
+    }
+
+    class Classmate(map: Map<String, Any?>) {
+        val name: String by map
+        val age: Int by map
+    }
+
+    class MutableClassmate(map: MutableMap<String, Any?>) {
+        var name: String by map
+        var age: Int by map
+    }
+
+    class Foo {
+        fun isValid(): Boolean = true
+        fun doSomething() = println("Do something")
+    }
+}

KotlinFromScratch/.idea/workspace.xml

@@ -0,0 +1,43 @@
+class Delegation {
+
+    fun test() {
+        println("Implementation by delegation")
+        val baseImpl = BaseImpl(10)
+        Derived(baseImpl).println() // message from BaseImpl, if you want to show message from Derived, override println()
+        Derived(baseImpl).print()
+        println(Derived(baseImpl).message) // message from Derived
+    }
+
+    interface Base {
+        val message: String
+        fun print()
+        fun println()
+    }
+
+    class BaseImpl(x: Int) : Base {
+        override val message = "BaseImpl: x = $x"
+
+        override fun print() {
+            print(message)
+        }
+
+        override fun println() {
+            println(message)
+        }
+    }
+
+    // The last "b" (from ": Base by b") is implemented by the "b" in "Derived(b: Base)"
+    class Derived(b: Base) : Base by b {
+
+        override val message = "Message of Derived"
+        // overriding functions is optional
+        override fun print() {
+            print("Derived\n")
+        }
+
+        // override println() or println the message from BaseImpl
+//        override fun println() {
+//            println(message)
+//        }
+    }
+}

KotlinFromScratch/src/DelegatedProperties.kt

@@ -30,7 +30,7 @@ class EnumClasses {
 
     enum class RGB { RED, GREEN, BLUE }
 
-    inline fun <reified T : Enum<T>> printAllValues() {
+    private inline fun <reified T : Enum<T>> printAllValues() {
         print(enumValues<T>().joinToString { it.name })
     }
 

KotlinFromScratch/src/Delegation.kt

@@ -0,0 +1,92 @@
+class Functions {
+    fun test() {
+        println("Basic functions")
+        println(double(10))
+        println(triple(10))
+        println(isPrimeNumber(17))
+
+        println("")
+        println("Default arguments")
+        val s = "Function parameters can have default values, which are"
+        read(s.toByteArray())
+
+        println("")
+        println("Override functions")
+        val b = B()
+        b.foo()
+
+        println("")
+        println("lambda")
+        foo(0, 2) { println("Fill in all arguments") }
+        foo(0) { println("Fill in some arguments") }
+        foo(baz = 2) { println("Fill in specific arguments") }
+        foo(qux = { println("Fill in the last argument") })
+        foo { println("Fill in the last argument") }
+
+
+        println("")
+        println("variable number of arguments (vararg)")
+        foo(strings = *arrayOf("a", "b", "c"))
+
+        println("")
+        println("Unit-returning functions")
+        println("fun bar(): Unit {} is equivalent to fun bar() {}")
+
+
+        println("")
+        println("infix functions")
+        println("aaa".add(3))
+        println("aaa" add 3)
+        this bar "bbb"
+        bar("bbb")
+
+        println("")
+        println("Local functions")
+        f()
+    }
+
+    private fun double(x: Int): Int = 2 * x
+    private fun triple(x: Int) = 3 * x
+    private fun isPrimeNumber(x: Int): Boolean {
+        var factors = 0
+        for (i in 2..x / 2) {
+            if (x % i == 0) {
+                factors++
+            }
+        }
+        return factors == 0
+    }
+
+    private fun read(bytes: ByteArray, off: Int = 0, len: Int = bytes.size) {
+        val s = String(bytes, off, len)
+        println(s)
+    }
+
+    open class A {
+        open fun foo() {}
+    }
+
+    class B : A() {
+        override fun foo() {}
+    }
+
+    private fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) {
+        qux()
+    }
+
+    // In Java -> public void println(String.. args) { }
+    private fun foo(vararg strings: String) {
+        println(strings[0])
+    }
+
+    private infix fun String.add(x: Int) = "$this$x"
+    private infix fun bar(s: String) = println(s)
+
+    private fun f() {
+        fun f() {
+            println("call f() in f()")
+        }
+        print("call f() -> ")
+        f()
+    }
+}

KotlinFromScratch/src/EnumClasses.kt

@@ -0,0 +1,55 @@
+// since Kotlin 1.3, it is impossible to call functions which accept inline classes from Java.
+class InlineClass {
+
+    fun test() {
+        println("Inline Classes")
+        val martin = Name("Martin")
+        martin.greet()
+        println(martin.length)
+
+        println("")
+        println("Representation")
+        asInline(martin)
+        asGeneric(martin)
+        asInterface(martin)
+        asNullable(martin)
+        println(id(martin))
+
+        println("")
+        println("Inline classes vs type aliases")
+        val nameAlias: NameTypeAlias = ""
+        val nameInlineClass: NameInlineClass = NameInlineClass("")
+        val s: String = ""
+
+        acceptString(nameAlias)
+//        acceptString(nameInlineClass) // not allow
+
+        acceptNameTypeAlias(s)
+//        acceptNameInlineClass(s) // not allow
+
+    }
+
+    private fun asInline(n: Name) {}
+    private fun <T> asGeneric(t: T) {}
+    private fun asInterface(i: I) {}
+    private fun asNullable(n: Name?) {}
+    private fun <T> id(t: T): T = t
+
+    private fun acceptString(s: String) {}
+    private fun acceptNameTypeAlias(n: NameTypeAlias) {}
+    private fun acceptNameInlineClass(n: NameInlineClass) {}
+}
+
+interface I
+
+inline class Name(private val s: String) : I {
+    val length: Int
+        get() = s.length
+
+    fun greet() {
+        println("Hello, $s")
+    }
+}
+
+inline class NameInlineClass(val s: String)
+typealias NameTypeAlias = String