# 基本语法
## 定义包
包应该在源文件的顶部指定：
``` kotlin
package my.demo
import java.util.*
// ...
```
无需匹配对应的目录和包：源文件可以放置在文件系统中任何地方。
查看 [包定义](../basics/packages.md)。
## 定义函数
有两个`Int`参数并返回`Int`类型的函数：
``` kotlin
fun sum(a: Int, b: Int): Int {
return a + b
}
```
只有一个表达式函数体、推断返回类型的函数：
``` kotlin
fun sum(a: Int, b: Int) = a + b
```
不返回具体值的函数：
``` kotlin
fun printSum(a: Int, b: Int): Unit {
print(a + b)
}
```
`Unit` 返回类型可以省略:
``` kotlin
fun printSum(a: Int, b: Int) {
print(a + b)
}
```
查看 [函数](../functions-and-lambdas/functions.md).
## 定义本地变量
一次性分配（只读）的本地变量：
``` kotlin
val a: Int = 1
val b = 1 // `Int` 类型靠推断得出
val c: Int // 未初始化时必须指定类型
c = 1 // 明确地分配
```
可变的变量值:
``` kotlin
var x = 5 // `Int` 类型靠推断得出
x += 1
```
参阅 [属性和字段](properties.html).
## 注释
与 Java 和 JavaScript 类似，Kotlin 支持行尾和块注释。
``` kotlin
// 这是一个行尾注释
/* 这是一个
多行块注释*/
```
与 Java 不同的是，在 Kotlin 中块注释可以嵌套。
查看 [Kotlin 代码文档](kotlin-doc.html) 了角注释语法。
## 使用字符串模板
``` kotlin
fun main(args: Array<String>) {
if (args.size == 0) return
print("First argument: ${args[0]}")
}
```
查看 [String 模板](basic-types.html#string-templates).
## 使用条件表达式
``` kotlin
fun max(a: Int, b: Int): Int {
if (a > b)
return a
else
return b
}
```
像表达式一样使用 `if` 句式:
``` kotlin
fun max(a: Int, b: Int) = if (a > b) a else b
```
查看 [if 表达式](control-flow.html#if-expression).
## 使用可空的值并检测 `null`
当值可空时必须明确地加以标记。
如果 `str` 不是一个表示整数的字符串则返回 `null` ：
``` kotlin
fun parseInt(str: String): Int? {
// ...
}
```
用一个函数返回可空值：
``` kotlin
fun main(args: Array<String>) {
if (args.size < 2) {
print("Two integers expected")
return
}
val x = parseInt(args[0])
val y = parseInt(args[1])
// 因为有可能保存 `null` ，所以使用 `x * y` 会产生错误。
if (x != null && y != null) {
// 在空值检查后x 和 y 自动转换成不可空
print(x * y)
}
}
```
或者写成这样：
``` kotlin
// ...
if (x == null) {
print("${args[0]} 数字格式错误")
return
}
if (y == null) {
print("${args[1]} 数字格式错误")
return
}
// x 和 y 会在空值检查后自动转换为不可空
print(x * y)
```
查看 [Null 安全](null-safety.html).
## 使用类型检查与自动转换
`is` 运算符检查一个表达式是否是另一个类型的实例。
如果一个不可变的本地变量或属性被检测为一个特定的类型，则不需要明确地转换它：
``` kotlin
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 在这个作用域中 obj 会自动转换为 String
return obj.length
}
// 在类型检查的作用域之外， obj 的类型仍然为 Any
branch
return null
}
```
或者是：
``` kotlin
fun getStringLength(obj: Any): Int? {
if (obj !is String)
return null
// 在这个作用域中 obj 会自动转换为 String
return obj.length
}
```
甚至可以这样写：
``` kotlin
fun getStringLength(obj: Any): Int? {
// 在 && 运算符右边 obj 会自动转换为 String
if (obj is String && obj.length > 0)
return obj.length
return null
}
```
查看 [类](classes.html) 和 [类型转换](typecasts.html).
## 使用 `for` 循环
``` kotlin
fun main(args: Array<String>) {
for (arg in args)
print(arg)
}
```
或者：
``` kotlin
for (i in args.indices)
print(args[i])
```
查看 [for 循环](control-flow.html#for-loops).
## 使用 `while` 循环
``` kotlin
fun main(args: Array<String>) {
var i = 0
while (i < args.size)
print(args[i++])
}
```
查看 [while 循环](control-flow.html#while-loops).
## 使用 `when` 表达式
``` kotlin
fun cases(obj: Any) {
when (obj) {
1 -> print("One")
"Hello" -> print("Greeting")
is Long -> print("Long")
!is String -> print("Not a string")
else -> print("Unknown")
}
}
```
查看 [when 表达式](control-flow.html#when-expression).
## 使用“范围”
要检查某个数字是否在某个范围内，使用 `in` 操作符：
``` kotlin
if (x in 1..y-1)
print("OK")
```
检查某个数字是否在某个范围之外：
``` kotlin
if (x !in 0..array.lastIndex)
print("Out")
```
范围迭代：
``` kotlin
for (x in 1..5)
print(x)
```
查看 [范围](ranges.html).
## 使用集合
迭代集合：
``` kotlin
for (name in names)
println(name)
```
要检查某个集合是否包含某个对象，使用 `in` 操作符：
``` kotlin
if (text in names) // names.contains(text) is called
print("Yes")
```
使用 lambda 表达式来过滤和映射集合：
``` kotlin
names
.filter { it.startsWith("A") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { print(it) }
```
查看 [高阶函数和 Lambda](lambdas.html).
