1.接口
/**
 * 接口 interface : 方法、属性或一段功能的"蓝本"
 * 仅仅是规定实现的标准(抽象的)
 *
 * 通常用于对类进行附加功能，可以用类保持简洁的定义
 * 通过实现1个或N个接口的组合，来实现非继承式的功能增强
 */

//接口定义: interface 接口名 {//各种属性或方法定义 }

interface Livable {
    val hasSkill: Boolean
}

interface ChinaLivable {
    //接口中的属性只有类型定义,不可初始化
    val hasJobOffer: Boolean

    //接口中的属性可以有get,通常用于单纯地增加一个常量属性
    val visaCategory: String
        get() = "工作签证"

    //接口中的变量属性
    var city: String

    //接口中的方法
    fun speakChinese()

    //接口中的方法可以有默认实现,通常指该方法是固定不变的
    fun handleGuanxi() {
        println("在中国要学会处理人际关系")
    }

}

open class Person {
    var name =""
}

//继承父类，并实现多个接口
class ForigenChinese : Person(),Livable,ChinaLivable{
    override val hasJobOffer: Boolean
        get() = true
    override var city =""

    override fun speakChinese() {
        println("我叫${this.city},汉语水平一级")
    }

    override val hasSkill: Boolean
        get() = true

}

fun main(args: Array<String>) {

    val tom = ForigenChinese()
    tom.name = "Green"
    tom.city = "Beijing"
    tom.speakChinese()
    tom.handleGuanxi()
    println(tom.visaCategory)
    println("tom有技能：${tom.hasSkill}")
}
我叫Beijing,汉语水平一级
在中国要学会处理人际关系
工作签证
tom有技能：true
2.泛型
/**
 * 泛型 Generics
 * 让一个类型被广泛使用,即,通用化,称之为"泛型"
 * 一般用于函数的参数类型定义
 */

fun main(args: Array<String>) {
    //最常用的例子:print和println函数，几乎可以放任何参数类型
    println(2)
    println("泛型")


    //Array，参数也可以是任意类型
    val a = arrayOf(1, 2, 3)

    //自定义一个泛型函数:<T> Type的首字母缩写,T 代表一个占位符,用尖括号包含
    fun <T> showText(para: T) {

        println(para)
    }

    showText("自定义泛型")
    showText(2)

    //有时候系统提供的泛型函数很好
    //求和
    val sum = arrayOf(1, 2, 3, 4, 5).sum()
    println(sum)

    //整数、小数在一起sum()无法求和
    //val sum = arrayOf(1,2,3,4,5.5).sum()
    //println(sum)

    //泛型约束:<泛型占位符:类型>
    fun <T : Number> sum(vararg numbers: T): Double {

        return numbers.sumByDouble { it.toDouble() }
    }

    println(sum(1, 2, 3, -0.5, 5))

    //多重约束 :where,哥哥约束用逗号分割,写在函数体之前
    //例子：把数组中大于某个(阈值)的部分取出并升序排列
    //(1,2,-398,88,1024,8888)

    fun <T> biggerPart(list: Array<T>, threhold: T): List<T>
            where T : Number, T : Comparable<T> {

        return list.filter { it >= threhold }.sorted()
    }

    val b = arrayOf(1, 0, 123, -12, 11, 666)
    println(biggerPart(b,11))

}
2
泛型
自定义泛型
2
15
10.5
[11, 123, 666]
3.扩展
/**
 * 扩展:对既有类增加新功能而无需继承该类，及时获取源代码
 * 主要作用是"立即"为相关类 整体上添加工具类(Utils)方法或属性,高效优雅。
 * Kotlin:扩赞函数,扩展属性
 *
 * 与接受者中参数、名称都一样的扩展是无效的。
 * 尽量避免与已有的名字重名，如果一定要重名，参数名和类型也要不一样。
 */

//扩展函数: fun 函数接受者类型，新扩赞函数名(参数类别) {//函数实现}
//1.普通函数扩展:整数的平方
fun Int.square(): Int {

    return this * this
}
//2.泛型扩展函数:取数字型数组中最大的元素


fun <T> Array<T>.biggest(): T
        where T : Number, T : Comparable<T> {
    var biggest = this[0]
    for (i in 1..lastIndex) {
        val element = this[i]
        if (element > biggest) {
            biggest = element;
        }
    }
    return biggest
}

fun <T> Array<T>.smallest(): T where T : Number, T : Comparable<T> {
    var smalllest = this[0]
    for (i in 1..lastIndex) {
        val element = this[i]
        if (element < smalllest) {
            smalllest = element
        }
    }
    return smalllest
}

//泛型属性扩展
//1.普通属性扩展 。例子：整数的下一个数字
val Int.next: Int
    get() = this + 1
//2.泛型属性扩展：数字类型的半径对应的类型
val <T : Number> T.area: Double
    get() = 3.1415926 * this.toDouble() * this.toDouble()

fun main(args: Array<String>) {
    println(5.square())

    println(2.area)

    val a = arrayOf(1, 2, 3, -88)
//    println(a.max())
//    println(a.min())
    println(a.biggest())
    println(a.smallest())

    println(3.next)
}
25
12.5663704
3
-88
4