上一篇文章主要总结了一些Kotlin的基础知识，包括类，对象，数组，区间等（Kotlin基础知识（二）类，对象，数组，区间），接下来开始接触Kotlin语法方面的东西，这也是能开始领略Kotlin“好玩”的地方了。来，上我的车吧。
常量
在Kotlin中，常量的命名使用val修饰，val相当于value，类似Java中的final，不可以重复赋值。不管是哪种语言，使用常量很多情况下能减少我们犯错的可能，在Java 中使用final修饰不需要被重复赋值的变量是一个很好的习惯，这与C++中使用const的道理是一样的。
当然，我们在Java中命名变量，其实是很麻烦的，尤其是final变量，比如：
public static final String NAME = "xiaoming"
又是变量名，又是类型，又是修饰符，命名一个两个还好，但我们比较大型的工程中，往往一个功能模块就需要命名n个常量或者变量，而在Kotlin中，没有这么麻烦。，比如：
val NAME:String = "xiaoming"
可以再简化：
val NAME = "xiaoming"
这就类型推导：
编译器可以推导变量或者常量的类型，简化了代码：
val name = "小明" // 推导出String类型
var int = 5 //推导出int 类型
小Tips：利用反射等手段是可以修改val值的
变量
在Kotlin中，使用var来修饰变量，关于变量的知识，跟Java等其他语言没什么不同，可以重复赋值。
var相当于variable
例子：
var x = "xixi" //这里定义一个x变量
x = "haha" //重新给x赋值
函数
函数，是以特定功能组织起来的代码块，
在Kotlin中，函数的写法：
fun 【函数名】(【参数列表】):【返回值类型】{【函数体】}
或者：
fun 【函数名】（【参数列表】） = 【表达式】
例子：
fun sum(param1:Int,param2:Int):Int{
return param1 + param2
}
以上边为例，fun表明这是一个函数，sum是函数名，(param1:Int,param2:Int)是参数列表，Int表明了返回值类型
而{}中的内容则是函数体
或者
fun sayHi(name:String) = {
println("hi,$name")
}
其中，由于没有返回值，所以返回值省略不写。
Tips：没有返回值的返回值类型是Unit
函数的调用跟Java一样，比如上文，执行sum(1,2)，返回3
当然，Kotlin是一门有极大优越性的语言，怎么更加简洁的写这个函数呢？可以用 ——>
匿名函数
在Kotlin中，匿名函数写法是：
fun(【参数列表】)...
例子：
val nemoSum = fun(arg1:Int,arg2:Int):Int{
return arg1 + arg2
}
注意：一定需要一个变量来接收这个函数，要不这个函数名字都没有，连在哪里都不知道，那我怎么在茫茫人海中找到并调用他呢？（这个有点像C语言中的函数指针）
匿名函数的调用，跟普通函数类似：
上文中，执行 nemoSum(1,3) 输出4。
编写普通函数和匿名函数，有什么注意事项呢？
一、功能单一
二、函数名要做到顾名思义
三、参数不要太多
当然，这个例子，还没办法展示匿名函数的优越之处。但在以后的文章中，我们可以一直体会到。
为啥匿名函数这么牛叉呢？你们看电视剧，电影，小说，无名氏是不是一直都最吊？
下面，我们立刻来体会匿名函数的其中一点厉害之处：
Lambda表达式
Lambda表达式其实也是匿名函数，写法是：
{【参数列表】} ->【函数体，最后一行为返回值】
比如： val sum = {arg1:Int,arg2:Int -> arg1 + arg2},
Lambda表达式的最后一行是返回的数据，例子：
val lambdaSum = {param1:Int,param2:Int ->
println("我执行了但我没返回哦")
param1 + param2
}
执行这个Lambda表达式
println(lambdaSum(3,5))
输出结果：
我执行了但我没返回哦
8
从上边的例子可以看到，Lambda表达式使用（）进行调用，等价于invoke()，
比如上文 lambda(3,5)相当于lambda.invoke(3,5)
invoke实际上是运算符重载的方法，关于这个知识点，后边文章讲解运算符的时候会说明。
关于Lambda表达式的语法，我们以下边的例子来说明：
我们有三头猪，现在需要找出其中最重的一头(#.#)
假如不使用Lambda表达式，是这样的：
data class 猪(val 编号:String,val weight:Int)
val pigs = listOf(猪("9527",50),
猪("007",48),
猪("009",45))
fun main(args: Array<String>) {
var pig:猪 ?= null
var maxWeight = 0;
pigs.forEach{
if (it.weight > maxWeight){
pig = it;
maxWeight = it.weight
}
}
println(pig)
}
输出结果：
猪(编号=9527, weight=50)
抛去数据源不论，找猪的过程还是需要不少代码的，但使用Lambda可以简化：
println(pigs.maxBy { it.weight })
输出结果一致。
maxby函数可以在任何集合上调用，且只需要一个实参：一个函数，指定比较哪个值来找到最大元素。
maxby函数是这样的：
/**
* Returns the first element yielding the largest value of the given function or `null` if there are no elements.
*/
public inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T? {
val iterator = iterator()
if (!iterator.hasNext()) return null
var maxElem = iterator.next()
var maxValue = selector(maxElem)
while (iterator.hasNext()) {
val e = iterator.next()
val v = selector(e)
if (maxValue < v) {
maxElem = e
maxValue = v
}
}
return maxElem
}
他接收一个Lambda表达式作为参数，而{it.weight}就是实现此种逻辑的Lambda。它接收集合中的元素作为实参（it）并返回用来比较的值（weight）。
上面引用这个函数的完整代码应该是
pigs.maxBy({ p:猪 -> p.weight })
如果Lambda表达式是函数的最后一个实参，那么可以把（）放到外面：
pigs.maxBy(){ p:猪 -> p.weight }
若Lambda是唯一参数，还可以把()去掉：
pigs.maxBy{ p:猪 -> p.weight }
简化写法与常规写法语义一致，简化写法更易读。
除此之外，Lambda也能作为命名实参（将它看做一个表达式，很容易理解）
比如我们把所有猪的编号链接起来：
val nums = pigs.joinToString(separator = " ",transform = {p:猪 ->p.编号})
println(nums)
输出 9527 007 009
只有一个实参，所以可以放在括号外
val nums =pigs.joinToString(separator = " "){p:猪 -> p.编号}
这样写看起来简洁，实际上除作者外的人很难立刻就知道Lambda在哪里运用了
更进一步，类型推导可以帮助我们移除参数类型：
//显示的写出参数推导类型
pigs.maxBy { p:猪 -> p.weight }
//推导出参数类型
pigs.maxBy { p ->p.weight }
再进一步还能使用默认参数：
//使用默认参数名称
pigs.maxBy { it.weight} //"it"是自动生成的参数名称
默认参数只会在实参名称没有显示的指定时候才会生成，能大大缩短简化代码，但是不应该滥用，尤其是在lambda嵌套情况下，最好显示声明lambda参数。否则很难搞清it引用的到底是哪个值，本末倒置。
如果我们使用变量来存储Lambda，那编译器就无法根据上下文来推导参数，必须使用指定参数：
//变量存储lambda，必须显示指定参数类型
val weight = { p: 猪 -> p.weight }
println(pigs.maxBy(weight))
Lambda在Kotlin中的重要性毋庸置疑，涉及到的知识点是在太多，在后面的文章中会有更多说明，之后应该还会有专门的文章来讲解Lambda。
这一篇文章主要阐释了Kotlin中的常量，变量，函数以及Lambda表达式，涵盖的知识面其实比较宽，但篇幅所限，只能浅尝辄止。有疑问的同学欢迎留言一起探讨。
下一篇文章将继续讲解语法有关的部分，包括类成员，循环语句，表达式，运算符等，欢迎关注（点我继续修炼）
。
