本文参考官方文档：http://kotlinlang.org/docs/kotlin-docs.pdf
本文参考博客:《灰蓝时光》
定义包的规范应位于源文件的顶部
package my.demo
import java.awt.Rectangle
import java.util.*
Kotlin 中的注释
// --- 单行注释---
/* --- 多行注释 ---*/
定义函数
// 带有两个Int参数、返回Int的函数：
fun sum(a:Int, b:Int):Int{
return a + b // 返回的是Int
}
// 主函数入口，程序执行：定义函数
fun main(args:Array<String>){
print("sum of 3 and 5 is ") // print 打印不换行
println(sum(3,5)) // println 打印换行
}
// 将表达式作为函数体、返回值类型自动推断的函数：
fun sum(a:Int, b:Int) = a + b
fun main(args:Array<String>){
println("sum of 19 and 23 is ${sum(19, 23)}") // ${} 占位
}
// 函数返回无意义的值
fun print_sum(a:Int, b:Int): Unit{
println("sum of $a and $b is ${a + b}") // $ 占位
}
fun main (args: Array<String>){
print_sum(-1, 8)
}
// Unit 返回类型可以省略：
fun printSum(a:Int, b:Int){
println("sum of $a and $b is ${a + b}")
}
fun main(args: Array<String>){
printSum(-1, 8)
}
定义变量
// 一次赋值--只读--局部变量
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")
}
// 可变变量
fun main(args: Array<String>){
var x = 5 // 自动推断出“Int”类型
x += 1
println("x = $x")
}
// 顶层变量：
val PI = 3.14
var x = 0
fun incrementX(){
x += 1
}
fun main(args: Array<String>){
println("x = $x, PI = $PI")
incrementX()
println("incrementX()")
println("x = $x, PI = $PI")
}
/*变量还可以作为属性和字段使用 */
使用字符串模板
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)
}
使用条件表达式
fun maxOf(a:Int, b:Int):Int{
return if (a > b){
a
}else{
b
}
}
fun main(args:Array<String>){
println("max of 0 and 42 is ${maxOf(0, 42)}")
}
// 使用if作为表达式：
fun moxOf(a:Int, b:Int) = if (a > b) a else b
fun main(args: Array<String>){
println("maxOf of 0 and 42 is ${maxOf(0, 42)}")
}
使用可空值及null检测
// 当变量的值可以为null的时候，必须在声明处的类型后添加? 用来标识该应用可为空。
fun parseInt(str:String):Int?{
// ......
}
// 使用返回可空值的函数
fun parseInt(string: String):Int?{
return string.toIntOrNull()
fun printProduct(arg1:String, arg2:String){
val x = parseInt(arg1)
val y = parseInt(arg2)
// 直接使用 x * y 会导致编译器错误，因为他们可能为null
if (x == null) {
println("Wrong number format in arg1:'$arg1'")
return
}
if (y == null){
println("Wrong number format in arg2: '$arg2'")
return
}
}
// 在空检测后，x 和 y自动转换为非空值（non-nullable）
println(x * y)
}
fun main(args:Array<String>){
printProduct("6", "7")
printProduct("a", "7")
printProduct("6", "b")
printProduct("a", "b")
}
使用类型检测及自动类型转换
/* is 运算符检测一个表达式是否某类型的一个实例。
* 如果一个不可变的局部变量或属性已经判断出为某类型
* 那么检测后的分支中可以直接当作该类型使用，无需显示转换*/
fun getStringLength(obj: Any):Int?{
if (obj is String) {
// 'obj'在条件分支内自动转换成'String'
return obj.length
}
// 在离开类型检测分支后，'obj'仍然是'Any'类型
return null
}
fun main(args:Array<String>){
fun printLength(obj: Any){
println("'$obj' string length is ${getStringLength(obj) ?: " ... err, not a string"}")
}
printLength("Incomprehensibilities")
printLength(1000)
printLength(listOf(Any()))
}
使用for循环
fun main(args:Array<String>){
val items = listOf("apple", "banana", "kiwi")
for (item in items){
println(item)
}
}
使用while表达式
fun main(args: Array<String>){
val items = listOf("apple", "banana", "kiwi")
var index = 0
while (index < items.size){
println("item at $index is ${items[index]}")
index++
}
}
使用when表达式
fun describe(obj:Any):String =
when(obj){
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long"
!is String -> "Not a string"
else -> "Unknown"
}
fun main(args:Array<String>){
println(describe(1))
println(describe("Hello"))
println(describe(1000L))
println(describe(2))
println(describe("other"))
}
使用区间range
// 使用 in 运算符来检测某个数字是否在指定区间内：
fun main(args:Array<String>){
val x = 10
val y = 9
if (x in 1..y+1){
println("fits in range")
}
}
// 检测某个数字是否在指定区间外：
fun main(args:Array<String>){
val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex){
println("-1 is out of range")
}
if (list.size !in list.indices){
println("list size is out of valid list indices range too")
}
}
// 区间迭代
fun main(args:Array<String>){
for (x in 1..5){
print(x)
}
}
// 数列迭代
fun main(args:Array<String>){
for (x in 2..10 step 2){
print(x)
}
}
使用集合
// 对集合进行迭代
fun main(args:Array<String>){
val items = listOf("apple", "banana", "kiwi")
for (item in items){
println(item)
}
}
// 使用 in 运算符来判断集合内是否包含某实例：
fun main(args:Array<String>){
val items = listOf("apple", "banana", "kiwi")
when{
"orange" in items -> println("juicy")
"apple" in items -> println("apple is fine too")
}
}
// 使用lambda表达式来过滤（filter）和映射（map）集合：
fun main(args:Array<String>){
val fruits = listOf("banana", "avocado", "apple", "kiwi")
fruits
.filter { it.startsWith("a") }
.sortedBy { it }
.map { it.toUpperCase() } // 字母全部转换成大写
.forEach { println(it) }
}
创建基本类及其实例：
// 抽象类
abstract class Shape (private val sides : List <Double> ) {
val perimeter : Double get() = sides.sum()
abstract fun calculateArea():Double
}
interface RectangleProperties{
val isSquare:Boolean
}
// 创建矩形类
class Rectangle(
var height:Double,
var length: Double
):Shape(listOf(height, length, height, length)), RectangleProperties{
override val isSquare: Boolean
get() = length == height
override fun calculateArea(): Double = height * length
}
// 创建三角形类
class Triangle(
private var sideA:Double,
private var sideB:Double,
private var sideC:Double
):Shape(listOf(sideA, sideB, sideC)){
override fun calculateArea(): Double {
val s = perimeter / 2
return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC))
}
}
fun main(args:Array<String>){
val rectangle = Rectangle(5.0,2.0) // 不需要“new”关键字
val triangle = Triangle(3.0,4.0,5.0)
println("Area of rectangle is ${rectangle.calculateArea()}, its perimeter is ${rectangle.perimeter}")
println("Area of triangle is ${triangle.calculateArea()}, its perimeter is ${triangle.perimeter}")
}
