package com.ys.usekotlin

import com.ys.base.utils.L


//接口
interface TestBy {
    fun test() {//默认实现方法
        L.i("test")
    }
}

//实现接口后面不需要()
//接口实现类
class TestByImpl : TestBy {

    override fun test() {
        L.i("test")
    }
}


//基类
abstract class BaseModel {
    abstract fun ab()
}

//继承父类后面需要()
//父类,open可被继承
open class ParentModel : BaseModel() {

    var s = "ParentModel.ab"
    override fun ab() {
        L.i("$s")
    }
}

//空类
//class Model

//非空类,by委托 //!!表示变量为null时抛出异常
class Model constructor(ipl: TestByImpl, var a: String, val b: String) : ParentModel(), TestBy by ipl {//主构造方法

    //静态区
    companion object A {
        //调用Model.A.say();
        fun say(): String {
            return "holle"
        }
    }

    val d = b
    var e = a
    var f = 10

    //主构造方法代码段
    init {
        e = b

        var ipml = ipl
        if (ipml == null) {
            L.i("ipml == null")
        }

        // 做过类型判断以后，ipml会被系统自动转换为TestByImpl类型
        if (ipml is TestByImpl) {
            ipml.test()
        }
    }

    //次构造方法1,无参
    constructor() : this(1, "b")

    //次构造方法2，带参
    constructor(a1: Int, b1: String) : this(b1, b1, b1) {
        //方法体无代码可以省略
    }

    //次构造函数3,带参
    constructor(h: String, g: String, s: String) : this(TestByImpl(), s, s) {

    }


    //成员函数
    fun main() {

        //类型转换
        var bb: Boolean = false
        var sss = bb.toString()

        var ii: Int = 100
        sss = ii.toString()

        var dd: Double = 29.1
        ii = dd.toInt()
        dd = ii.toDouble()
        dd = ii / 2.0

        var cc: Char = 'a'
        sss = cc.toString()


        //创建实例
        Model(1, "")
        Model("", "", "")//
        Model(TestByImpl(), "", "")//主构造函数

        //使用成员变量
        L.i(a)

        //扩展函数静态，实例函数动态
        var m: ParentModel = Model()
        m.ab() //Model的ab
        m.excfun()  //ParentModel的excfun

        //使用扩展函数，空对象也能使用
        var onull = null
        onull.say()

        //调用伴生对象扩展函数
        Model.A.afoo("afoo")


        //内部类实例创建，和调用内部类的方法，和内部类调用外部类
        Model().Inner().innerTest()

        //嵌套类实例创建
        Model.Nested().foo(this)

        //匿名内部类实例
        var test: TestInterFace = object : TestInterFace {
            override fun test() {
                L.i("对象表达式创建匿名内部类的实例")
            }
        }

        //可变长度参数
        testVararg(1, 2, 3, 4, 5, 6)

        var a = 42
        //when就是switch,可返回值
        val answerString1 = when {
            a == 42 -> "I have the answer."
            a > 35 -> "The answer is close."
            else -> "The answer eludes me."
        }

        //ss返回值类型由值固定
        var ss = when (a) {
            is Int -> 1 //判断类型
            42 -> "I have the answer." //判断值
            35 -> "The answer is close."
            else -> false
        }

        //没有了三目运算符
        var aee =
                if (ss is Int) {
                    L.i("Choose a")
                    100
                } else if (ss is String) {
                    false
                } else
                    "SS"

        //for 循环
        var array = IntArray(100)
        for (i in array.indices) {
            array[i] = i * 100
        }
        for (i in array) {
            L.i(i.toString())

        }

        //forEach
        array.forEach {
            if (it == 100) {
                L.i(it.toString())
            }
        }

        //while循环
        while (a > 0) {
            L.i(a.toString())
            a--
            if (a < 10) {
                break
            } else {
                continue
            }
        }

        //do - while循环
        do {
            L.i(a.toString())
            a--
        } while (a > 0)

    }

    //伴生对象扩展函数
    fun Model.A.afoo(ss: String) {
        L.i("伴随对象的扩展函数_" + ss)
    }

    //给任何类扩展函数
    fun Any?.say(): String {
        if (this == null) return "null"
        // 空检测之后，“this”会自动转换为非空类型，所以下面的 toString()
        // 解析为 Any 类的成员函数
        return toString()
    }

    //扩展函数
    fun ParentModel.excfun() {
        L.i("ParentModel.excfun")
    }

    fun Model.excfun() {
        L.i("Model.excfun")
    }


    //可变长度参数
    fun testVararg(vararg a: Int) {
        for (aa in a) {
            L.i(aa.toString())
        }
    }

    //内部类
    inner class Inner {
        fun foo() = b // 访问外部类成员
        fun innerTest() {
            var o = this@Model //获取外部类的成员变量
            L.i("内部类可以引用外部类的成员，例如：" + o.e)
        }
    }

    //嵌套类
    class Nested {
        fun foo(model: Model): Int {
            return model.f
        }
    }

    //定义接口
    interface TestInterFace {
        fun test()
    }

    //override
    override fun ab() {
        L.i("Model.ab")
    }

}

//(1执行)companion object 静态区,
//(2执行)init 初始化代码段,
//(3执行)类里面constructor 次构造

//classModifier: 类属性修饰符，标示类本身特性。
//    abstract    // 抽象类
//    final       // 类不可继承，默认属性
//    enum        // 枚举类
//    open        // 类可继承，类默认是final的
//    annotation  // 注解类

//accessModifier: 访问权限修饰符
//    private    // 仅在同一个文件中可见
//    protected  // 同一个文件中或子类可见
//    public     // 所有调用的地方都可见
//    internal   // 同一个模块中可见