// Single-line comments start with //
/*
Multi-line comments look like this.
*/
// The "package" keyword works in the same way as in Java.
package com.learnxinyminutes.kotlin
/*
The entry point to a Kotlin program is a function named "main".
The function is passed an array containing any command line arguments.
*/
fun main(args: Array<String>) {
/*
Declaring values is done using either "var" or "val".
"val" declarations cannot be reassigned, whereas "vars" can.
*/
val fooVal = 10 // we cannot later reassign fooVal to something else
var fooVar = 10
fooVar = 20 // fooVar can be reassigned
/*
In most cases, Kotlin can determine what the type of a variable is,
so we don't have to explicitly specify it every time.
We can explicitly declare the type of a variable like so:
*/
val foo: Int = 7
/*
Strings can be represented in a similar way as in Java.
Escaping is done with a backslash.
\n \t :使用反斜杠进行转义
*/
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)
/*
A raw string is delimited by a triple quote (""").
Raw strings can contain newlines and any other characters.
三个双引号可以将输入的任何东西作为字符串
*/
val fooRawString = """
fun helloWorld(val name : String) {
println("Hello, world!")
}
"""
println(fooRawString)
/*
Strings can contain template expressions.
A template expression starts with a dollar sign ($).
$+变量名 可以在双引号中使用使其也能获取变量 就像java中的 字符串 + 变量名
*/
val fooTemplateString = "$fooString has ${fooString.length} characters"
println(fooTemplateString) // => My String Is Here! has 18 characters
/*
For a variable to hold null it must be explicitly specified as nullable.
A variable can be specified as nullable by appending a ? to its type.
We can access a nullable variable by using the ?. operator.
We can use the ?: operator to specify an alternative value to use
if a variable is null.
?表示变量可以为null,可以为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
/*
Functions can be declared using the "fun" keyword.
Function arguments are specified in brackets after the function name.
Function arguments can optionally have a default value.
The function return type, if required, is specified after the arguments.
以下是构造一个名为 hello 传入参数默认为 "world" 的String类型的参数,并且返回值为String类型的方法
*/
fun hello(name: String = "world"): String {
return "Hello, $name!"
}
println(hello("foo")) // => Hello, foo!
println(hello(name = "bar")) // => Hello, bar!
println(hello()) // => Hello, world!
/*
A function parameter may be marked with the "vararg" keyword
to allow a variable number of arguments to be passed to the function.
vararg 修饰一个参数变量使该方法可以传入多个指定类型的参数,即(以下)可以传入多个Int类型的参数
*/
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
/*
When a function consists of a single expression then the curly brackets can
be omitted. The body is specified after a = symbol.
当函数由单个表达式组成时，大括号可以被省略。 在=符号后指定正文。
以下表示 x 取余 2 是否为 1 ,返回的是Boolean类型
*/
fun odd(x: Int): Boolean = x % 2 == 1
println(odd(6)) // => false
println(odd(7)) // => true
// If the return type can be inferred then we don't need to specify it.
//如果知道返回类型也可以不指定返回类型
fun even(x: Int) = x % 2 == 0
println(even(6)) // => true
println(even(7)) // => false
// Functions can take functions as arguments and return functions.
//Lambda表达式(不想学,也不想用,所以就跳过)
fun not(f: (Int) -> Boolean): (Int) -> Boolean {
return {n -> !f.invoke(n)}
}
// Named functions can be specified as arguments using the :: operator.
//可以使用::运算符将命名函数指定为参数
val notOdd = not(::odd)
val notEven = not(::even)
// Lambda expressions can be specified as arguments.
val notZero = not {n -> n == 0}
/*
If a lambda has only one parameter
then its declaration can be omitted (along with the ->).
The name of the single parameter will be "it".
*/
val notPositive = not {it > 0}
for (i in 0..4) {
println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
}
// The "class" keyword is used to declare classes.创建一个类
class ExampleClass(val x: Int) {
fun memberFunction(y: Int): Int {
return x + y
}
infix fun infixMemberFunction(y: Int): Int {
return x * y
}
}
/*
To create a new instance we call the constructor.
Note that Kotlin does not have a "new" keyword.
kotlin没有new关键字,构建实例可以直接写类名
*/
val fooExampleClass = ExampleClass(7)
// Member functions can be called using dot notation.
println(fooExampleClass.memberFunction(4)) // => 11
/*
If a function has been marked with the "infix" keyword then it can be
called using infix notation.
*/
println(fooExampleClass infixMemberFunction 4) // => 28
/*
Data classes are a concise way to create classes that just hold data.
The "hashCode"/"equals" and "toString" methods are automatically generated.
数据类,即java中的实体类,免去写set() get() 方法的麻烦
*/
data class DataClassExample (val x: Int, val y: Int, val z: Int)
val fooData = DataClassExample(1, 2, 4)//跟调用set方法差不多
println(fooData) // => DataClassExample(x=1, y=2, z=4)
// Data classes have a "copy" function.
//拷贝fooData并将它传入的参数 y 指定为 100
val fooCopy = fooData.copy(y = 100)
println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
/**Objects can be destructured into multiple variables.
*将fooCopy中的x,y,z分别赋给a,b,c
*即 a = fooCopy.x ; b = fooCopy.y ; c = fooCopy.z
* */
val (a, b, c) = fooCopy
println("$a $b $c") // => 1 100 4
// destructuring in "for" loop
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 is destructurable as well
for ((key, value) in mapData) {
println("$key -> $value")
}
// The "with" function is similar to the JavaScript "with" statement.
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)
/*
We can create a list using the "listOf" function.
The list will be immutable - elements cannot be added or removed.
使用listof创建一个列表(不可变,即不能添加或删除该列表中的元素)
*/
val fooList = listOf("a", "b", "c")
println(fooList.size) // => 3
println(fooList.first()) // => a
println(fooList.last()) // => c
// Elements of a list can be accessed by their index.
println(fooList[1]) // => b
// A mutable list can be created using the "mutableListOf" function.
//可以使用“mutableListOf”函数创建可变列表。
val fooMutableList = mutableListOf("a", "b", "c")
fooMutableList.add("d")
println(fooMutableList.last()) // => d
println(fooMutableList.size) // => 4
// We can create a set using the "setOf" function.
//使用setof创建一个集合
val fooSet = setOf("a", "b", "c")
println(fooSet.contains("a")) // => true
println(fooSet.contains("z")) // => false
// We can create a map using the "mapOf" function.
val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
// Map values can be accessed by their key.
println(fooMap["a"]) // => 8
/*
Sequences represent lazily-evaluated collections.
We can create a sequence using the "generateSequence" function.
*/
val fooSequence = generateSequence(1, { it + 1 })
val x = fooSequence.take(10).toList()
println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// An example of using a sequence to generate Fibonacci numbers:
fun fibonacciSequence(): Sequence<Long> {
var a = 0L
var b = 1L
fun next(): Long {
val result = a + b
a = b
b = result
return a
}
return generateSequence(::next)
}
val y = fibonacciSequence().take(10).toList()
println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
// Kotlin provides higher-order functions for working with collections.
val z = (1..9).map {it * 3}
.filter {it < 20}
.groupBy {it % 2 == 0}
.mapKeys {if (it.key) "even" else "odd"}
println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
// A "for" loop can be used with anything that provides an iterator.
//for循环迭代器,即将"hello" 一个个作为字符提出
for (c in "hello") {
println(c)
}
// "while" loops work in the same way as other languages.
var ctr = 0
while (ctr < 5) {
println(ctr)
ctr++
}
do {
println(ctr)
ctr++
} while (ctr < 10)
/*
"if" can be used as an expression that returns a value.
For this reason the ternary ?: operator is not needed in Kotlin.
if作为返回值表达式,取余为0则返回even,否则为odd,就像java中的三元运算符
*/
val num = 5
val message = if (num % 2 == 0) "even" else "odd"
println("$num is $message") // => 5 is odd
// "when" can be used as an alternative to "if-else if" chains.
/**when跟switch差不多,但是它可以不传如参数
* 所以when可以替代if else ,即在when主体中将判断语句作为参数
* */
val i = 10
when {
i < 7 -> println("first block")
fooString.startsWith("hello") -> println("second block")
else -> println("else block")
}
// "when" can be used with an argument.
when (i) {
0, 21 -> println("0 or 21")
in 1..20 -> println("in the range 1 to 20")
else -> println("none of the above")
}
// "when" can be used as a function that returns a value.
var result = when (i) {
0, 21 -> "0 or 21"
in 1..20 -> "in the range 1 to 20"
else -> "none of the above"
}
println(result)
/*
We can check if an object is a particular type by using the "is" operator.
If an object passes a type check then it can be used as that type without
explicitly casting it.
Any表示一个任意对象,可能是1234也可能是hello等不同类型的对象
*/
fun smartCastExample(x: Any) : Boolean {
if (x is Boolean) {
// x is automatically cast to Boolean
return x
} else if (x is Int) {
// x is automatically cast to Int
return x > 0
} else if (x is String) {
// x is automatically cast to String
return x.isNotEmpty()
} else {
return false
}
}
println(smartCastExample("Hello, world!")) // => true
println(smartCastExample("")) // => false
println(smartCastExample(5)) // => true
println(smartCastExample(0)) // => false
println(smartCastExample(true)) // => true
// Smartcast also works with when block
fun smartCastWhenExample(x: Any) = when (x) {
is Boolean -> x
is Int -> x > 0
is String -> x.isNotEmpty()
else -> false
}
/*
Extensions are a way to add new functionality to a class.
This is similar to C# extension methods.
*/
fun String.remove(c: Char): String {
return this.filter {it != c}
}
println("Hello, world!".remove('l')) // => Heo, word!
println(EnumExample.A) // => A
println(ObjectExample.hello()) // => hello
}
// Enum classes are similar to Java enum types.
//枚举
enum class EnumExample {
A, B, C
}
/*
The "object" keyword can be used to create singleton objects.
We cannot instantiate it but we can refer to its unique instance by its name.
This is similar to Scala singleton objects.
创建object对象,可以通过他的名字直接获取实例
*/
object ObjectExample {
fun hello(): String {
return "hello"
}
}
fun useObject() {
ObjectExample.hello()
val someRef: Any = ObjectExample // we use objects name just as is
}