Hello World！
fun main(args: Array<String>) {
println("Hello World")
}Kotlin的基础语法
Kotlin文件以.kt为结尾
包声明
代码文件的开头一般为包开头
package com.runoob.main
import java.util.*
fun test() {}
class Runoob {}kotlin源文件不需要相匹配的目录和包，源文件可以放在任何文件目录。
以上例中 test() 的全名是 com.runoob.main.test、Runoob 的全名是 com.runoob.main.Runoob。
如果没有指定包，默认为 default 包。
默认导入
有多个包会默认导入到每个 Kotlin 文件中：
- kotlin.*
- kotlin.annotation.*
- kotlin.collections.*
- kotlin.comparisons.*
- kotlin.io.*
- kotlin.ranges.*
- kotlin.sequences.*
- kotlin.text.*
函数定义
函数定义使用关键字 fun，参数格式为：参数 : 类型
fun sum(a: Int, b: Int): Int { // Int 参数，返回值 Int
return a + b
}表达式作为函数体，返回值自动判断。
fun sum(a: Int, b: Int) = a +b
public fun sum(a: Int, b: Int): Int = a +b //public 方法要明确返回类型无返回值类型，类似java的void
fun sum(a: Int, b: Int):Unit {//Unit代表无返回值，也可以省略
println("$a + $b = ${a+b}")
}
//对于public方法也适用，无返回值，Unit可以省略
fun sum(a: Int, b: Int) {
println("$a + $b = ${a+b}")
}可变长参数函数
可变长参数用vararg表示
fun main(args: Array<String>) {
printSth("a","b","c","d")//打印a,b,c,d
}
fun printSth(vararg vars: String): Unit {
for (v in vars) {
println(v)
}
}lambda(匿名函数)
lambda表达式使用
fun main(args: Array<String>) {
val sumLambda:(Int,Int) -> Int = {x,y -> x+y}
val result = sumLambda(1,1)
println(result) // print 2
}定义常量与变量
可变变量定义var
var <变量名> : <类型> = <初始值>
var a : Int = 1不可变变量定义：val
关键字，只能赋值一次的变量(类似Java中final修饰的变量)
val <变量名> : <类型> = <初始值>
val a : Int = 1常量与变量都可以没有初始化值,但是在引用前必须初始化
编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。
fun main(args: Array<String>) {
val a: Int = 1
val b = 1 //系统自动判断值为Int
val c : Int //如果在声明时不初始化，则必须要提供类型！
c = 1 //明确赋值
var x = 5; //系统判断为Int
x ++; //变量可修改
println("a = $a b = $b c = $c x = $x")
}注释
// 这是一个单行注释
/* 这是一个多行的
块注释。 */与 Java 不同, Kotlin 中的块注释允许嵌套。
字符串模板
fun main(args: Array<String>) {
val name: String = "qfxl"
println("my name is $name")
changeName(name)
}
fun changeName(name: String):Unit {
println("my name is $name but was changed to ${name.replace("q","a")}")
}
Log:
my name is qfxl
my name is qfxl but was changed to afxlNULL检查机制
Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理
fun main(args: Array<String>) {
//表示name可为空
var age : String ? = "100"
//如果age为空抛出空指针异常
var ageInt = age!!.toInt()
//如果age为空直接返回null
var ageNull = age?.toInt()
//如果age为空，则返回-1
var ageIntIfNull = age?.toInt() ?: -1
}当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null
fun main(args: Array<String>) {
val result = parseInt("a")
println(result)
}
fun parseInt(str: String): Int ? {//如果要返回null则要标记可为null
if (str in "0".."9") {
return str.toInt()
}
return null
}以下实例演示如何使用一个返回值可为 null 的函数:
fun main(args: Array<String>) {
if (args.size < 2) {
println("需要两个参数")
return
}
val a = parseInt(args[0])
val b = parseInt(args[1])
// 直接使用 `a + b` 会导致错误, 因为它们可能为 null.
if (a != null && b != null) {
// 在进行过 null 值检查之后, a 和 b 的类型会被自动转换为非 null 变量
println("$a + $b = ${a + b}")
}
}
fun parseInt(str: String): Int ? {
if (str in "0".."9") {
return str.toInt()
}
return null
}类型检测和类型自动转换
可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。
fun main(args: Array<String>) {
val length = getStringLength("qfxl")
println("length is $length")// print length is 4
}
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
}
//这里自动转换成String类型
return obj.length
}设置还可以
fun getStringLength(obj: Any): Int ? {
//&&后面的obj已经转换成String类型
if (obj is String && obj.length > 0) {
return obj.length
}
return null
}区间
区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。
区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:
fun main(args: Array<String>) {
for (i in 1..4) println(i) //输出1,2,3,4
for (i in 4..1) println(i) //什么都不输出
for (i in 4 downTo 1) println(i) //输出4,3,2,1
for (i in 4 downTo 1 step 2) println(i) //输出4,2
for (i in 1 until 4) println(i) //输出1,2,3
}