简单的kotlin练习(ing)

fun main(args: Array<String>) {
    println("Hello, world!")
}

fun main(args: Array<String>) {
    if (args.size == 0) {
        println("Please provide a name as a command-line argument")
        return
    }
    println("Hello, ${args[0]}")
}

fun main(args: Array<String>) {
    for (name in args) {
        println("Hello, $name")
    }
}

fun main(args: Array<String>) {
    val language = if (args.size == 0) "EN" else args[0]
    println(when (language) {
        "EN" -> "Hello!"
        "FR" -> "Salut!"
        "IT" -> "Ciao"
        else -> "Sorry, I can't greet you in $language yet"
    })
    for (name in args) {
        println("Hello, $name")
    }
}

    class Greeter(val name: String) {
        fun greet() {
            println("Hello, ${name}")
        }
    }

    fun main(args: Array<String>) {
        Greeter(args[0]).greet()
    }

    fun main(args: Array<String>) {
        println(max(args[0].toInt(), args[1].toInt))
    }
    fun max(a: Int, b: Int) = if (a > b) a else b

    fun parseInt(str: String): Int? {
        try {
            return str.toInt()
        } catch (e: NumberFormatException) {
            println("One of the arguments isn't Int")
        }
        return null
    }

    fun main(args: Array<String>) {
        if (args.size < 2) {
            println("No number supplied")
        } else {
            val x = parseInt(args[0])
            val y = parseInt(args[1])

            if(x != null && y != null) {
                println(x * y)
            } else {
                println("One of the arguments is null")
            }
        }
    }

    fun main(args: Array<String>) {
        println(getStringLength("aaa"))
        println(getStringLength(1))
    }

    fun getStringLength(obj: Any): Int? {
        if (obj is String)
            renturn obj.length
        return null
    }

    fun main(args: Array<String>) {
        var i = 0
        while (i < args.size)
            println(args[i++])
    }

    fun main(args: Array<String>) {
        for (arg in args) {
            println(arg)
        }

        //or
        println()
        println("===" + args.indices)
        for (i in args.indices) {
            println(args[i])
        }
    }

    fun main(args: Array<String>) {
        val x = args[0].toInt()
        //check if a number lies within a range:
        val y = 10
        if (x in 1..y-1)
            println("OK")

        //Iterate over a range:
        for (a in 1..5)
            println("${a}  ")

        //check if a number is out of range:
        println()
        val array = arrayListOf<String>()
        //val array = ArrayList<String>()
        array.add("aaa")
        array.add("bbb")
        array.add("ccc")

        println("===" + x)
        if (x !in 0..array.size -1)
            println("Out: array has only ${array.size} elements. x = ${x}")

        //check if a collection contains an object:
        if ("aaa" in array) // collection.contains(obj) is called
            println("Yes: array contains aaa")
        if ("ddd" in array) // collection.contains(obj) is called
            println("Yes: array contains aaa")
        else 
            println("No: array doesn't contains ddd")
    }

    fun main(args: Array<String>) {
        cases("Hello")
        cases(1)
        cases(0L)
        cases(MyClass())
        cases("hello")
    }

    fun cases(obj: Any) {
        when (obj) {
            1 -> println("One")
            "Hello" -> println("Greeting")
            is Long -> println("Long")
            !is String -> println("Not a string")
            else -> println("Unknown")
        }
    }

    class MyClass() {

    }

    /*See http://kotlinlang.org/docs/reference/multi-declarations.html#multi-declarations*/
    fun main(args: Array<String>) {
        val pair = Pair(1, "one") 
        val (num, name) = pair
        println("num = $num, name = $name")
    }

    class Pair<K, V>(val first: K, val second: V) {
        operator fun component1(): K {
            return first
        }

        operator fun component2(): V {
            return second
        }
    }

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

    fun getUser(): User {
        renturn User("Alex", 1)
    }

    fun main(args: Array<String>) {
        val user = getUser()
        println("name = ${user.name}, id = ${user.id}")

        //or
        val (name, id) = getUser()
        println("name = $name, id = $id")

        //or
        println("name = ${getUser().compont1()}, id = ${getUser().componet2()}")
    }

    fun main(args: Array<String>) {
        val map = hashMapof<String, Int>()
        map.put("one", 1)
        map.put("two", 2)

        for ((key, value) in map) {
            println("key = ${key}, value = $value")
        }
    }

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

    fun main(args: Array<String>) {
        val user = User("Alex", 1)
        println(user) // toString

        val secondUser = User("Alex", 1)
        val thirdUser = User("Max", 2)

        println("user == seconedUser: ${user == secondUser}")//true
        println("user == thirdUser: ${user == thirdUser}")//false

        //copy() function
        println(user.copy())
        println(user.copy("Max"))
        println(user.copy(id = 2))
        println(user.copy("Max", 2))
    }

    class Example {
        var p: String by Delegate()

        override fun toString() = "Example Class"
    }

    class Delegate() {
        operator fun getValue(thisRef: Any?, prop: KProperty<*>): String {
            return "$thisRef, thank you for delegating '${prop.name}' to me!"
        }

        operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: String) {
            println("$value has been assigned to ${prop.name} in $thisRef")
        }
    }

    fun main(args: Array<String>) {
        val e = Example()
        println(e.p)
        e.p = "NEW"
    }

// 后续调用 get() 只是返回记录的结果。
    class LazySample {
        val lazy: String by lazy {
            println("computed!")
            "my lazy"
        }
    }

    fun main(args Array<String>) {
        val sample = LazySample()
        println("lazy = ${sample.lazy}")
        println("lazy = ${sample.lazy}")
    }

/*Delegates.observable() 接受两个参数：初始值和修改时处理程序（handler）。 每当我们给属性赋值时会调用该处理程序（在赋值后执行）。它有三个参数：被赋值的属性、旧值和新值：*/
    class User {
        var name: String by Delegates.observable("no name") {
            prop, old, new -> 
            println("$old -> $new")     
        }
    }

    fun main(args Array<String>) {
        var user = User()
        user.name = "Carl"
    }

    class User {
        var name: String by Delegates.notNull()
        fun init(name: String) {
        this.name = name
        }
    }

    fun main(args: Array<String>) {
        val user = User();
        //user.name -> IllegalStateException
        user.init("Carl")
        println(user.name)
    }

    class User(val map: Map<String, Any?>) {
        val name: String by map
        val age: Int by map
    }

    fun main(args: Array<String>) {
        val user = User(mapOf(
                    "name" to "John doe",
                    "age" to 25
                    ))
        println("name = ${user.name}, age = ${user.age}")
    }

    /*"Callable References" or "Feature Literals", i.e. an ability to pass
     * named functions or properties as values. Users often ask
     * "I have a foo() function, how do I pass it as an argument?".
     * The answer is: "you prefix it with a `::`".*/
    fun main(args: Array<String>) {
        val numbers = listOf(1, 2, 3)
        println(numbers.filter(::isOdd))
    }

    fun isOdd(x: Int) = x % 2 != 0