kotlin基础语法

1.变量

var a:Int = 2                        //声明类型的可变变量

（）

var b = 3                             //代码推测可变变量类型

val c = 6                             //代码推测不可变常量类型

（）

var d:String?=null              //可为null的String类型的可变变量

lateinit var e:String            //延迟初始化的String类型的可变变量（不能为null）

val f:String by lazy("xxx")  //String类型的不可变常量，被访问时会赋值xxx

const val g = 4                  //编译期常量

 2.函数

fun sum(a:Int, b:Int):Int(

        return a+b

)

//fun 函数名(参数1:参数1类型, 参数2:参数2类型):返回值类型

fun p(c:Int, d:Float = 1f) = c+d

//kotlin的函数的参数可以赋初始值，当不传参数时就会使用初始值

//方法也可以直接简写

fun more(vararg a:Int)(

        return a.get(0)+...+a.get(xx)

)

//vararg表示可以传多个参数，参数就相当于一个数组

3.语法

        除了 for 与 when 其他与Java一致

for( i in 0..10))( printLn(i) )        //左右闭区间

for( i in 0 until 10))( printLn(i) )        //左右开区间

for( i in 0..10 step 2))( printLn(i) )        //0、2、4、6、8、10

for( i in 10 downTo 0 step 2))( printLn(i) )        //10、8、6、4、2、0

when(i){

        i is String->{}

        i !is Float->{}

        i in 0..10->{}

        i == 2->{}

        else->{}

}

when{

       boolean->{}

       else->{}

}

• i is String -> {}：当 i 是 String 类型时执行的代码块

• i !is Float -> {}：当 i 不是 Float 类型时执行的代码块

• i in 0..10 -> {}：当 i 在闭区间 [0, 10] 内时执行的代码块

• i == 2 -> {}：当 i 的值等于 2 时执行的代码块

• else -> {}：当以上条件都不满足时执行的代码块

• boolean -> {}：当 boolean 为真时执行的代码块。这里 boolean 是一个布尔值

• else -> {}：当以上条件都不满足时执行的代码块

  4.类

  interface AAA{

          fun aaa()                //需要重写

          fun bbb(){}              //不需重写

  }

  •  实现AAA时，其已经有方法体的方法可以不重写

    object Obclass{

            fun aaa()

    }

    • Kotlin 中的单例对象 Obclass，外部可以直接用object.aaa()来调用其方法

      data class AAA(var name:String, var age:Int = 20){

              var grade:String = " "

      }

      • 数据类，至少有一个参数（所有参数都要声明类型）

        sealed class Slclass() 

        • 密封类（枚举） 

          5.构造函数

          class AAA(private var b:Int = 1)

          class AAA private constructor (var b:Int)

          class AAA(){

                  constructor()

                  constructor(var b:Int):super()

                  constructor(var a:String, var b:Int = 20):super()

                  init{

                          //初始化

                  }

          }

          • 前两个是只有主构造函数，第三个包含了多个辅助构造函数
          • init在主构造函数之后执行