Kotlin基本用法(一)

package com.wzx.kotlin


//const不适用于 局部变量。
const val PT = 3.1415926
fun main() {
    println("Hello world")
    //TODO  声明变量
    /*
    *  可读可改 变量名 类型 值
    */
    var name: String = "wzx"
    name = "LUCY"
    println(name)

    //TODO  内置数据类型
    /*
   *  String 字符串
   *  char 单字符
   *  Boolean true/false
   *  Int 整形
   *  Double
   *  Float
   *  List 集合
   *  Set 无重复对元素集合
   *  Map 键值对的集合
    */

    //TODO ======只读变量
    val info: String = "myInfo"
    println(info)


    //TODO ======类型推断
    //Explicitly given type is redundant here  给定的类型是多余的
    val info2: String = "myInfo"
    println(info)

    val age = 18
    println(age)

    //TODO ======编译时常量
    //编辑时常量只能是常用的基本数据类型（String Double Int FLoat Long Short Byte Char Boolean）
    //编译时常量只能在函数之外定义，why？ 因为如果在函数之内定义，就必须在运行时才能调用赋值，何来编译时常量一说
    //结论：编译时常量只能在函数之外定义，就可以在编译期间赋值初始

    //const不适用于局部变量。
    //const val PT2 = 3.1415926

    //TODO ======查看kotlin反编译后字节码
    //tools --> kotlin --> show kotlin bycode --> decompile

    //TODO ======kotlin 引用类型学习
    //java有两种数据类型：1、基本类型；2、引用类型
    //kotlin只有一种数据类型，看起来是引用类型，实际上编辑器会在java字节码中修改成"基本类型"

    //TODO ======range表达式
    //上升： 1..1024  闭区间 ; [0,1024] 1 until 1024 // 半闭区间 [1,1024)
    //下降：i in 4 downTo 1
    //进阶：i in 1..10 step 3; i in 1 downTo 10 step 3
    val number = 48
    if (number in 10..59) {
        println("不及格")
    } else if (number in 0..9) {
        println("不及格且很差")
    } else if (number in 60..100) {
        println("合格")
    } else if (number !in 0..100) {
        println("分数不在0到100的范围内")
    }

    //TODO ======when表达式
    val week = 5
    //info 不确定什么类型，例如下面又有""，又有{},那么会返回Any类型
    //Any相当于java的Object
    //Unit相当于java的void
    val info3 = when (week) {
        1 -> "周一"
        2 -> "周二"
//        else ->"其他"
        else -> {
            println("其他")
        }
    }
    println(info3)

    //TODO ======字符串模板
    val garden = "泉水公园"
    val time = 6
    println("今天天气很好，去$garden")
    println("今天天气很好，去${garden}玩，玩了$time 小时") //如果garden后面没有字符串，可以不加{}.time后面是空格不是字符串，可以不加{}

    //kt 的if是表达式，所以更灵活。java的if是语句，有局限性
    val isLogin = true
    println("service response result ${if (isLogin) "登录成功" else "登录失败"}")

    //TODO ======函数参数的默认参数 使用
    action01("wzx", 11)
    action02("wzx")
    action02("wzx", 11)
    action03()
    action03("wzx", 11)

    //TODO ======具名函数参数 使用
    //参数没有顺序
    LoginAction(age = 9, phoneNumber = "122222", name = "wzx", pass = "111")

    //TODO ======反引号中函数名特点 使用
    //情况1
    `登录测试`("wzx", "123")
    //情况2:in is在kt里是关键字，但在java里是普通的。当调用java的is方法时，加上``
    //    ktBase.`is`()
    //    ktBase.`in`()
    //情况3 很少发生
    `129752745`()

}

//TODO ======函数头
//函数默认public fun：函数声明变量关键字
//kotlin的函数，先有输入，再有输出（更规范）
//输出类型：Int
private fun method01(age: Int, name: String): Int {
    return 200
}

//TODO ======函数参数的默认参数

private fun action01(name: String, age: Int) {
    println("姓名$name,年龄$age")
}

//赋值后，可以不传
private fun action02(name: String, age: Int = 77) {
    println("姓名$name,年龄$age")
}

private fun action03(name: String = "赵四", age: Int = 77) {
    println("姓名$name,年龄$age")
}


//TODO ======具名函数参数
private fun LoginAction(name: String, pass: String, age: Int, phoneNumber: String) {

}

//TODO ======Unit函数特点
//Java 的Void是关键字，他是void是无参数返回的 忽略类型
//unit不写，默认也有，unit代表，无参数返回的 忽略类型==unit类型类
private fun doWork(): Unit {
    return println()
}

private fun doWork1() {
    return println()
}

private fun doWork2() {
    println()
}

//TODO ======Nothing类型特点
private fun show(number: Int) {
    when (number) {
        -1 -> TODO("没有这种分数")
        in 0..59 -> println("1")
        in 60..70 -> println("2")
        in 71..100 -> println("3")
    }
}

interface A {
    fun show()
}

class AImpl : A {
    override fun show() {
        //下面这句话，不是注释提示，会终止程序的
        TODO("Not yet implemented")
    }

}

//TODO ======反引号中函数名特点
//情况1
//`登录测试`("wzx", "123")
private fun `登录测试`(name: String, pwd: String) {
    println("$name $pwd")
}

//情况3
private fun `129752745`() {
    //很多很复杂的功能，核心功能
    //...
}
//公司加密私有的文档 129752745=此函数的作用：XXX