Kotlin基础：泛型、注解、DSL

var items = listOf("lhr","lnx",2)

/**
 * 运行时泛型被擦除了，无法判断List的类型
 */
fun main(args: Array<String>) {
    if (items is List<String>){

        //...
    }
}

/**
 * 内联函数 reified声明了类型参数T不会在运行时被擦除
 */
inline fun <reified T> Iterable<*>.filterIsInstance():List<T>{
    val destination= mutableListOf<T>()
    /*
    对指定实参进行检测存储返回。
    因为生成的字节码引用了具体类，而不是类型参数，它不会被运行时发生的类型参数擦除影响 。
     */
    for(element in this){
       if (element is T){
           destination.add(element)
       }
    }
    return destination;
}

fun main(args: Array<String>) {
    val list = listOf("123", "456", 999)
    println(list.filterIsInstance<String>())
}

List<? extends Fruit> fruits = new ArrayList<>();
//编译错误:不能添加任何类型的对象
//fruits.add(new Orange());
//fruits.add(new Fruit());
//fruits.add(new Object());
//我们知道，返回值肯定是Fruit
Fruit f = fruits.get(0);

List<Object> objs = new ArrayList<>();
objs.add(new Object());
List<? super Fruit> canContainFruits = objs;
//没有问题，可以写入Fruit类及其子类
canContainFruits.add(new Orange());
canContainFruits.add(new Banana());
canContainFruits.add(new Fruit());
//无法安全地读取,canContainFruits完全可能包含Fruit基类的对象，比如这里的Object
//Fruit f = canContainFruits.get(0);

//总是可以读取为Object，然而这并没有太多意义
Object o = canContainFruits.get(1);

abstract class Source<out T> {
    abstract fun nextT(): T
}

fun demo(oranges: Source<Orange>) {
    val fruits: Source<Fruit> = oranges // 没问题，因为 T 是一个 out-参数，Source<T>是协变的
    val oneFruit: Fruit = fruits.nextT() //可以安全读取
}

//kotlin
abstract class Comparable<in T> {
    abstract fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
    val y: Comparable<Double> = x // OK！逆变，Comparable<Number>可以作为Comparable<Double>的子类型
    y.compareTo(1.0) //1.0 拥有类型 Double
}

//volatile 多线程可见性
@volatile
//Strictfp 多平台浮点数可预测性
@Strictfp
//改变由 Kotlin 生成的 Java 方法或字段的名称 
@JvmName 
//能被用在对象声明或者伴生对象的方法上，把它们暴露成Java 的静态方法
@JvmStatic
//指导 Kotlin 编译器为带默认参数值的函数生成多个重载
@JvmOverloads
//应用于一个属性，把这个属性暴露成一个没有访问器的公有 Java 字段。
@JvmField 

//声明注解
//@Target 元注解
@Target(AnnotationTarget.PROPERTY)
annotation class xxx

open class Tag(val name: String) {

    /**
     * 保存所有嵌套标签
     */
    private val children = mutableListOf<Tag>()

    protected fun <T : Tag> doInit(child: T, init: T. () -> Unit) {
        //调用作为参数的lambda,初始化并保存子标签
        child.init()
        children.add(child)
    }

    override fun toString() = "<$name>${children.joinToString("")} </$name>"
}

fun table(init: TABLE.() -> Unit) = TABLE().apply(init)

class TABLE : Tag("table") {
    /**
     * 创建并初始化 TR 标签的示例并添加到TABLE 的子标签中
     */
    fun tr(init: TR.() -> Unit) = doInit(TR(), init)
}

class TR : Tag("tr") {
    /**
     * 添加TD标签的一个实例到 TR 的子标签中
     */
    fun td(init: TD.() -> Unit) = doInit(TD(), init)
}

class TD : Tag("td")

fun main(args: Array<String>) {
    fun createTable() =
            table {
                tr {
                    td { }
                    td { }
                }
            }
    //<table><tr><td> </td><td> </td> </tr> </table>
    println(createTable())
}

/**
 * action: StringBuilder.() -> Unit 定义接收者为StringBuilder的lambda
 * StringBuilder.() -> Unit 扩展函数
 */
fun buildString(action: StringBuilder.() -> Unit):String{
    val sb = StringBuilder()
    //传递一个 StringBuilder 实例作为lambda的接收者
    sb.action()
    return sb.toString()
}

var s = buildString {
    append("are you ok")
}

class Person(val name: String){
    /**
     * 重载invoke
     */
    operator fun invoke(no: String){
        println("$name - $no ")
    }
}

fun main(args: Array<String>) {
    val person = Person("lhr")
    person("test")//实际上调用的是person.invoke

}

object start

infix fun String.should(x: start): StartWrapper = StartWrapper(this)

class StartWrapper(val value: String) {
    infix fun with(prefix: String): Unit =
            if (value.startsWith(prefix)) {
            } else {
                throw AssertionError("String does not start with $prefix: $value")
            }

}

fun main(args: Array<String>) {
    "kotlin" should start with "ko"
}

val Int.days: Period
    //this 引用数字常量值
    get() = Period . ofDays (this)

val Period.ago:LocalDate
    get() = LocalDate.now() - this

fun main(args: Array<String>) {
    //获取一天前日期
    println(1.days.ago)
}