Kotlin学习历程四：基础语法

既然点进来看了，我也就不多赘述kotlin的历史，为什么要学kotlin那些东西了，直接开门见山，开始我们的学习。

我在参照这个文档来的http://www.kotlindoc.cn/GettingStarted/Basic-Syntax.html在中间穿插了一些自己的理解，不喜勿喷。

这里我用到了一个在线工具https://c.runoob.com/compile/2960，在此推荐给大家。

1.包名

包名不必和文件夹路径一致：源文件可以放在任意位置。

 

2.函数

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

只有一个表达式函数体以及一个自推导型的返回值

 

    fun printSum(a: Int, b: Int): Unit { 
        println("sum of $a and $b is ${a + b}") 
    }

返回一个没有意义的值

当然Unit的返回类型可以省略

 

3.局部变量

    fun main(args: Array<String>) {
      val a: Int = 1  // 立即初始化
      val b = 2   // 推导出Int型
      val c: Int  // 当没有初始化值时必须声明类型
      c = 3       // 赋值
      println("a = $a, b = $b, c = $c")
    }

最完整版本是：val（只读）/ var（可变）变量名：类型=初始值
可以直接按上边的规则，也可以不写类型让程序自己去推导类型，当没有初始化值时就必须声明类型。

 

4.注释

当行注释和块注释

块注释可以级联

 

5.字符串模板

    fun main(args: Array<String>) {
      var a = 1
      // 使用变量名作为模板:
      val s1 = "a is $a"

      a = 2
      // 使用表达式作为模板:
      val s2 = "${s1.replace("is", "was")}, but now is $a"
      println(s2)
    }

 

6.条件表达式

    fun maxOf(a: Int, b: Int): Int {
        if (a > b) {
            return a
        } else {
            return b
        }
    }

可把if当做表达式

    fun maxOf(a: Int, b: Int) = if (a > b) a else b

在 Kotlin 中，if 是表达式，比如它可以返回一个值。是除了condition ? then : else)之外的唯一一个三元表达式

    //传统用法
    var max = a
    if (a < b)
	    max = b

    //带 else 
    var max: Int
    if (a > b)
	    max = a
    else
	    max = b

    //作为表达式
    val max = if (a > b) a else b

if 分支可以作为块，最后一个表达是是该块的值：

    val max = if (a > b){
	print("Choose a")
	a
    }
    else{
	print("Choose b")
	b
    }

7.使用可空变量以及空值检查

当空值可能出现时应该明确指出该引用为空。

当str中不包含整数时返回空：

使用一个返回可空值的函数：

    fun parseInt(str: String): Int? {
      return str.toIntOrNull()
    }

    fun printProduct(arg1: String, arg2: String) {
      val x = parseInt(arg1)
      val y = parseInt(arg2)

      // 直接使用 x*y 会产生错误因为它们中有可能会有空值
      if (x != null && y != null) {
        // x 和 y 将会在空值检测后自动转换为非空值
        println(x * y)
      }
      else {
        println("either '$arg1' or '$arg2' is not a number")
      }    
    }

或者这样

    fun parseInt(str: String): Int? {
      return str.toIntOrNull()
    }

    fun printProduct(arg1: String, arg2: String) {
      val x = parseInt(arg1)
      val y = parseInt(arg2)

      // ...
      if (x == null) {
        println("Wrong number format in arg1: '${arg1}'")
        return
      }
      if (y == null) {
        println("Wrong number format in arg2: '${arg2}'")
        return
      }

      // x 和 y 将会在空值检测后自动转换为非空值
      println(x * y)
    }

 

8.使用值检查并自动转换

使用is操作符检查一个表达式是否是一个类型的实例。

如果对不可变的局部变量或属性进行过了类型检查，就没有必要强制转换：

    fun getStringLength(obj: Any): Int? {
      if (obj is String) {
        // obj 将会在这个分支中自动转换为 String 类型
        return obj.length
      }

      // obj 在种类检查外仍然是 Any 类型
      return null
    }

或者这样

    fun getStringLength(obj: Any): Int? {
      if (obj !is String) return null

      // obj 将会在这个分支中自动转换为 String 类型
      return obj.length
    }

还可以这样

    fun getStringLength(obj: Any): Int? {
    	// obj 将会在&&右边自动转换为 String 类型
      if (obj is String && obj.length > 0) {
        return obj.length
      }

      return null
    }

9.for循环

• Kotlin废除了Java中的for(初始值;条件；增减步长)这个规则。但是Kotlin中对于for循环语句新增了其他的规则，来满足刚提到的规则。
• for循环提供迭代器用来遍历任何东西
• for循环数组被编译为一个基于索引的循环，它不会创建一个迭代器对象

9.1 新增的规则，去满足for(初始值;条件;增减步长)这个规则

9.1.1 递增

关键字：until
范围：until[n,m) => 即大于等于n,小于m

  // 循环5次，且步长为1的递增
  for (i in 0 until 5){
    print("i => $i \t")
  }

  
  输出结果：
  i => 0  i => 1  i => 2  i => 3  i => 4

 

9.1.2 递减

关键字：downTo
范围：downTo[n,m] => 即小于等于n,大于等于m ,n > m

// 循环5次，且步长为1的递减
for (i in 15 downTo 11){
    print("i => $i \t")
}

输出结果：
i => 15     i => 14     i => 13     i => 12     i => 11     

9.1.3 符号（' .. '） 表示递增的循环的另外一种操作

使用符号( '..')
范围：..[n,m]=> 即大于等于n，小于等于m
和until的区别，一是简便性。二是范围的不同。

print("使用 符号`..`的打印结果\n")
for (i in 20 .. 25){
    print("i => $i \t")
}

println()

print("使用until的打印结果\n")
for (i in 20 until 25){
    print("i => $i \t")
}

输出结果：
使用 符号`..`的打印结果
i => 20     i => 21     i => 22     i => 23     i => 24     i => 25     
使用until的打印结果
i => 20     i => 21     i => 22     i => 23     i => 24 

9.1.4 设置步长

关键字：step

for (i in 10 until 16 step 2){
    print("i => $i \t")
}

输出结果：
i => 10     i => 12     i => 14 

9.2 迭代

for循环提供一个迭代器用来遍历任何东西。
for循环数组被编译为一个基于索引的循环，它不会创建一个迭代器对象

9.2.1 遍历字符串

for (i in "abcdefg"){
    print("i => $i \t")
}

输出结果为：
i => a  i => b  i => c  i => d  i => e  i => f  i => g  

9.2.2 遍历数组

var arrayListOne = arrayOf(10,20,30,40,50)
for (i in arrayListOne){
    print("i => $i \t")
}

输出结果为：
i => 10     i => 20     i => 30     i => 40     i => 50    

9.2.3 使用数组的indices属性遍历

var arrayListTwo = arrayOf(1,3,5,7,9)
for (i in arrayListTwo.indices){
    println("arrayListTwo[$i] => " + arrayListTwo[i])
}

输出结果为：
arrayListTwo[0] => 1
arrayListTwo[1] => 3
arrayListTwo[2] => 5
arrayListTwo[3] => 7
arrayListTwo[4] => 9

9.2.4 使用数组的withIndex()方法遍历

var arrayListTwo = arrayOf(1,3,5,7,9)
for ((index,value) in arrayListTwo.withIndex()){
    println("index => $index \t value => $value")
}

输出结果为：
index => 0   value => 1
index => 1   value => 3
index => 2   value => 5
index => 3   value => 7
index => 4   value => 9

9.2.5 使用列表或数组的扩展函数遍历

数组或列表有一个成员或扩展函数iterator()实现了Iterator<T>接口，且该接口提供了next()与hasNext()两个成员或扩展函数
其一般和while循环一起使用

1.可以查看Array.kt这个类。可以看见其中的iterator()函数，而这个函数实现了Iterator接口。

 /**
   *   Creates an iterator for iterating over the elements of the array.
   */
 public operator fun iterator(): Iterator<T>

2.查看Iterator.kt这个接口类，这个接口提供了hasNext()函数和next()函数。

 public interface Iterator<out T> {

 /**
   * Returns the next element in the iteration.
   */
 public operator fun next(): T

 /**
   * Returns `true` if the iteration has more elements.
   */
 public operator fun hasNext(): Boolean
 }

var arrayListThree = arrayOf(2,'a',3,false,9)
var iterator: Iterator<Any> = arrayListThree.iterator()

while (iterator.hasNext()){
    println(iterator.next())
}

输出结果为：
2
a
3
false
9

 

 

10.while循环

其同Java中的while循环一样。在此不做累述。
定义格式：

while(exp){ 其中exp为表达式
...
}

11.when表达式

取代了C风格语言的switch。

when会对所有的分支进行检查直到有一个条件满足。when 可以用做表达式或声明。如果用作表达式的话，那么满足条件的分支就是总表达式。如果用做声明，那么分支的的的值会被忽略。(像 if 表达式一样，每个分支是一个语句块，而且它的值就是最后一个表达式的值)

在其它分支都不匹配的时候默认匹配 else 分支。如果把 when 做为表达式的话 else 分支是强制的，除非编译器可以提供所有覆盖所有可能的分支条件。

when语句不仅可以替代掉switch语句，而且比switch语句更加强大

    fun describe(obj: Any): String =
    when (obj) {
      1          -> "One"
      "Hello"    -> "Greeting"
      is Long    -> "Long"
      !is String -> "Not a string"
      else       -> "Unknown"
    }

如果有分支可以用同样的方式处理的话，分支条件可以连在一起：

    when (x) {
	    0,1 -> print("x == 0 or x == 1")
	    else -> print("otherwise")
    }

可以用任意表达式作为分支的条件

    when (x) {
	    parseInt(s) -> print("s encode x")
	    else -> print("s does not encode x")
    }

甚至可以用 in 或者 !in 检查值是否值在一个集合中：

    when (x) {
	    in 1..10 -> print("x is in the range")
    	in validNumbers -> print("x is valid")
	    !in 10..20 -> print("x is outside the range")
	    else -> print("none of the above")
    }

也可以用 is 或者 !is 来判断值是否是某个类型。注意，由于 smart casts ，你可以不用另外的检查就可以使用相应的属性或方法。

    val hasPrefix = when (x) {
    	is String -> x.startsWith("prefix")
    	else -> false
    }

when 也可以用来代替 if-else if 。如果没有任何参数提供，那么分支的条件就是简单的布尔表达式，当条件为真时执行相应的分支：

    when {
    	x.isOdd() -> print("x is odd")
    	x.isEven() -> print("x is even")
    	else -> print("x is funny")
    }

12.ranges

使用in操作符检查数值是否在某个范围内

检查数值在范围外 !in

在范围内迭代

或者使用步进

13.集合

对一个集合进行迭代（for循环）

使用 in 操作符检查集合中是否包含某个对象（when）

使用lambda表达式过滤和映射集合

基础语法部分就到这里，感觉有帮助的，还请关注我的博客，持续更新ing。