Kotlin语言

Kotlin语言

Google规定的官方Android语言

# 1. 变量

// TODO Var 与 Val
fun main() {

    // 可变变量定义：var 关键字
    // var <标识符> : <类型> = <初始化值>

    // 不可变变量定义：val 关键字，只能赋值一次的变量(有一点点类似Java中final修饰的变量)
    // val <标识符> : <类型> = <初始化值>

    // 可以修改的
    var name: String = "Derry"
    name = "张三"
    name = "李四"

    var info1 = "AAAA" // 类型推到
    var info2 = 'A' // 类型推到  Char
    var info3:Int = 99 // 类型推到  Int

    // 不可以修改的
    val age: Int = 99
    // age = "" 报错


    // 静态语言 编译期 就决定了 String类型
    var info4 = "LISI"  // info4==String类型
    // info4 = 88   // js 动态解释语言
}

class Test {

    // 可以改，可以读  get  set
    var info1 : String = "A"

    // 只能读， 只有 get
    val info2 : String = "B"
}

val相等于 加了 final 修饰

# 2. 函数

// TODO 函数  方法

// void == :Unit
fun main(): Unit {

    println(add(1, 1))

    lenMethod(1, 2, 3, 4, 5, 6, 7)

    // lambda表达式函数
    val addMethod : (Int, Int) -> Int = {number1, number2 -> number1 + number2}
    val r= addMethod(9, 9)
    println(r)
}

// 返回类型Int
fun add(number1: Int, number2: Int): Int {
    return number1 + number2
}

// 返回类型  == 类型推导 Int
fun add2(number1: Int, number2: Int) = number1 + number2

// 返回类型  == 类型推导 String
fun add3(number1: Int, number2: Int) = "AAA"

// 可变参数 （可变长 参数函数）
fun lenMethod(vararg value: Int) {
    for (i in value) {
        println(i)
    }
}

# 3. 字符串模板

// TODO 字符串模板
fun main() {

    // $ 表示一个变量名或者变量值

    // $varName 表示变量值

    // ${varName.fun()} 表示变量的方法返回值

    val name = "张三"

    val age = 28

    val sex = 'M'

    val info = "ABCDEFG"

    println("name:$name,  age:$age,  sex:$sex  info:$info")

    // --- 自己不用关系 
 换行 ，不用自己调整
    val infoMesage = """
        AAAAAAAAAAA
        BBBBBBBBBBB
        CCCCCCCCCCC
        DDDDDDDDDDD
        EEEEEEEEEEE
    """  // 前置空格
    println(infoMesage)

    val infoMesage2 = """
        AAAAAAAAAAA
        BBBBBBBBBBB
        CCCCCCCCCCC
        DDDDDDDDDDD
        EEEEEEEEEEE
    """.trimIndent()  // 没空格
    println(infoMesage2)

    val infoMesage3 = """
        ?AAAAAAAAAAA
        ?BBBBBBBBBBB
        ?CCCCCCCCCCC
        ?DDDDDDDDDDD
        ?EEEEEEEEEEE
    """.trimMargin("?")  // 没空格 控制|
    println(infoMesage3)

    // 需求：显示 $99999.99
    val price = """
        ${'$'}99999.99
    """.trimIndent()
    println(price)
}

# 4. 空检查机制

// TODO NULL检查机制
fun main() {
    // Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，
    // 有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?

    var info: String? = null

    // println(info?.length)  // 第一种补救：? 如果info是null，就不执行 .length

    // println(info!!.length) // 第2种补救： !! 我自己负责info 不会为null ==  (不管null不null必须执行)  ==  Java

    /*if (info != null)           // 第3种补救：  ==  Java
        println(info.length)*/

    // println(testMethod("AAAAA"))

    // 刚那个提问的呢?
    // ?:  如果你一定要输出null  就让你  “你很牛逼”
    println(info?.length           ?: "你很牛逼")
}

// : Int? === 允许返回null
fun testMethod(name: String) : Int? {
    if (name == "zs") {
        return 99999
    }
    return null
}

# 5. 区间

// TODO 区间
fun main() {

    // 1 到 9
    for (i in 1..9) {
        // println(i)
    }

    // 不会输出
    for (i in 9..1) {
        // println(i)
    }

    // 大 到 小
    for (i in 9 downTo 1) {
        // println(i)
    }

    // 用区间做判断
    val value = 88
    if (value in 1..100) {
        // println("包了 1 到 100")
    }

    // 步长指定
    for (i in 1..20 step 2) {
        // 1 3 5 7 ...
        // println(i)
    }

    // 排除 最后元素
    for (i in 1 until 10) {
        println(i)
    }
}

# 6. 比较

// TODO 比较两个值
fun main() {

val name1: String = "张三"
val name2: String = "张三"

// --- 比较值本身
// == 等价 Java的equals
println(name1.equals(name2))
println(name1 == name2)


// ---  比较对象地址
val test1:Int? =  10000
val test2:Int? =  10000
println(test1 === test2) // false
}

# 7. 数组

// TODO 数组
fun main() {
    // 第一种形式
    val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8)
    // println(numbers[0])
    // println(numbers[7])
    for (number in numbers) {
        // println(number)
    }

    // 第二种形式  value=0
    // 0 + 200 = 200
    // 1 + 200 = 201
    val numbers2 = Array(10,  {value: Int -> (value + 200) })
    for (value in numbers2) {
        println(value)
    }

    // 定义一个变量 value Int类型
    // value=0 + 200
    // {value: Int                ->                     (value + 200) }
}

# 8. 条件

// TODO 条件
fun main() {
    val number1: Int = 9999999
    val number2: Int = 8888888

    // 表达式 比 大小 最大值
    val maxValue = if (number1 > number2) number1 else number2
    // println(maxValue)

    val max: Int = if (number1 > number2) {
        println("number1是最大的哦")
        // TODO
        // ....... 省略 200行代码
        number1
    } else {
        println("number2是最大的哦")
        // TODO
        // .......  省略 200行代码
        number2
    }
    // println(max)

    // 使用区间做判断
    val x = 80
    val y = 29
    if (x in 1..10 && y in 1..50) {
        // println("x y 轴 符合")
    } else {
        // println("x y 轴 不符合")
    }

    println()


    /* val number = 5
     when(number) {
         1 -> println("一")
         2 -> println("二")
         3 -> println("三")
         4 -> println("四")
         5 -> println("五")
         else -> println("其他")
     }*/

    /*val number = 745
    when(number) {
        in 1..100 -> println("1..100")
        in 200..500 -> println("200..500")
        else -> println("其他")
    }*/


    // Object == Any ?
    // val str : String = ""

    val number = 3
    val result = when (number) {
        1 -> {
            println("很开心")
            // 很多很多的逻辑..  省略 200行代码
            // ...
            // TODO ....
            "今天是星期一"
            99
        }
        2 -> {
            println("很开心")
            // 很多很多的逻辑..  省略 200行代码
            // ...
            // TODO ....
            "今天是星期二"
            88
        }
        3 -> {
            println("很开心")
            // 很多很多的逻辑..  省略 200行代码
            // ...
            // TODO ....
            "今天是星期三"
            true
            100
        }
        else -> 99
    }
    // println(result)


    when (8) {
        1, 2, 3, 4, 5, 6, 7 -> println("满足")
        else -> println("不满足")
    }
}

# 9. 循环标签

package simple04.s01

// TODO 循环 与 标签
fun main() {

    // 自定义标签
    tttt@ for (i in 1..20) {

        for (j in 1..20) {
            println("i:$i, j:$j")

            if (i == 5) {
                // break // j循环 给break

                break@tttt // i循环 给break
            }
        }

    }


    // TODO 循环
    var items  = listOf<String>("李四", "张三", "王五")
    for (item in items) {
        println(item)
    }

    items.forEach {
        println(it)
    }

    for (index in items.indices) {
        println("下标：$index,  对应的值：${items[index]}")
    }

}

// 自带的标签
class Derry {

    val I = "AAAA"

    fun show() {
        println(I)
        println(this.I)
        println(this@Derry.I)
    }

}

# 10. 类与对象

空类

// 默认就是public
class Empty

person类

// public final class Person 默认就是这样的，不能被继承，  可以加open就可以被人家继承了
open class Person(id: Int) // 主构造
{

    // 次构造
    constructor(id: Int, name: String) : this(id) {

    }

    // 次构造
    constructor(id: Int, sex: Char) : this(id) {

    }

    // 次构造
    constructor() : this(787) {

    }

}

调用 person

// TODO 类与对象
fun main() {

    val person = Person() // 次构造

    val person2 = Person(6465) // 主构造


    Person(464, "Derry") // 次构造
    Person(464, 'M') // 次构造
}

student 继承 person

class Student(id: Int) : // Person() // 次构造
                Person(id) // 主构造了
{
    // 再Kotlin 全部都是没有默认值的

    // 再Java 成员有默认值，但是方法内部没有默认值

    // lateinit 懒加载  没有赋值 就不能使用，否则报错
    lateinit var name : String
    var age: Int = 0
}

抽象类与接口

// 接口默认都是 open
interface Callback {

    fun callbackMethod() : Boolean

}

抽象类 实现接口 可以不用实现方法

// 默认是 public final class Person 不能被人家继承的      abstract有open的特征 相当于open
abstract class Person : Callback , Callback2 {

    abstract fun getLayoutID() : Int

    abstract fun initView()

}

继承抽象类 实现抽象类 和 接口方法

class Student : Person() {

    override fun getLayoutID(): Int = 888

    override fun initView() { }

    override fun callbackMethod(): Boolean  = false
}

# 11. 数据类

bean 类

/**
 * 数据类  == Java实体Bean
 */

// 不会再修改了，可以是使用val
// get set 构造 equals hashCode toString，  copy
data class User(val id: Int, val name: String, val sex: Char)

引擎

// 只实例一次   相当于 单例
object MyEngine {

    fun m() {
        println("M run")
    }

    fun show() {
        println("我就只有一个实例")
    }
}

实现

// TODO  data数据类 ，object单例
fun main() {

    val user = User(99, "lisi", 'M')

    val(myID, myName, mySex) = user.copy()
    println("myID:$myID, myName:$myName, mySex:$mySex")

    // _ 代表不接收
    val(_, myName2, _) = user.copy()
    println("myName2:$myName2")

    // --- 相当于 new 了五次
    MyEngine.m()
    MyEngine.m()
    MyEngine.m()
    MyEngine.m()
    MyEngine.m()
}

单例模式1

package simple05.s04

// TODO　Kotlin 单例模式1
class NetManager {

    // object只有一个实例
    object Holder {

        val instance = NetManager()

    }

    // 看不到 static  可以 派生操作
    companion object {

        // 全部都是  相当于 Java static

        fun getInstance() : NetManager = Holder.instance
    }

    fun show(name: String) {
        println("show:$name");
    }

}

// 客户端
fun main() {
    val net  = NetManager.getInstance()
    net.show("kt Derry1")
}

单例模式2

package simple05.s04

// TODO　kt 单例模式2
class NetManager2 {

    companion object {

        private var instance: NetManager2? = null

        // 返回值：允许你返回null
        fun getInstance(): NetManager2? {
            if (instance == null) {
                instance = NetManager2()
            }

            // 如果是null，也返回回去了
            return instance

            // 第二种补救： 我来负责 instance 肯定不为null
            // return instance!!
        }

    }


    fun show(name: String) {
        println("show:$name");
    }

}

fun main() {
    // 客户端 来做补救措施
    val netManager = NetManager2.getInstance()

    // 如果 netManager == null ，就不执行 .show("AAA")
    netManager?.show("AAA")
}