Kotlin 基础学习笔记（二）

1. 函数 和 函数表达式

1.1 函数

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

==>如果函数语句只有一句，变形：

fun add(x: Int, y: Int): Int = x + y

1.2 函数表达式

==>将一个函数表达式赋值给一个变量，然后调用：

	// 将一个函数表达式 赋 给了i
	var i = { x: Int, y: Int -> x + y }

	// 调用声明好的 函数表达式
	var ret = i(3 , 5)

==>另外一种变形：

	var j:(Int, Int) -> Int = {x, y -> x + y}

	// 调用声明好的函数
	var ret3 = j(3, 5)

2. 默认参数 和 具名参数

	// 声明一个常量
	val pi = 3.14159f

	fun main(args: Array<String>) {

		// 正常调用
	    var line = 获取园的周长(pi, 4.0f)

	    var line2 = 获取园的周长2(pi, 2.0f)

	    println("line = ${line}, line2 = ${line2}")

	    // 具名参数，第一个参数默认
	    var line3 = 获取园的周长2(半径 = 2.0f)
	    println("line3 = ${line3}")
	}

	// (PI为形参)，指定第一个参数默认为pi
	fun 获取园的周长(PI: Float = pi, 直径: Float): Float {
	    return PI * 直径
	}
	// 指定第一个参数默认为pi
	fun 获取园的周长2(PI: Float = pi, 半径: Float): Float {
	    return PI * 半径 * 2
	}

3. 字符串 和 数字 之间的转换

	var a = "12"
	var b = 12

	a = b.toStirng()

	b = a.toInt() 

4. 人机交互

    var num1Str = readLine() // readLine 读取的都是字符串

    var num1 = num1Str?.toInt()
    var num2 = num1Str!!.toInt()

5. 异常处理

try {} cach (e: Exception) {}

6. Kotlin 递归 和 尾递归优化

6.1 递归

		fun main(args:Array<String>) {
		    // 计算阶乘
		    var i = 5
		    println(fact(i))
		}

		fun fact(num: Int) : Int{
		    if (num == 1) {
		        return 1
		    } else {
		        return num * fact(num -1)
		    }
		}

如果计算30的阶乘，就会发现结果为负数，已经超过Int类型的最大范围，也可能超过Long类型的最大范围，有一个新的类型：BigInteger 类型  （Long类型的数字超出范围可用）

		// 1==BigInteger.ONE 
		fun main(args: Array<String>) {
		    // 计算阶乘
		    var i = BigInteger("100")
		    println(fact(i))
		}

		fun fact(num: BigInteger): BigInteger {
		    if (num == BigInteger.ONE) {
		        return BigInteger.ONE
		    } else {
		        return num * fact(num - BigInteger.ONE)
		    }
		}

6.2 尾递归优化

为什么需要优化？

	fun main(args: Array<String>) {
	    // 累加操作
	    println(ollAdd(100000))
	}

	fun ollAdd(num: Int): Int {
	    if (num == 1) {
	        return 1
	    } else {
	        return num + ollAdd(num - 1)
	    }
	}

运行上述代码会报StackOverflowError， 因为 递归函数的层数过多会造成java 堆栈溢出。

优化之后：

fun main(args: Array<String>) {
    // 累加操作
    var result = 0
    println(ollAdd(100000, result))
}

tailrec fun ollAdd(num: Int, result: Int): Int {
    if (num == 0) {
        return result
    } else {
        return ollAdd(num - 1, result + num)
    }
}

使用了 tailrec 关键字，并且使用该关键字之后，要求函数返回值是它函数本身，这一点要注意。