Android --- Kotlin学习之路：基础语法学习笔记

------>可读可写变量

var name: String = "Hello World";

------>只读变量

val name: String = "Hello World"

------>类型推断

val name: String = "Hello World" 可以写成 val name = "Hello World"

------>基本数据类型

1.String,Double,Int,Float,Long,Short,Byte,Char,Boolean
2.Kotlin对于小数的默认推断是Double类型，默认6位
3.and(bits)，or(bits), inv()

------>编译时常量

const val PI = 3.1415 需要定义在全局变量范围内，不能定义到函数内部，这才叫编译时常量

------>range 表达式

val number = 148
        if (number in 0 .. 59) {
            println("不及格")
        } else if (number in 60 .. 100) {
            println("及格")
        } else if (number !in 0 .. 100) {
            println("成绩无效")
        }
        

------>when 表达式

 val month = "January"
        val result = when(month) {
            "January" -> "一月"
            "February" -> "二月"
            "March" -> "三月"
            "April" -> "四月"
            "May" -> "五月"
            "June" -> "六月"
            "July" -> "七月"
            "August" -> "八月"
            "September" -> "九月"
            "October" -> "十月"
            "November" -> "十一月"
            "Devember" -> "十二月"
            else -> "错误的月份"
        }
        println(result)
        

------>String 模板

 val isLogin = true
        println("server respose result : ${if (isLogin) "登录成功" else "登录失败"}")
		

------>具名函数参数
具名函数的意义是：假如一个函数有多个参数，传递参数的时候为了避免一个一个对，可以直接用名字赋值

loginAction(name = "Derr", age =90)
        private fun loginAction(name: String, age: Int) {
            println("name is : ${name}, age is : ${age}")
        }

------>Nothing 类型会终止程序

TODO("not implement")  

------>双等号相当于Java中的equals()，三哥等号是引用的比较，也就是地址的比较

------>类型转换相关

val number1 : Int? = "666.6".toIntOrNull() // 能转换成功就转换，不成功就返回Null
val r = "%3.f".format(65.38344) // r 的类型是String
println(65.683.roundToInt()) // 会四舍五入，结果是66

------>apply 内置函数

apply 函数会返回对象本身
val file = File("D:\\a.txt")
// 普通写法
file.setExecutable(true)
file.setReadable(true)
println(file.readLines())

//apply写法
file.apply {
	setExecutable(true) // 这里面会有this引用，可以省略不写
}.apply {
	setReadable(true)
}.apply {
	println(readLines())
}.ll

------>let 内置函数

fun main() {
    println(getMethod(null))
}
fun getMethod(value: String?): String {
	// 判空用法，当value为空的时候将不会执行闭包里面的逻辑
    return value?.let {
        "值是非空的"
    } ?: "值是空的"
}

------->run 扩展函数
最后一行当作函数的返回值，在run函数中可以直接访问实例的公有属性和方法

fun main() {
    println(testRun(Jump()))
}

class Jump {
    fun test():String {
        return "111"
    }
}
fun testRun(jump: Jump) : String {
    jump.run {
        test() // 直接调用
        return jump.test()
    }
}

------>数组的创建

 val array: Array<Any> = arrayOf(1, 2, 3, 4)
 println(array[0])

 val arrayOfNulls = arrayOfNulls<Any>(5)
 arrayOfNulls[0] = "1"
 arrayOfNulls[1] = 'A'
 arrayOfNulls[2] = 1
 arrayOfNulls.forEachIndexed(action = {
     index, item ->
     println("$index：$item")
 })

------>可变的集合，不可变的集合

 // 可变集合
 val array = mutableListOf<Any>()
 array.add("1")
 array.add(2)
 // 不可变集合
 val arrayInt = listOf(1,2,3)
 // 可变Map
 val arrayMap = mutableMapOf<String, Int>()
 arrayMap["1"] = 1
 arrayMap["2"] = 1
 // 不可变Map,通过Pair指定集合里面的元素
 val arrayMap2 = mapOf<String, Int>(Pair("1",1))
 for (item in arrayMap2) {
     println(item)
 }

------>类

Person().test()
Person.test2()
println(NumUtil.double(4))

// 普通类
class Person {
    fun test() {
        println("猪头")
    }
    // 半生类
    companion object{
        fun test2() {
            println("半生类")
        }
    }
}

// 静态类
object NumUtil {
    fun double(num: Int): Int {
        return num * num
    }
}

------>泛型类和泛型接口

fun main() {
    val drinkFruits = DrinkFruits()
    drinkFruits.drinks("apple juice")

    val eat = EatEgg("blue")
    eat.prints()
}
// 泛型接口
interface Drink<T> {
    fun drinks(t: T)
}
class DrinkFruits: Drink<String> {
    override fun drinks(t: String) {
        println("Drink:$t")
    }
}
// 泛型类
abstract class Eat<T> {
    abstract fun prints()
}

class EatEgg(val color: String) : Eat<String>() {
    override fun prints() {
        println("eat:${color}'s egg")
    }
}

------->扩展方法

扩展方法在什么时候使用呢？
当一个jar包中的方法不满足我们的需求时，
我们可以给jar包中的某个类添加方法，因为jar包中的那个方法本身是不可以修改的

fun main() {
    println(Jump().doubleJump())
}

class Jump {
}

fun Jump.doubleJump(): String {
    val result = "此方法为扩展方法"
    return result
}

----------->延迟初始化

private lateinit var _binding: FragmentFirstBinding

-----------------------------------------基础知识学习完之后训练的例子-------------------------------------------------

package com.example.kotlindemo

// 一次2位数四则运算
fun main() {
    while(true) {
        // 控制台输入
        println("请输入一个2位数的加减乘除")
            val input = readLine()
        input?.let {
            val result = calculate(input)
            println(result)
            println("是否继续使用程序，继续使用请输入Y，不使用请输入N")
            val inputContinue = readLine()
            inputContinue?.let {
                if (it != "Y") {
                    System.exit(-1)
                }
            }
        }
    }

}

fun calculate(input: String): String {
    if (input.contains("+")) {
        val strings = input.trim().split("+")
        return operate(strings[0].toDouble(), strings[1].toDouble(), "+").toString()
    } else if (input.contains("-")) {
        val strings = input.trim().split("-")
        return  operate(strings[0].toDouble(), strings[1].toDouble(), "-").toString()
    } else if (input.contains("*")) {
        val strings = input.trim().split("*")
        return  operate(strings[0].toDouble(), strings[1].toDouble(), "*").toString()
    } else if (input.contains("/")) {
        val strings = input.trim().split("/")
        return  operate(strings[0].toDouble(), strings[1].toDouble(), "/").toString()
    } else {
        return "you input is error!"
    }
}

fun operate(num1: Double, num2: Double, operateChar: String): Double {
    return when(operateChar) {
        "+" -> num1 + num2
        "-" -> num1 - num2
        "*" -> num1 * num2
        "/" -> num1 / num2
        else -> 0.0
    }
}