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 = 148if (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 = trueprintln("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] = 1arrayOfNulls.forEachIndexed(action = {index, item ->println("$index：$item")})

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

 // 可变集合val array = mutableListOf<Any>()array.add("1")array.add(2)// 不可变集合val arrayInt = listOf(1,2,3)// 可变Mapval arrayMap = mutableMapOf<String, Int>()arrayMap["1"] = 1arrayMap["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 / num2else -> 0.0}
}