//这是单行注释 //
/*
这是多行注释
*/
// 这和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
//待续
来源: http://www.jdon.com/48901