//如果存在于区间(1,Y-1)，则打印OK  【判断区间】
if (x in 1..y-1) 
  print("OK")
//如果x不存在于array中，则输出Out  【用于判断】
if (x !in 0..array.lastIndex) 
  print("Out")
//打印1到5    【判断区间】
for (x in 1..5) 
  print(x)
//遍历集合(类似于Java中的for(String name : names))
for (name in names)
  println(name)
//如果names集合中包含text对象则打印yes  【判断包含】
if (text in names)
  print("yes")

fun cases(obj: Any) { 
  when (obj) {
    1       -> print("第一项")
    "hello" -> print("这个是字符串hello")
    is Long -> print("这是一个Long类型数据")
    !is String -> print("这不是String类型的数据")
    else    -> print("else类似于Java中的default")
  }
}

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // 做过类型判断以后，obj会被系统自动转换为String类型
    return obj.length 
  }
  //同时还可以使用!is，来取反
  if (obj !is String){
  }
  // 代码块外部的obj仍然是Any类型的引用
  return null
}

//当data不为空的时候，执行语句块
data?.let{
    //... 
}
//相反的，以下代码当data为空时才会执行
data?:let{
    //...
}

enum class Programer {
    JAVA, KOTLIN, C, CPP, ANDROID;
}

inline (内联函数)
内联函数与普通的函数有点不同。一个内联函数会在编译的时候被替换掉，而不是真正的方法调用。这在译写情况下可以减少内存分配和运行时开销。例如，有一函数只接收一个函数作为它的参数。如果是普通函数，内部会创建一个含有那个函数的对象。而内联函数会把我们调用这个函数的地方替换掉，所以它不需要为此生成一个内部的对象。
 // 例一、创建代码块只提供 Lollipop 或更高版本来执行
inline fun supportsLollipop(code: () -> Unit) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        code()
    }
}
// usage
supportsLollipop {
    window.setStatusBarColor(Color.BLACK)
}

class App : Application() {
   val database: SQLiteOpenHelper by lazy {
       MyDatabaseHelper(applicationContext)
    }
    override fun onCreate() {
      super.onCreate()
      val db = database.writeableDatabase
    }
}

// 定义一个接口,和一个方法 show()
interface Base {
fun show()
}
// 定义类实现 Base 接口, 并实现 show 方法
open class BaseImpl : Base {
override fun show() {
print("BaseImpl::show()")
}
}
// 将Base中所有的实现都委托给base 对象，这个类本身就不需要去实现Base接口中的方法
class BaseProxy(base: Base) : Base by base
// main 方法
fun main(args: Array<String>) {
val base = BaseImpl()
BaseProxy(base).show()
}
分析：每次在实现接口时，都需要实现接口中的所有方法，by也就是将 Base 接口中需要实现的
方法都委托给BaseImpl 类去实现，所以这里这样写 ：Base by base 其实也就是说，我实现了接口
Base,但我本身不实现Base接口中的方法，委托给base帮我实现，那么在调用的时候就传入有具体实现了Base接口的类，方便我们的委托。
这里：
// 传入了BaseImpl类的引用，BaseImpl 必须是实现了Base接口的类
val base = BaseImpl()
// 传入了BaseImpl类的引用，这里在调用的时候也是调用BaseImpl中的方法
BaseProxy(base).show()
/* 在这里就把整个接口的实现委托给 持有 base 引用的类去实现接口Base中具体的方法
不代表Base接口在其他地方一定要有被其他实体类实现了才可以使用by 委托，即使在其他地方没
有实现Base 接口也可以使用 Base接口的对象去委托 */
class BaseProxy(base: Base) : Base by base

fun testLet(){
       "Rocker".let {
           print(it)
           print(it)
       }
   }

fun testApply(){
        mutableListOf<String>().apply {
            add("jim")
            add("lili")
            add("Rocker")
        }.add("To test whether returns this object")
  }

class ViewModel(val db: MyDatabase) {
  var myProperty by Delegates.observable("") {
    d,old,new ->
    db.saveChanges(this,new)
  }
}

var positiveNumber = Delegates.vetoable(0) {
    d, old, new -> 
    new >= 0
}
// 上面这个委托只允许在新的值是正数时执行保存。在 lambda 中，最后一行表示返回值。不需要使用 return 关键字(实质上不能被编译)

class App : Application() {
  companion object {
    var instance: App by Delegates.notnull()
  }
   override fun onCreate() {
      super.onCreate()
      instance = this
    }
}

import kotlin.properties.getValue
class Configuration(map: Map<String,Any?>) {
  val width: Int by map
  val height: Int by map
  val dp: Int by map
  val deviceName: String by map
}
// usage
conf = Configuration(mapof(
  "width" to 1080,
  "height" to 720,
  "dp" to 240,
   "deviceName" to "myDecive"
))

// step1
private class NotNullSingleValueVar<T>() : ReadWriteProperty<Any?, T> {
  private var value: T? = null
  override fun getValue(thisRef: Any?, property: KProperty<*>): T {
      return value ?: throw IllegalStateException("${desc.name not initialized}")
  }
  override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
      this.value = if (this.value == null) value else throw IllegalStateException("${desc.name} already initialized")
      }
}
// step2: usage
object DelegatesExt {
  fun notNullSingleValue<T>(): ReadWriteProperty<Any?, T> = NotNullSingleValueVar()
}