Kotlin 程序结构

常量
val = value,值类型
类似Java的final
不可能重复赋值

• 运行时常量：val x =getX()

• 编译期常量：const val x = 2
  变量
  val = variable

• var x = “HelloWorld”//定义变量

• x = “Hello,China”//再次赋值
  类型推导
  编译器可以推导量的类型

• val string =“Hello” //推导出String类型

• val int = 5 //Int 类型

• var x = getString() + 5 //String类型
  函数
  以特定功能组织起来的代码块

• fun函数名:[返回值类型]{[函数体]}

• fun函数名 = [表达式]
  举例：

• fun sayHi(name:String) { println(“Hi,$name”) }

• fun sayHi(name:String) = println(“Hi,$name”)
  匿名函数
  fun([参数列表])…

• val sayHi = fun(name:String) = println(“Hi,$name”)
  编写函数的注意事项
  功能单一
  函数名要做到顾名思议
  参数个数不要太多
  Lambda 表达式
  匿名函数
  写法:{[参数列表]->[函数体，最后一行是返回值]}

• val sum = {a:Int,b:Int->a + b }
  Lambda的类型举例
  ()->Unit
  无参,返回值为Unit
  (Int)->Int
  传入整型，返回一个整型
  (String,(String)->String)->Boolean

• 传入字符串、Lambda表达式，返回Boolean
  Lambda表达式的调用
  用()进行调用
  等价于invoke()

• val sum = {a:Int,b:Int -> a + b}

• sum(2,3)

• sum.invoke(2,3)
  Lambda表达式的简化
  函数参数调用时最后一个Lambda可以移出去
  函数参数只有一个Lambda,调用时小括号可以省略
  Lambda只有一个参数可默认为it
  入参，返回值与形参一致的函数可以用函数引用的方式作为实参传入

fun main(args: Array<String>) {
   
   

    println(int2Long(3))
    println(sum(2, 3))
    println(sum2(5, 6))
    println(sum.invoke(1, 3))

    val args: Array<Int> = arrayOf(1, 2, 3, 4, 5, 6)
    for (i in args) {
   
   
        println(i)
    }
    args.forEach(::println)
    println("--------------------------------")
    args.forEach ForEach@{
   
   
        if (it == 2) return@ForEach
        println(it)
    }
    println("The End 1.....")
    args.forEach {
   
   
        if (it == 3) return
        println(it)
    }
    println("The End 2.....")
}

val int2Long = fun(x: Int): Long {
   
   
    return x.toLong()
}

val sum = {
   
    arg1: Int, arg2: Int -> arg1 + arg2 }

val sum2 = {
   
    arg1: Int, arg2: Int -> println("$arg1 + $arg2 = ${arg1 + arg2}") }
3
5
5 + 6 = 11
kotlin.Unit
4
1
2
3
4
5
6
1
2
3
4
5
6
--------------------------------
1
3
4
5
6
The End 1.....
1
2

类成员
属性:作者说成员变量，类范围内的变量
方法:或者说成员函数，类范围内的函数
函数和方法的区别
函数强调功能本身，不考虑从属
方法的称呼通常是从类的角度出发
叫法不同而已,不要纠结
定义属性
构造方法参数中val/var修饰的都是属性
类内部也可以定义属性
属性访问控制
属性可以定义getter/setter

• val a:Int = 0 //不能定义set()
• get() = field
• var b:Float = 0f //可以定义getter/setter
• set(value){field = value}
  属性初始化
  属性的初始化尽量在构造方法中完成
  无法在构造方法中初始化，尝试降级为局部变量
  var用lateinit延迟初始化,val用lazy
  可空类型谨慎用null直接初始化

class X
//lateinit 延迟初始化
class A {
   
   
    var b = 0
    lateinit var c: String
    lateinit var d: X
    val e: X by lazy {
   
   
        println("init X")
        X(