// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:7.0.3"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

package com.example.myapplication

fun VariableTest_Go(){
    //val声明常量
    val a = 3;
    //val的不能被赋值
    //a = 2;

    //var声明变量
    var b = 4;
    b = 5;
}

package com.example.myapplication

fun maxNumber(a:Int,b:Int):Int{
    if( a > b){
        return a;
    }else{
        return b
    }
}

fun maxNumber2(a:Int,b:Int):Int = Math.max(a, b)

fun minNumber(left:Int,right:Int):Int{
    if( left < right ){
        return left
    }else{
        return right
    }
}

fun FunctionTest_Go(){
    println(maxNumber(1,2));
    println(maxNumber2(2,3));
    println(minNumber(
        right = 20,
        left = 10
    ))
}

package com.example.myapplication

fun IfConfidition(a:Int,b:Int):Int{
    if( a > b ){
        return a;
    }else{
        return b;
    }
}

fun IfConfidition2(a:Int,b:Int):Int{
    //if语句也可以有返回值
    var result = if( a > b ){
        a
    }else{
        b
    }
    return result;
}

fun IfConfidition3(a:Int,b:Int) = if( a> b) {
    a
}else{
    b
}

fun whenCondition(a:Int):String{
    return when(a){
        1->"One"
        2->"Two"
        else->"Other"
    }
}

fun whenConditionForType(a:Number):String{
    return when(a){
        is Int->"Int"
        is Double->"Double"
        else->"Other"
    }
}

fun whenConditionForExpression(name:String):Int{
    //when的参数为空
    return when{
        name.startsWith("Fish_")->100
        //不需要用equals来比较
        name == "Jim"->200
        else->-1
    }
}

fun ConditionTest_Go(){
    println(IfConfidition(1,2))
    println(IfConfidition2(2,3))
    println(IfConfidition3(3,4))

    println(whenCondition(2))
    println(whenConditionForType(1.1))
    println(whenConditionForExpression("Fish_gg"))
}

package com.example.myapplication

fun whileLoop():String{
    var out = ""
    var a = 0
    while( a <= 10 ){
        out = out+a+" "
        a++
    }
    return out
}

fun forLoop():String{
    var out = ""
    //左闭右闭区间，只能升序
    for( i in 0..10){
        out = out + i +" "
    }
    return out
}

fun forLoop2():String{
    var out = ""
    //左闭右开区间，只能升序
    for( i in 0 until 10 ){
        out = out + i +" "
    }
    return out
}


fun forLoop3():String{
    var out = ""
    //左闭右开区间，升序，且设置步长
    for( i in 0 until 10 step 2 ){
        out = out + i +" "
    }
    return out
}

fun forLoop4():String{
    var out = ""
    //左闭右闭区间，只能降序
    for( i in 10 downTo 1 ){
        out = out + i +" "
    }
    return out
}



fun LoopTest_Go(){
    println(whileLoop())
    println(forLoop())
    println(forLoop2())
    println(forLoop3())
    println(forLoop4())
}

package com.example.myapplication

class Person(var name:String,var age:Int){

}

//参数类型为Person的时候，就是排除了null的这种情况
fun go1(a:Person){
    println("person.name = ${a.name}")
}

//参数类型为Person?的时候，才能包含有null的这种情况
fun go2(a:Person?){
    //这种情况下，需要先判断null，再获取字段
    if( a != null){
        println("person.name2 = ${a.name}")
    }

    //kotlin有省事的?判断操作符
    println("person.name2 = ${a?.name}")
}

fun go3(a:Person?){
    //这种情况下，需要先判断null，再获取字段，否则取默认值
    var result = "";
    if( a != null){
        result = a.name;
    }else{
        result = "[null]";
    }
    println("person.name3 = ${result}")

    //kotlin有省事的?判断操作符，再结合省事的?:二元操作符来表达
    println("person.name3 = ${a?.name?:"[null]"}")
}

fun go4(a:Person?){
    //!!是一个危险的操作，强行指定这个变量是非空的，出了问题由开发者自己兜底
    println("person.name4 = ${a!!.name}")
}
fun OptionTest_Go(){
    //编译不通过
    //go1(null)
    go1(Person("fish",123))

    go2(null)
    go2(Person("fish",123))


    go3(null)
    go3(Person("fish",123))

    go4(Person("fish",123))
    go4(null)//这里能编译通过，但是运行时抛出NullPointerException

}

package com.example.myapplication

class MyPerson{
    //由开发者来确定它是否已经初始化了
    //编译时，编译器都认为它是非空的
    private lateinit var target:String;

    fun isInit():Boolean{
        return ::target.isInitialized
    }
    fun get():String{
        return target;
    }

    fun set(a:String){
        this.target = a;
    }
}

fun LateInitTest_Go(){
    var person = MyPerson()
    println("hasInit ${person.isInit()}")
    person.set("fish")
    println(person.get())
    println("hasInit ${person.isInit()}")

    var person2 = MyPerson()
    println("hasInit ${person2.isInit()}")
    //这里运行时会报错，因为读取对象的时候，发现对象还没有被初始化
    //lateinit property target has not been initialized
    println(person2.get())
}

package com.example.myapplication

enum class Color {
    RED,
    GREEN,
    BLUE,
}

fun enumTest1(){
    val output = {input:Color->
        println("name ${input.name} ordinal ${input.ordinal}")
    }
    output(Color.RED)
    output(Color.GREEN)
    output(Color.BLUE)
}


enum class Color2(val index:String,val aliasName:String) {
    RED("#FF0000","红色"),
    GREEN("#00FF00","绿色"),
    BLUE("#0000FF","蓝色"),
}

fun enumTest2(){
    val output = {input:Color2->
        println("name ${input.name} ordinal ${input.ordinal} index ${input.index} alias ${input.aliasName}")
    }
    output(Color2.RED)
    output(Color2.GREEN)
    output(Color2.BLUE)
}

fun EnumTest_Go(){
    enumTest1()
    enumTest2()
}

package com.example.myapplication

//默认是不可以被继承的
class Person {

    //默认成员为public，自动生成对应的getter与setter
    var name = ""
    var age = 0

    //私有化setter
    var height:Float = 0f
        private set

    //自定义getter与setter
    var color = ""
        get(){
            println("color getter run")
            return field
        }
        set(value) {
            println("color setter run")
            field = value
        }

    fun eat(){
        println(name +" is eating. He is "+ age +" years old")
    }

    fun setHeight(height:Float){
        this.height = height
    }
}

fun ClassTest_Go(){
    val p = Person()
    p.age = 121
    p.name = "Fish"
    //失败，因为setter被设置为private
    //p.height = "123"
    //必须通过指定方法
    p.setHeight(123f)
    p.color = "blue"
    println("age = ${p.age} and name = ${p.name} and height = ${p.height} and color = ${p.color}")
    p.eat()
}

package com.example.myapplication

class Animal(private var name:String){
    var nameLength:Int;

    init{
        //类实例时初始化的方法
        nameLength = name.length;
    }

    fun show(){
        println("name ${name} nameLength ${nameLength}")
    }
}
fun ClassInitTest_Go(){
    val animal = Animal("Dog");
    animal.show()
}

package com.example.myapplication

//案例1
//要想让类继承，必须有open关键字
//无参数的Person2，默认有一个空参数的主构造函数
open class Person2{

}

//Student也没有参数，所以它也有一个空参数的主构造函数
//因此必须显式地调用Person2的空参数主构造函数
class Student2: Person2(){

}

//案例2
//主构造函数上的参数，默认会成为类的成员变量。
//而且默认这些成员为final，不能被覆写
open class Person3(val name:String,val age:Int){
    fun show(){
        println("name ${this.name} age ${this.age}")
    }
}

//Student有一个主构造函数，需要显式地调用父类的主构造函数
class Student3(val clazz:String, name2:String, age2:Int): Person3(name2,age2){
    fun showClazz(){
        println("clazz ${this.clazz}");
        //没有name2的成员，因为主构造函数上面没有val，或者var注解
        //println("name: ${this.name2} age: ${this.age2}")
    }
}

//案例3
// 可以被覆写的成员，需要加入open关键字
open class Person4( open val name:String,open val age:Int){
    fun show(){
        println("name ${this.name} age ${this.age}")
    }
}

//对于覆写的成员，也需要指定override关键字
class Student4(val clazz:String, override val name:String, override val age:Int): Person4(name,age){
    fun showClazz(){
        println("clazz ${this.clazz} name: ${this.name} age: ${this.age}")
    }
}

//案例4
//Person5有主构造函数
open class Person5( val name:String, val age:Int){
    fun show(){
        println("name ${this.name} age ${this.age}")
    }
}

//Student5有主构造函数，也有次构造函数
//每个类仅仅只能有一个主构造函数，次构造函数可以是多个
//对于每个次构造函数，它们都需要显式地调用自身的主构造函数
//次构造函数上面的参数不会成为成员。
class Student5(val clazz:String,val name2:String, val age2:Int): Person5(name2,age2){
    constructor(name:String,age:Int):this("go",name,age){

    }

    constructor(age:Int):this("go","fish",age){

    }

    fun showClazz(){
        println("clazz ${this.clazz} name: ${this.name} age: ${this.age}")
    }
}

//案例5
//Person6有主构造函数
open class Person6( val name:String, val age:Int){
    fun show(){
        println("name ${this.name} age ${this.age}")
    }
}

//相当特殊的情况
//Student6没有主构造函数，只有次构造函数的时候，需要显式地调用父类的主构造函数
//这个时候省略了括号
class Student6: Person6{
    var clazz:String = ""

    constructor(clazz:String,name:String,age:Int):super(name,age){
        this.clazz = clazz
    }

    constructor(clazz:String,age:Int):super("fish",age){
        this.clazz = clazz
    }

    fun showClazz(){
        println("clazz ${this.clazz} name ${this.name} age ${this.age}")
    }
}

//案例6
//Person7有主构造函数，没有次构造函数
open class Person7{
    var name:String = "";
    var age:Int = 0;
    constructor( name:String, age:Int){
        this.name = name;
        this.age =age;
    }
    constructor( age:Int){
        this.name = "fish2";
        this.age =age;
    }
    fun show(){
        println("name ${this.name} age ${this.age}")
    }
}

//相当特殊的情况
//Student7没有主构造函数
class Student7: Person7{
    var clazz:String = ""

    constructor(clazz:String,name:String,age:Int):super(name,age){
        this.clazz = clazz
    }

    constructor(clazz:String,age:Int):super(age){
        this.clazz = clazz
    }

    fun showClazz(){
        println("clazz ${this.clazz} name ${this.name} age ${this.age}")
    }
}

fun ExtendAndConstructorTest_Go(){
    val student2 = Student2();

    val student3 = Student3("student_clazz3","fish3",123);
    student3.show();
    student3.showClazz();

    val student4 = Student4("student_clazz4","fish4",124);
    student4.show();
    student4.showClazz();

    val student5 = Student5("fish5",125);
    student5.show();
    student5.showClazz();

    val student5_2 = Student5("fish5",25);
    student5_2.show();
    student5_2.showClazz();

    val student6 = Student6("student_clazz6",1);
    student6.show();
    student6.showClazz();

    val student7 = Student7("student_clazz7",1);
    student7.show();
    student7.showClazz();
}

package com.example.myapplication

interface Flyer{
    fun fly()
}

class Bird:Flyer{
    override fun fly(){
        println("brid fly")
    }
}

fun InterfaceTest_Go(){
    val bird = Bird()
    bird.fly()
}

package com.example.myapplication

class MyClass{
    //私有权限，仅当前类可以看到
    private var a = 1

    //保护权限，当前类，子类可以看到
    protected var b = 3

    //internal权限，仅同一个模块中类可以看到，（与Java的不同）
    internal var d:Boolean = true

    //公开权限，所有类可以看到，默认方式
    public val c:String = "123"
}

fun AccessTest_Go(){
    var myClass = MyClass()
    println("c = ${myClass.c} d= ${myClass.d}")
}

package com.example.myapplication

//默认的data class没有空构造函数，通过默认参数的方式，给与空构造函数
data class Phone(val brand:String = "",val price:Double = 0.0) {

}

fun DataClassTest_Go(){
    var a = Phone("MOTO",1.1)
    var b = Phone()
    var c = Phone("MOTO",1.1)

    //data class默认有equals方法
    println("a == c 为 "+(a==c))
    println("a == b 为 "+(a==b))

    //data class默认有toString方法
    println("a.toString "+ a.toString())

    //data class默认有hashCode方法
    println("a.hasCode "+ a.hashCode())

}

package com.example.myapplication

//注意没有class关键字，object表示是单例方式的类
//Kotlin会为这个类型自动生成一个唯一的伴生对象，该对象就是单例
object Single {
    private var count = 1;
    fun inc(){
        count ++;
    }
    fun get():Int{
        return count;
    }
}

fun SingletonClassTest_Go(){
    println("count ${Single.get()}")
    Single.inc()
    println("count ${Single.get()}")
}

package com.example.myapplication

class Util {
    fun doAction1(){
        println("do action1")
    }
    companion object{
        //伴生对象，一个具体的实例，不是Java的static方法
        fun doAction2(){
            println("do Action2")
        }

        //与Java一样的static方法，以方便与Java对象进行交互
        @JvmStatic
        fun doAction3(){
            println("do Action3")
        }
    }
}

fun CompaionClassTest_Go(){
    var util = Util()
    util.doAction1()

    Util.doAction2()
    Util.doAction3()
}

package com.example.myapplication

import java.lang.Exception

sealed class Result{
    private val age:Int = 12
}

//有括号，是一个类
class Success:Result(){}

class Fail:Result(){}

interface Result2

//没有括号，是一个接口
class Success2:Result2{}

class Fail2:Result2{}

fun showResult2(input:Result2) = when(input){
    is Success2->println("success")
    is Fail2->println("fail")
    //普通interface类型的时候，缺少了else操作会报错，因为存在非Success2或者非Fail2的情况。
    // 因为，其他代码文件中可能存在实现Result2接口的类
    else ->throw Exception("123")
}

fun showResult(input:Result) = when(input){
    is Success->println("success")
    is Fail->println("fail")
    //sealed类型，因为sealed class规定所有继承sealed class的其他类必须在同一个代码文件中，因此不需要else操作
}

fun SealedClassTest_Go(){
    var result2:Result2 = Success2()

    showResult2(result2)

    var result:Result = Success()

    showResult(result)
}

package com.example.myapplication

class Garage(val address:String) {
    inner class Car(var name:String){
        fun getGarageAddress():String{
            return address
        }
    }

    fun createCar():Car{
        return Car("fish")
    }
}

class Garage2(val address:String) {
    class Car2(var name:String){
        fun getGarageAddress():String{
            //非内部类无法获取外部类的成员
            //return address
            return ""
        }
    }

    fun createCar():Car2{
        return Car2("fish")
    }
}

fun InnerClassTest_Go(){
    val garage = Garage("a")
    val car1 = garage.createCar()
    println(car1.getGarageAddress())

    //内部类无法在外部类之外创建，因为它需要获取外部类的引用
    //var car1_out = Garage.Car("kk")
    //内部类，需要用外部类引用才能创建，看一下和上一个语句区别
    var car1_out = garage.Car("fish")

    var garage2 = Garage2("b")
    var car2 = garage2.createCar()

    //无法获取address，因为是普通的嵌套类
    println(car2.getGarageAddress())

    //嵌套类，可以仅仅通过外部类名称就能创建
    var car2_out = Garage2.Car2("kk")
    //嵌套类，无需用外部类引用来创建
    //var car3_out = garage2.Car2("fish")
}

package com.example.myapplication

//注意，这里的接口有个fun关键字，相当于Java里面的@FunctionalInterface注解
fun interface MyAnimal{
    fun call():String
}

fun goAnimal(animal:MyAnimal){
    println("animal call [${animal.call()}]")
}

class MyDog:MyAnimal{
    override fun call(): String {
        return "dog call"
    }
}

fun AnonymousClassTest_Go(){
    //明确地创建一个类
    goAnimal(MyDog())

    //匿名类
    goAnimal(object :MyAnimal{
        override fun call():String{
            return "Cat call"
        }
    })

    //可以用闭包传入参数，但是需要interface声明时有fun关键字才行
    goAnimal{
        "Closure Call"
    }
}

package com.example.myapplication

//我们声明为可继承的类
open class QAnimal(protected var name:String){
    fun callName(){
        println("call ${this.name}")
    }

    fun walk(){
        println("walk")
    }
}

//QDog可以通过继承的方式，复用QAnimal的行为逻辑
class QDog:QAnimal("Dog"){
    fun run(){
        println("Dog run")

        //继承的问题在于，强约束
        //子类可以修改父类的变量，而且每个类只能有一个父类
        this.name = "xxx"
    }
}

//QAnimal2是不可被继承的
class QAnimal2(var name:String){
    fun callName(){
        println("call ${this.name}")
    }

    fun walk(){
        println("walk")
    }
}

//QDog2复用QAnimal2的另外一种方式是，组合，创建一个内部的Animal类
//然后将QAnimal2的接口手动复制过来，转发给QAnimal2
class QDog2{
    private val myAnimal:QAnimal2 = QAnimal2("Dog2")

    fun callName(){
        myAnimal.callName()
    }

    fun walk(){
        myAnimal.walk()
    }

    fun run(){
        println("Dog run")

        //组合更加灵活，我们可以只转发一部分接口
        //另外，一个类允许组合多个类的行为，没有继承带来的强约束问题
        //使用这种方法的麻烦在于，当QAnimal2后续新增了行为以后，QDog2都要手动添加对应接口来转发，比较麻烦
        //this.name = "xxx"
    }
}

interface QAnimal3Interface{
    fun callName()
    fun walk()
}

//QAnimal3是不可被继承的
class QAnimal3(var name:String):QAnimal3Interface{
    override fun callName(){
        println("call ${this.name}")
    }

    override fun walk(){
        println("walk")
    }
}

//QDog3使用委托机制来实现组合的灵活性，同时避免组合需要手动添加接口的麻烦。
class QDog3:QAnimal3Interface by QAnimal3("Dog3") {

    fun run(){
        println("Dog run")

        //这个时候，by委托当Dog的接口新增的时候，不需要更改。
    }
}



fun ByClassTest_Go(){
    val dog1 = QDog()
    dog1.walk()
    dog1.run()
    dog1.callName()

    val dog2 = QDog2()
    dog2.walk()
    dog2.run()
    dog2.callName()

    val dog3 = QDog3()
    dog3.walk()
    dog3.run()
    dog3.callName()
}

package com.example.myapplication

import kotlin.reflect.KProperty

class ReadOnlyPropertyDelegate{
    operator fun getValue(thisRef:Any?,property:KProperty<*>):String{
        return "${thisRef?.javaClass}, thank you for delegating '${property.name}' to me!"
    }
}

class WritePropertyDelegate{
    operator fun getValue(thisRef:Any?,property:KProperty<*>):String{
        return "${thisRef?.javaClass}, thank you for delegating '${property.name}' to me!"
    }
    operator fun setValue(thisRef:Any?,property:KProperty<*>,value:String){
        println("${value} has been assigned to '${property.name}' in ${thisRef?.javaClass}")
    }
}

//属性的by委托，就是将属性的读写操作委托到另外一个类去
class ByPropertyExample{
    //val声明，只读
    val str:String by ReadOnlyPropertyDelegate()

    //var声明，可读写
    var str2:String by WritePropertyDelegate()
}

fun ByPropertyTest_Go(){
    val example = ByPropertyExample()

    println(example.str)
    println(example.str2)
    example.str2 = "789"
}

package com.example.myapplication

import kotlin.properties.Delegates

class example2 {
    //lazy，惰性获取变量，变量只能是只读的
    //该方法是线程安全的
    val no:Int by lazy {
        println("begin get no")
        200
    }

    //observable，可观察数据，首个参数的默认值，闭包是修改时候触发的
    var name: String by Delegates.observable("wang", {
        kProperty, oldName, newName ->
        println("kProperty：${kProperty.name} | oldName:$oldName | newName:$newName")
    })

    //notNull，与lateinit的效果一样，只是支持基元类型
    var instance:Int by Delegates.notNull()
}
fun LazyByTest(){
    val a = example2()
    println("after init a")
    println(a)
    println("get a")
    println(a.no)
    println(a.no)
}

fun ObservableByTest(){
    val a = example2()
    println("after init a")
    println(a)
    println("get a")
    println(a.name)
    a.name = "bb"
    a.name = "cc"
}

fun NotNullByTest(){
    val a = example2()
    //这里会产生运行是报错
    //println(a.instance)

    a.instance = 123
    println(a.instance)
}

fun BuiltInByPropertyTest_Go(){
    LazyByTest()
    ObservableByTest()
    NotNullByTest()
}

package com.example.myapplication

fun ListTest(){
    var a = listOf("a","b")

    //listOf 创建的是不可变集合，所以不能被Add
    //a.add("c")

    //读取下标
    println(a[0])

    //遍历list，不需要声明single
    for( single in a ){
        println(single)
    }
}

fun ListTest2(){
    var b = mutableListOf("a","b")

    //可修改集合
    b.add("c")

    //读取下标
    println(b[0])

    //遍历list
    for( single in b ){
        println(single)
    }
}

fun MapTest(){
    var a = mapOf("A" to 1,"B" to 2)

    //不可变的Map，不能被修改
    //a["B"] = 3;

    //读取下标
    println(a["A"])
    println(a["C"])//不存在的时候返回null

    //遍历map
    for( (key,value) in a ){
        println("key is ${key} value is ${value}")
    }
}

fun MapTest2(){
    var a = mutableMapOf("A" to 1,"B" to 2)

    //不变的Map，能被修改
    a["B"] = 3;

    //读取下标
    println(a["A"])
    println(a["C"])

    //遍历map
    for( (key,value) in a ){
        println("key is ${key} value is ${value}")
    }
}

fun CollectionTest_Go(){
    ListTest()
    ListTest2()
    MapTest()
    MapTest2()
}

package com.example.myapplication

fun BasicLambdaTest_Go(){
    val list = listOf("Apple","Banana","Orange","Pear","Grape")

    //lambda的基础写法
    val r1 = list.map({
        fruit:String->fruit.length
    })
    println("r1 is ${r1}")


    //lambda作为函数的最后一个参数的时候，可以移出到括号外面
    val r2 = list.map(){
            fruit:String->fruit.length
    }
    println("r1 is ${r2}")

    //map函数的参数为空的时候，可以省略括号
    val r3 = list.map{
            fruit:String->fruit.length
    }
    println("r1 is ${r3}")

    //可以省略lambda的参数类型，由kotlin来自己推导
    val r4 = list.map{
            fruit->fruit.length
    }
    println("r1 is ${r4}")

    //使用it关键字，来代表lambda的唯一参数的情况，这样能避免尖括号
    val r5 = list.map{
            it.length
    }
    println("r1 is ${r5}")
}

package com.example.myapplication

import java.io.BufferedOutputStream
import java.io.FileOutputStream

data class Person(private var name:String,private var age:Int){
    fun incAge(){
        this.age = this.age+1
    }

    fun getAge():Int{
        return this.age
    }
}

fun let_Go(){

    val a = Person("fish",123)
    //let 关键字，相当于js的with，只是需要明确指定一个参数可以
    a.let{
            person->
        println("age is ${person.getAge()}")
        println("age is ${person.getAge()}")
    }

    //等效于以上的效果，用it关键字能更省事一点
    a.let{
        println("age is ${it.getAge()}")
        println("age is ${it.getAge()}")
    }
}

fun with_Go(){
    var a = Person("fish",123)
    //let 关键字，与js的with，完全等价，可以直接调用对象的方法和变量。
    // 另外，最后一个语句的值，作为整个with语句的结果。
    var newAge = with(a){
        incAge()
        incAge()
        getAge()
    }
    println("new Age ${newAge}")
}

fun run_Go(){
    var a = Person("fish",123)
    //与let关键字等价，语法不同而已
    var newAge = a.run{
        incAge()
        incAge()
        getAge()
    }
    println("new Age ${newAge}")
}

fun apply_Go(){
    var a = Person("fish",123)
    //与let关键字相似，返回值是对象自身，而不是最后一个语句的值
    var newA = a.apply{
        incAge()
        incAge()
        getAge()
    }
    println("new Age ${newA}")
}

fun use_Go(){
    val fo = FileOutputStream("data")
    val bfo = BufferedOutputStream(fo)
    //外层流关闭的时候，内层流就会关闭
    //use会在闭包结束的时候自动调用close
    bfo.use {
        bfo.write("Hello".toByteArray())
    }
    bfo.close()
}


fun BuiltInLambdaTest_Go(){
    let_Go()
    with_Go()
    run_Go()
    apply_Go()
    use_Go()
}

package com.example.myapplication

fun String.lettersCount():Int{
    var count = 0
    for( char in this ){
        if( char.isLetter() ){
            count++
        }
    }
    return count
}

//使用泛型，可以对任何类型进行方法扩展
fun <A> A.with(b:String):String{
    return this.toString()+"#"+b;
}

data class testClass(val name:String,val age:Int)

fun ExtendFunctionTest_Go(){
    var a = "21 Hello22"
    println("lettersCount ${a.lettersCount()}")

    var b = "b".with("c")
    println("b ${b}")

    var c = testClass("fish",123).with("kk")
    println("c ${c}")
}

package com.example.myapplication

class Money(val value:Int) {
    operator fun plus(money:Money):Money{
        val sum = this.value + money.value
        return Money(sum)
    }

    operator fun plus(money:Int):Money{
        val sum = this.value + money
        return Money(sum)
    }

    operator fun minus(money:Money):Money{
        val sum = this.value - money.value
        return Money(sum)
    }

    operator fun minus(money:Int):Money{
        val sum = this.value - money
        return Money(sum)
    }

    operator fun times(money:Money):Money{
        val sum = this.value * money.value
        return Money(sum)
    }

    operator fun times(money:Int):Money{
        val sum = this.value * money
        return Money(sum)
    }

    operator fun div(money:Money):Money{
        val sum = this.value / money.value
        return Money(sum)
    }

    operator fun div(money:Int):Money{
        val sum = this.value / money
        return Money(sum)
    }

    operator fun compareTo(money:Money):Int{
        return this.value - money.value
    }

    override fun toString():String{
        return this.value.toString()
    }
}

fun MoneyTest(){
    val money1 = Money(10)
    val money2 = Money(20)
    var money3 = Money(10)
    println("money1 + money2 = ${money1+money2}")
    println("money1 - money2 = ${money1-money2}")
    println("money1 * money2 = ${money1*money2}")
    println("money1 / money2 = ${money1/money2}")
    println("money1 > money2 = ${money1 > money2}")
    println("money1 < money2 = ${money1 < money2}")
    println("money1 == money2 = ${money1 == money2}")
    println("money1 == money3 = ${money1 == money3}")


    println("money1 + 20 = ${money1+20}")
    println("money1 - 20 = ${money1-20}")
    println("money1 * 20 = ${money1*20}")
    println("money1 / 20 = ${money1/20}")
}

class MyArray {
    val list:ArrayList<Int> = ArrayList()

    fun add(data:Int){
        this.list.add(data)
    }

    operator fun get(index:Int):Int{
        return this.list.get(index)
    }

    operator fun set(index:Int,data:Int){
        this.list.set(index,data)
    }

    operator fun contains(data:Int):Boolean{
        return this.list.contains(data)
    }
}

fun MyArrayList_Go(){
    val list = MyArray()
    list.add(1)
    list.add(3)
    list.add(5)
    println("list[1] ${list[1]}")
    list[0] = 3
    println("list[0] ${list[0]}")
    println("3 in list is ${3 in list}")
    println("2 in list is ${2 in list}")
}

fun OperatorTest_Go(){
    MoneyTest()
    MyArrayList_Go()

    //返回值是IntRange类型
    //左闭右闭区间
    val target = (1..20)
    println("IntRange ${target}")
    val random = target.random()
    println("IntRange Random random ${random}")
    val newStr = "fish".repeat( random)
    println("newStr ${newStr}")
}

package com.example.myapplication

//Unit相当于Void类型
fun num1AndNum2(num1:Int,num2:Int,operatorion:(Int,Int)->Unit):Unit{
    operatorion(num1,num2)
}

fun print(num1:Int,num2:Int){
    println("num1 ${num1} and num2 ${num2}")
}

//一个特殊的闭包，类似apply方式的闭包，stringBuilder是该闭包的this参数
fun build(myBuilder:StringBuilder,block:StringBuilder.()->Unit):StringBuilder{
    block(myBuilder)
    return myBuilder
}

fun HighOrderFunctionText_Go(){
    val a = 10
    var b = 20
    //传入一个已存在的全局函数，用:;
    num1AndNum2(a,b,::print)
    //传入一个闭包
    num1AndNum2(a,b){c,d->
        println("c = ${c} and d = ${d}")
    }

    val c = StringBuilder()
    val d = build(c){
        //调用的都是StringBuilder里面的方法
        append(10)
        append("cc")
    }
    println("d is ${d}")
}

package com.example.myapplication

/*
 inline的优势：
 * 不需要进行函数的实际调用
 * 附加可以提前整个函数中退出的功能，return
 */
inline fun printStringInline(str:String, block:(String)->Unit){
    println("printString begin")
    block(str)
    println("pringString end")
}

fun printStringNoInline(str:String,block:(String)->Unit){
    println("printString begin")
    block(str)
    println("pringString end")
}

inline fun printStringInline2(str:String, block:(String)->Unit){
    println("printString begin")
    block(str)
    println("pringString end")
}


inline fun printStringInline3(str:String, block:(String)->Unit){
    println("printString begin")
    //inline的局限性一，inline函数中只能调用inline函数，不能调用noinline函数
    // 解决方法是，用noinline关键字包装，例如printStringInline3_2，同时失去闭包的内联能力
    //printStringNoInline(str,block)
    printStringInline2(str,block)
    println("pringString end")
}

inline fun printStringInline3_2(str:String, noinline block:(String)->Unit){
    println("printString begin")
    //inline的局限性
    printStringNoInline(str,block)
    println("pringString end")
}

inline fun printStringInline4(str:String, block:(String)->Unit){
    println("printString begin")
    //inline的局限性二，inline函数中不能将闭包block放在另外一个闭包runnable里面，因为没人清楚闭包runnable什么时候会触发
    // 解决方法是，用crossinline关键字包装，例如printStringInline4_2，同时会失去提前return全局函数的能力
    /*
    var runnable = Runnable {
        block(str)
    }
     */
    println("pringString end")
}

inline fun printStringInline4_2(str:String, crossinline block:(String)->Unit){
    println("printString begin")
    var runnable = Runnable {
        block(str)
    }
    println("pringString end")
}


fun inline_test1(){
    var str = ""
    println("init test1 begin")
    printStringInline(str){
        println("lambda start")
        if( str.isEmpty()){
            //这里的做法相当诡异，与普通语言不同
            //在闭包中return不是结束闭包，而是结束整个inline_test1
            return
        }
        println("lambda end")
    }
    println("init test1 end")
}

fun inline_test2(){
    var str = ""
    println("init test2 begin")
    printStringInline(str){
        println("lambda start")
        if( str.isEmpty()){
            //这里的return才是结束闭包
            return@printStringInline
        }
        println("lambda end")
    }
    println("init test2 end")
}

fun no_inline_test3(){
    var str = ""
    println("init test3 begin")
    printStringNoInline(str){
        println("lambda start")
        if( str.isEmpty()){
            //非inline函数，不能实现提前结束no_inline_test3
            //return
        }
        println("lambda end")
    }
    println("init test3 end")
}

fun no_inline_test4(){
    var str = ""
    println("init test4 begin")
    printStringInline4_2(str){
        println("lambda start")
        if( str.isEmpty()){
            //结束闭包
            return@printStringInline4_2
            //不能使用return，虽然是inline，因为有crossinline关键字
            //return
        }
        println("lambda end")
    }
    println("init test4 end")
}

fun crossinline_test5(){
    var str = ""
    println("init test4 begin")
    printStringNoInline(str){
        println("lambda start")
        if( str.isEmpty()){
            //结束闭包
            return@printStringNoInline
        }
        println("lambda end")
    }
    println("init test4 end")
}

fun InlineFunctionTest_Go(){
    inline_test1()
    inline_test2()
    no_inline_test3()
    no_inline_test4()
    crossinline_test5()
}

package com.example.myapplication

//Any 类型是非空的
//vararg 是不定参数的关键字
fun cvOf(vararg pairs:Pair<String,Any?>):Map<String,Any>{
    val result = HashMap<String,Any>()
    for( pair in pairs ){
        var key = pair.first
        var value = pair.second
        when(value){
            is Int->result.put(key,value)
            is String->result.put(key,value)
            null->{
                println("key ${key} is null")
            }
        }
    }
    return result
}

fun VarargFunctionTest_Go(){
    val result = cvOf("a" to 1,"b" to "fish","c" to 12,"d" to null)
    println(result)
}

package com.example.myapplication

//infix是一种语法糖，可以简化函数的调用语法，不需要点号，和括号来引用参数
//限制在于，必须是某个类的成员方法或者扩展方法，方法有且仅有一个参数
infix fun String.beginsWithFish(prefix:String):Boolean{
    return this.startsWith(prefix+"#")
}

fun InfixFunctionTest_Go(){
    var a = "ccasd"
    var b = "cc#adsf"
    println("a beginsWithFish ${a beginsWithFish "cc"}")
    println("b beginsWithFish ${b beginsWithFish "cc"}")
}

package com.example.myapplication

fun <T> printTemp(a:T){
    println(a.toString()+"_temp")
}

//带泛型上界的声明
fun <T :Person > printPerson(a:T){
    println(a.name+","+a.age);
}

open class Person(val name:String,val age:Int)

class Student:Person("student",123)

class SimpleData<T>{
    private var data:T? = null

    fun set(t:T?){
        this.data = t
    }

    fun get():T?{
        return this.data
    }
}

//函数参数接受任意的泛型类型
fun printAllSimpleData(data:SimpleData<*>){
    val re = data.get()
    println("re ${re}")
}

fun BasicGenericTest_Go(){
    printTemp("123Hello")
    printTemp(78)
    printTemp(Person("fish",123))

    printPerson(Person("cat",780))
    printPerson(Student())

    val data1 = SimpleData<Int>()
    data1.set(123)
    println("data1 ${data1.get()}")

    var data2 = SimpleData<Person>()
    data2.set(Person("cat",879))
    println("data2 ${data2.get()}")
    //这里会报错，因为类型不匹配
    //data2.set(123)

    //可以传入不同的泛型参数
    printAllSimpleData(data1)
    printAllSimpleData(data2)
}