//这是单行注释 // /* 这是多行注释 */ // 这和Java的 "package" 差不多. package com.learnxinyminutes.kotlin
/* Kotlin程序入口函数是名为"main". 这个函数的入参是包含命令行参数的数组 */ fun main(args: Array<String>) { /* 声明值是使用"var" 或 "val". "val"是一旦分配值后就不能变,不变量,相反"vars" 是声明变量 */ val fooVal = 10 // 之后就不能再给fooVal分配其他值了 var fooVar = 10 fooVar = 20 // fooVar是变量,能够再次分配值
/* 大多数情况, Kotlin能够决定一个变量的类型是什么。 这样我们不必显式明确每次去指定变量类型了。 我们可以通过如下方式明确定义变量类型: */ val foo : Int = 7
/* Kotlin包含两种类型的字符串:与Java字符串相同的escaped strings和新的raw strings, escaped strings中的换行符是\n字符串和Java中一样定义, 反斜杠是换行符 */ val fooString = "My String Is Here!" val barString = "Printing on a new line?\nNo Problem!" val bazString = "Do you want to add a tab?\tNo Problem!" println(fooString) println(barString) println(bazString)
/* 行字符串(raw strings)由三个引号分隔 ("""). 顾名思义能包含新的一行和其他任何字符。 下面是给fooRawString赋值的是一个函数helloWorld,直至第四行的三个引号才表示赋值结束 */ val fooRawString = """ fun helloWorld(val name : String) { println("Hello, world!") } """ println(fooRawString)
/* 字符串能保护模板表达式 模板表达式是以美元符号开始($). */ val fooTemplateString = "$fooString has ${fooString.length} characters" println(fooTemplateString)
/* 对于一个变量是空必须明确指定其是nullable. 变量可以在其类型后面追加问号?指定其是nullable, 然后使用?.操作符访问这个nullable的变量 也可以使用?: 操作符在其为null时为其分配一种值。 */ var fooNullable: String? = "abc" println(fooNullable?.length) // => 3 println(fooNullable?.length ?: -1) // => 3 fooNullable = null println(fooNullable?.length) // => null println(fooNullable?.length ?: -1) // => -1
/* 函数是使用"fun" 定义 函数参数在函数名后面的括号中指定。函数参数可以有默认值。如果需要,函数返回类型在参数之后指定。 */ fun hello(name: String = "world"): String { return "Hello, $name!" } println(hello("foo")) // => Hello, foo! println(hello(name = "bar")) // => Hello, bar! println(hello()) // => Hello, world!
/* 一个函数参数可以使用"vararg" 标注, 能够让许多参数传递进入函数。 */ fun varargExample(vararg names: Int) { println("Argument has ${names.size} elements") } varargExample() // => Argument has 0 elements varargExample(1) // => Argument has 1 elements varargExample(1, 2, 3) // => Argument has 3 elements
/* 当一个函数由单个表达式组成时,那么这个卷括号可以被省略。函数内容体是在等于号=之后指定。 */ fun odd(x: Int): Boolean = x % 2 == 1 println(odd(6)) // => false println(odd(7)) // => true
// 如果返回类型能被推断,我们就不必指定了。 fun even(x: Int) = x % 2 == 0 println(even(6)) // => true println(even(7)) // => false
// 函数能用函数作为参数,返回页首函数。 fun not(f: (Int) -> Boolean): (Int) -> Boolean { return {n -> !f.invoke(n)} } // Named函数能使用 :: 作为参数指定. val notOdd = not(::odd) val notEven = not(::even) // Lambda 表达式能指定为参数 val notZero = not {n -> n == 0} /* 如果一个lambda仅有一个参数,它的声明可以被忽视(随着 ->一起). 单个参数名将是"it". */ val notPositive = not {it > 0} for (i in 0..4) { println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") }
// "class" 是用来声明类 class ExampleClass(val x: Int) { fun memberFunction(y: Int): Int { return x + y }
infix fun infixMemberFunction(y: Int): Int { return x * y } } /* 创建新的实例使用构造器 Kotlin没有 "new" */ val fooExampleClass = ExampleClass(7) // 成员函数能使用点符号调用 println(fooExampleClass.memberFunction(4)) // => 11
/* 如果一个函数被"infix"标注,能使用infix notation调用 下面fooExampleClass infixMemberFunction 4等同于 fooExampleClass.memberFunction(4) */ println(fooExampleClass infixMemberFunction 4) // => 28
/* 数据类是创建只包含数据的精确方式. "hashCode"/"equals" 和 "toString" 等方法会自动产生。 */ data class DataClassExample (val x: Int, val y: Int, val z: Int) val fooData = DataClassExample(1, 2, 4) println(fooData) // => DataClassExample(x=1, y=2, z=4)
// 数据类没有 "copy" 函数 val fooCopy = fooData.copy(y = 100) println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
// 对象能被解构入多个变量。 val (a, b, c) = fooCopy println("$a $b $c") // => 1 100 4
// 解构 "for" 循环 for ((a, b, c) in listOf(fooData)) { println("$a $b $c") // => 1 100 4 }
val mapData = mapOf("a" to 1, "b" to 2) // Map.Entry 也能解构 for ((key, value) in mapData) { println("$key -> $value") }
// "with" 函数类似JavaScript "with" 语句. data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) val fooMutableData = MutableDataClassExample(7, 4, 9) with (fooMutableData) { x -= 2 y += 2 z-- } println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
/* 使用 "listOf" 函数创建集合 集合是不可变的,元素不能增加和移走 */ val fooList = listOf("a", "b", "c") println(fooList.size) // => 3 println(fooList.first()) // => a println(fooList.last()) // => c // list元素可通过索引访问。 println(fooList[1]) // => b
// 一个可变的 list能使用 "mutableListOf" 函数创建 val fooMutableList = mutableListOf("a", "b", "c") fooMutableList.add("d") println(fooMutableList.last()) // => d println(fooMutableList.size) // => 4
// 使用 "setOf" 创建set val fooSet = setOf("a", "b", "c") println(fooSet.contains("a")) // => true println(fooSet.contains("z")) // => false
// 使用 "mapOf" f创建map val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) // Map values can be accessed by their key. println(fooMap["a"]) // => 8
//待续
|