Kotlin基础：函数、对象、Lamdba

//表达式与语句:表达式有值，并且能作为另一个表达式的一部分使用；而语句总是包围着它的代码块中的顶层元素，并且没有自己的值。

fun max(a : Int , b: Int) = if (a > b) a else b

//when
fun evalWhen(e: Expr): Int =
when (e) {
    is Num ->
        e.value //智能转换
    is Sum ->
        evalWhen(e.right) + evalWhen(e.left)
    else ->
        throw RuntimeException("类型错误")
}

joinToString(collectio, separator ="", prefix ="", postfix ="·")

fun <T> joinToString(
    collection: Collection<T>,
    separator: String =",",//默认参数值
    prefix: String ="",
    postfix: String = ""
    ) : String{
            
}

@file:JvmName("StrUtil")
package util

fun joinToStr(collection: Collection<String>): String{
    //....
    return "";
}

import util.joinToStr

fun main(args: Array<String>){
    joinToStr(collection = listOf("123", "456"))
}

/**
 * 扩展函数
 *
 *  String-接收者类型           get(this.length -1) 对接收者对象(字符串)进行操作并返回
 */
fun String.lastChar() : Char = get(this.length -1)

fun main(args: Array<String>) {
    System.out.println("Kotlin".lastChar())
}

import strings.lastChar

fun <K, V> mapOf(vararg values: Pair<K, V>): Map<K , V>
//使用
mapOf(1 to "One",2 to "Two")

//重写toString,equals,hashCode
override fun toString() = "..."
/**
 * 数据类，编译器重写toString 、equals 和 hashCode 。 
 * equals 用来比较实例
 * hashCode 用来作为例如 HashMap 这种基于哈希容器的键
 * toString 用来为类生成按声明顺序排列的所有字段的字符串表达形式
 *  copy 方法： copy对象的同时修改某些属性的值
 */
data class Client(val name: String, val postalCode: Int)
/**
 * 类委托：可以使用 by 关键字将接口的实现委托到另一个对象(避免装饰器模式带来的重复模板代码)
 *  
 *类相当于innerList的包装类，拥有innerList的实现，并可以覆盖原有方法提供不同实现
 */
 class DelegatingCollection<T>(innerList: Collection<T> = ArrayList<T>()) : Collection<T> by innerList {}

/**
 * object关键字 对象声明：创建单例类
 */
object Payroll {
 ...
 }
 
/**
 * 伴生对象companion：工厂方法
 */
//构造方法私有化
class User private constructor(val nickname: String) {
    //声明伴生对象:工厂方法创建对象
    companion object {
        fun newSubscribingUser(email: String) =
                User(email.substringBefore("@"))

        fun newFacebookUser(accountld: Int) =
                User(accountld.toString())
    }
}

/**
 * 普通类的伴生对象：伴生对象是一个声明在类中的普通对象，有名字(默认Companion )，可以实现一个接口或者有扩展函数或属性 。 伴生对象（与包级别函数和属性一起）替代了 Java 静态方法和字段定义
 */
class Prize(val name: String, val count: Int, val type: Int) {
	companion object {
		val TYPE_REDPACK = 0
		val TYPE_COUPON = 1
		fun isRedpack(prize: Prize): Boolean {
			return prize.type == TYPE_REDPACK
		}
    }
 }
fun main(args: Array<String>) {
	val prize = Prize("红包", 10, Prize.TYPE_REDPACK)
    print(Prize.isRedpack(prize))
}

/**
 * 对象表达式：(匿名内部类)
 */
val Listener = object: MouseAdapter() {
override fun mouseClicked(e: MouseEvent) { .. . }
override fun mouseEntered(e: MouseEvent) { ... }
}

/**
* by lazy : val变量的初始化
* lazy的背后是接受一个lambda并返回一个Lazy <T>实例的函数，第一次访问该属性时，会执行lazy对应的Lambda表达式并记录* 结果。
* lazy属性默认LazyThreadSafetyMode.SYNCHRON IZED（同步锁）
*/
class Bird(val weight: Double, val age: Int, val color: String) {
    val sex: String by lazy {
         if (color == "yellow") "male" else "female"
	}
}

/**
* lateinit : var变量的初始化
*/
lateinit var sex: String 
fun printSex() {
     this.sex = if (this.color == "yellow") "male" else "female"
}

/**
 * Delegates.notNull<T> ：基本数据类型变量初始化
 */
var test by Delegates.notNull<Int>()
fun doSomething() {
	test = 1
}

/**
 * 处理序列的中间操作函数是不进行任何计算的。相反，它们会返回上一个中间操作处理后产生的新序列。
 * 所有这些一系列中间计算都将在终端操作执行中被确定，例如常见的终端操作toList或count.在另一方面，处理Iterable的每个中间操作函数都是会返回一个新的集合。
 *
 */
interface Iterable<out T> {
    operator fun iterator(): Iterator<T>
}
interface Sequence<out T> {
    operator fun iterator(): Iterator<T>
}

//惰性求值，避免创建临时中间对象
 val list = persons.asSequence()
            .map(Person::name)
            .filter { it.startsWith("l") }
            .toList()
//惰性求值：给定序列中 的前一个元素，这个函数会计算出下一个元素。
val naturalNumbers = generateSequence(0) { it + 1 }
println("求100 以内的和：${naturalNumbers.takeWhile { it <= 100 }.sum()}")

/**
 * 使用给定的[receiver]作为接收器调用指定的函数[block]并返回其结果。
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

val returnAToZ = with(StringBuilder()) {
        for (letter in 'A'..'Z') {
            append(letter)
        }
        toString()
}

/**
 * 使用`this`值作为接收器调用指定的函数[block]并返回`this`值。
 */
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

val returnAToZ = StringBuilder().apply {
        for (letter in 'A'..'Z') {
            append(letter)
        }
}

        fun foo(x: Int): (Int) -> Int {
            return { y: Int -> x + y }
        }

        fun sum(x: Int) = { y: Int ->
            { z: Int -> x + y + z }
        }
        sum(1)(2)(3)

@kotlin.internal.InlineOnly
public inline fun <T> Lock.withLock(action: () -> T): T {
    lock()
    try {
        return action()
    } finally {
        unlock()
    }
}

/**
* tag@标签：return 会跳转到引用的标签lamdba 而不会跳出整个函数
*/
fun lookForAlice(s:List<String>){
   s.forEach tag@{
       if (it == "Alice") return@tag
   }
   println("I find Alice")
}

/**
 * 使用匿名函数lambda
 */
fun lookForAlice2(s:List<String>){
    s.forEach(fun (s){
        //return指向最近的匿名函数
        if (s == "Alice") return
    })
    println("I find Alice")
}

        val html = """<html>
                        <body>
                            <p>Hello World.</p>
                        </body>
                    </html>
                """

fun message(name: String, lang: String) = "Hi ${name}, welcome to ${lang}! "
>>> message("Shaw", "Kotlin")
Hi Shaw, welcome to Kotlin!