Kotlin之基础语法

Kotlin之基础语法

语言简介

kotlin是一门新语言，它有自己的编译器，能将kotlin代码编译成class文件，因此能被JVM识别，所以kotlin也是一门解释型语言，同java一样。JVM并不关心class文件来自于Java还是Kotlin，只要是符合规定的class文件，它都能识别。

语法特点

• Kotlin每一行代码的结尾是不用加分号的。
• Kotlin完全抛弃了Java中的基本类型，继而全部使用对象数据类型。
• Kotlin主要有类（class）、文件(file)、接口(interface)、密封接口(sealed interface)、数据类(data class)、枚举类(enum class)、密封类（sealed class）、注解（annotation）、单例类（object）。
  • File通常是用于编写Kotlin顶层函数和扩展函数的。

常用的关键字

• is关键字：可以用来判断对象的类型，相当于java的instanceof。

  •   val a = 10
      val b = a is Int
    

• Unit
  • 也是一种类型，就像Int一样，只是它不代表任何信息。
  • 它的实例只有一个，可写为()。
• ?:
  • 它叫做Elvis运算符，或者null合并运算符。
  • 作用：可以用来给可空类型的变量指定为空情况下的值。

    •  var test: Int? = null
       test = test ?: 1
      

变量

• 声明变量：使用var和val。
  • val：不可变变量。等同于Java的final变量。
    • 好的习惯：除非一个变量明确允许被修改，否则就应该把定义为final的。因此，建议永远优先使用val来声明一个变量，当val不满足需求时再使用var。

    •   val s: String = "hello"
      

  • var：可变变量。

    •  var s: String
      

• 出色的类型推导：编译器可以在不显式声明类型的情况下，自动推导出它所需要的类型。
  • 虽然Kotlin的类型推导机制很强大，但是也有它推导不了的情况，比如对一个变量延迟初始化，这时就无法推导，必须在定义时显式地声明变量类型才可以。

  •  val s = "hello"
     println("s的类型是：${s.javaClass.name}")
     
     输出：
     s的类型是：java.lang.String
    

• 声明函数返回值类型：
  • 如果没有声明返回的类型，函数会默认返回Unit类型。

  •  fun sum(x: Int, y: Int): Int {
     	return x + y
     }
    

  • 以上代码可以用表达式函数体来优化。
    • 表达式函数体：用单行表达式与等号的语法来定义函数。
    • 与之对应，普通的函数声明则可叫做代码块函数体。

    •  fun sum(x: Int, y: Int) = x + y
      

    • 在使用表达式函数体可以不声明返回值类型。但这不代表只要使用了表达式函数体就可以不声明返回值类型。
      • 如下，编译器不能针对递归函数的情况推导类型。

      •  fun foo(n: Int): Int = if (n == 0) 1 else n * foo(n - 1)
        

  • 总结：哪些情况需要显式声明类型？
    • ①它是函数的参数：必须。
    • ②它是一个非表达式定义的函数：除了返回Unit，其他情况必须。
    • ③它是一个递归的函数：必须。
    • ④它是一个公有方法的返回值：为了代码可读性和输出类型的可控性，建议。
    • ⑤除了以上情况，就可以不显式声明，除非碰到意外。

函数

• 函数-function，方法-method，它们是同一个东西，只是叫法习惯不同。在c、c++中习惯叫做函数，在Java中习惯叫做方法，而在Kotlin中习惯叫做函数。
• 定义：使用fun关键字来定义函数。
• 格式：

  •  fun methodName(param1: Int, param2: Int): Int {
     
     }
    

函数可变参数

• 使用varargs关键字来定义。
• 类似于Java的“…”，不同的是Java的可变参数必须是最后一个参数，而kotlin没有这个限制。
• 它们都可以在函数体中意数组的方式来使用可变参数变量。

  •  fun test(vararg nums: Int, count: Int) {
             nums.forEach { println(it) }
     }
    
     test(1, 2, 3, count = 4)
     
     输出：
     1
     2
     3
    

• 可以使用星号*来传入外部的变量作为可变参数的变量。

  •  val arr = IntArray(3)
     test(*arr, count = 3)
     
     输出：
     0
     0
     0
    

逻辑控制

if表达式

• kotlin的if语句与Java不同的是它可以有返回值。

•  val random = Random(47)
   val a = random.nextInt(100) + 1
   val b = random.nextInt(100) + 1
   val num = if (a > b) a else b
   println("a = $a, b = $b, num = $num")
   
   输出：
   a = 97, b = 59, num = 97
  

when表达式

• when表达式类似于switch语句，有when关键字开始，用大括号包含多个逻辑分支，每个分支用“->”连接，不需要break，从上到下匹配，一直匹配完为止，否则执行else分支的逻辑，else分支类似于default。
• 对比Java的switch语句，switch只能使用整型、短于整型或字符串的变量。
• when表达式同样可以有返回值。

  •  val random = Random(47)
     val a = random.nextInt(100) + 1;
     val b = when(a) {
             100 -> "完美"
             60 -> "及格"
             else -> "不及格"
     }
    

• 每个分支都有返回值，最终返回值的类型是所有分支相同的返回类型，或者公共类型。
  • 分支如果只有一行代码，可以省略{}。

  •  fun b(a: Int) = when(a) {
             100 -> "完美"
             60 -> "及格"
             else -> "不及格"
     }
    

• when关键字的参数可以省略。

  •  fun b(a: Int) = when {
             a == 100 -> "完美"
             a == 60 -> "及格"
             else -> "不及格"
     }
    

• 表达式可以组合。

  •  fun b(is100: Boolean, a: Int) = when {
             is100-> "完美"
             a == 60 -> "及格"
             else -> "不及格"
     }
    

for循环

• kotlin中的while和do-while与Java中的一样。
• kotlin的for循环，可以声明i的类型：

  •  for (i: Int in 1..5) {
             println(i)
     }
     
     输出：
     1
     2
     3
     4
     5
    

• 范围表达式：
  • Range表达式是通过rangeTo函数实现的，通过“..”操作符与某种类型的对象组成，左闭右闭，[0, 10]。除了整数的基本类型之外，该类型需实现java.lang.Comparable接口。
    • 当对整数进行for循环时，还可以使用step函数来定义步长。

      •  for (i: Int in 1..5 step 2) {
         	println(i)
         }
         
         输出：
         1
         3
         5
        

    • 倒序：使用downTo方法实现。

      •  for (i: Int in 5 downTo 1 step 2) {
         	println(i)
         }
         
         输出：
         5
         3
         1
        

    • 半开区间：左闭右开，[0,10)，使用until函数。

      •  for (i in 1 until 5) {
         	println(i)
         }
         
         输出：
         1
         2
         3
         4
        

    • 打印字符a-z：

      •  for (i in 'a'..'z') {
         	println(i)
         }
        

• 用“in”来检查成员关系
  • 用来检查一个元素是否是一个区间或集合中的成员。

    •   val isIn = "a" in listOf("a", "b", "c")
        println("a是否在列表中：$isIn")
      
        输出：
        a是否在列表中：true
      

  • 在in前加上“!”

    •  val isIn = 1 !in listOf(1, 2, 3)
       println("1不在列表中：$isIn")
       
       输出：
       1不在列表中：false
      

  •  val isIn = "kot" in "abc".."xyz"
     println("isIn = $isIn")
     
     输出：
     isIn = true
    

  • 任何提供迭代器（iterator）的结构都可以用for语句进行迭代。
  • 还可以通过调用一个withIndex方法提供一个键值元组。

    •  for ((index, value) in arrayOf(100, 28, 73).withIndex()) {
           println("当前元素为：$value, 下标为：$index")
       }
       
       输出：
       当前元素为：100, 下标为：0
       当前元素为：28, 下标为：1
       当前元素为：73, 下标为：2
      

• 中缀表达式：
  • 如in step downTo until等方法都不是用点进行调用的，而是使用中缀表达式来调用。
  • 如to方法，他可以返回一个Pair：
    • public infix fun A.to(that: B): Pair = Pair(this, that)。
    • to这种形式定义的函数被称为中缀函数。
      • 由于to会返回Pair这种键值对的数据结构，因此常与map一起使用。
    • 使用：
      • A 中缀方法 B
    • 定义一个中缀函数必须满足：
      • ①该中缀函数必须是某个类型的扩展函数或成员方法。
      • ②该中缀函数只能有一个参数。
      • ③中缀函数的参数不能有你·默认值。
      • ④该参数不能是可变参数。
    • 自定义中缀函数：
      • 中缀函数除了可以使用中缀表达式那样调用，也可以像正常函数那样调用。

      •   class Dog {
          	infix fun show(name: String) {
          		println("name is $name")
          	}
          }
          
          //调用：
          val dog = Dog()
          dog show "wangwang"
          
          输出：
          name is wangwang