既然点进来看了,我也就不多赘述kotlin的历史,为什么要学kotlin那些东西了,直接开门见山,开始我们的学习。
我在参照这个文档来的http://www.kotlindoc.cn/GettingStarted/Basic-Syntax.html在中间穿插了一些自己的理解,不喜勿喷。
这里我用到了一个在线工具https://c.runoob.com/compile/2960,在此推荐给大家。
1.包名
包名不必和文件夹路径一致:源文件可以放在任意位置。
2.函数
fun sum(a: Int, b: Int) = a + b
只有一个表达式函数体以及一个自推导型的返回值
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}
返回一个没有意义的值
当然Unit的返回类型可以省略
3.局部变量
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")
}
最完整版本是:val(只读)/ var(可变)变量名:类型=初始值
可以直接按上边的规则,也可以不写类型让程序自己去推导类型,当没有初始化值时就必须声明类型。
4.注释
当行注释和块注释
块注释可以级联
5.字符串模板
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)
}
6.条件表达式
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
可把if当做表达式
fun maxOf(a: Int, b: Int) = if (a > b) a else b
在 Kotlin 中,if 是表达式,比如它可以返回一个值。是除了condition ? then : else)之外的唯一一个三元表达式
//传统用法
var max = a
if (a < b)
max = b
//带 else
var max: Int
if (a > b)
max = a
else
max = b
//作为表达式
val max = if (a > b) a else b
if 分支可以作为块,最后一个表达是是该块的值:
val max = if (a > b){
print("Choose a")
a
}
else{
print("Choose b")
b
}
7.使用可空变量以及空值检查
当空值可能出现时应该明确指出该引用为空。
当str中不包含整数时返回空:
使用一个返回可空值的函数:
fun parseInt(str: String): Int? {
return str.toIntOrNull()
}
fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
// 直接使用 x*y 会产生错误因为它们中有可能会有空值
if (x != null && y != null) {
// x 和 y 将会在空值检测后自动转换为非空值
println(x * y)
}
else {
println("either '$arg1' or '$arg2' is not a number")
}
}
或者这样
fun parseInt(str: String): Int? {
return str.toIntOrNull()
}
fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
// ...
if (x == null) {
println("Wrong number format in arg1: '${arg1}'")
return
}
if (y == null) {
println("Wrong number format in arg2: '${arg2}'")
return
}
// x 和 y 将会在空值检测后自动转换为非空值
println(x * y)
}
8.使用值检查并自动转换
使用is操作符检查一个表达式是否是一个类型的实例。
如果对不可变的局部变量或属性进行过了类型检查,就没有必要强制转换:
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
// obj 将会在这个分支中自动转换为 String 类型
return obj.length
}
还可以这样
fun getStringLength(obj: Any): Int? {
// obj 将会在&&右边自动转换为 String 类型
if (obj is String && obj.length > 0) {
return obj.length
}
return null
}
9.for循环
- Kotlin废除了Java中的for(初始值;条件;增减步长)这个规则。但是Kotlin中对于for循环语句新增了其他的规则,来满足刚提到的规则。
- for循环提供迭代器用来遍历任何东西
- for循环数组被编译为一个基于索引的循环,它不会创建一个迭代器对象
9.1 新增的规则,去满足for(初始值;条件;增减步长)这个规则
9.1.1 递增
关键字:until
范围:until[n,m) => 即大于等于n,小于m
// 循环5次,且步长为1的递增
for (i in 0 until 5){
print("i => $i \t")
}
输出结果:
i => 0 i => 1 i => 2 i => 3 i => 4
9.1.2 递减
关键字:downTo
范围:downTo[n,m] => 即小于等于n,大于等于m ,n > m
// 循环5次,且步长为1的递减
for (i in 15 downTo 11){
print("i => $i \t")
}
输出结果:
i => 15 i => 14 i => 13 i => 12 i => 11
9.1.3 符号(' .. ') 表示递增的循环的另外一种操作
使用符号( '..')
范围:..[n,m]=> 即大于等于n,小于等于m
和until的区别,一是简便性。二是范围的不同。
print("使用 符号`..`的打印结果\n")
for (i in 20 .. 25){
print("i => $i \t")
}
println()
print("使用until的打印结果\n")
for (i in 20 until 25){
print("i => $i \t")
}
输出结果:
使用 符号`..`的打印结果
i => 20 i => 21 i => 22 i => 23 i => 24 i => 25
使用until的打印结果
i => 20 i => 21 i => 22 i => 23 i => 24
9.1.4 设置步长
关键字:step
for (i in 10 until 16 step 2){
print("i => $i \t")
}
输出结果:
i => 10 i => 12 i => 14
9.2 迭代
for循环提供一个迭代器用来遍历任何东西。
for循环数组被编译为一个基于索引的循环,它不会创建一个迭代器对象
9.2.1 遍历字符串
for (i in "abcdefg"){
print("i => $i \t")
}
输出结果为:
i => a i => b i => c i => d i => e i => f i => g
9.2.2 遍历数组
var arrayListOne = arrayOf(10,20,30,40,50)
for (i in arrayListOne){
print("i => $i \t")
}
输出结果为:
i => 10 i => 20 i => 30 i => 40 i => 50
9.2.3 使用数组的indices属性遍历
var arrayListTwo = arrayOf(1,3,5,7,9)
for (i in arrayListTwo.indices){
println("arrayListTwo[$i] => " + arrayListTwo[i])
}
输出结果为:
arrayListTwo[0] => 1
arrayListTwo[1] => 3
arrayListTwo[2] => 5
arrayListTwo[3] => 7
arrayListTwo[4] => 9
9.2.4 使用数组的withIndex()方法遍历
var arrayListTwo = arrayOf(1,3,5,7,9)
for ((index,value) in arrayListTwo.withIndex()){
println("index => $index \t value => $value")
}
输出结果为:
index => 0 value => 1
index => 1 value => 3
index => 2 value => 5
index => 3 value => 7
index => 4 value => 9
9.2.5 使用列表或数组的扩展函数遍历
数组或列表有一个成员或扩展函数iterator()实现了Iterator<T>接口,且该接口提供了next()与hasNext()两个成员或扩展函数
其一般和while循环一起使用
1.可以查看Array.kt这个类。可以看见其中的iterator()函数,而这个函数实现了Iterator接口。
/**
* Creates an iterator for iterating over the elements of the array.
*/
public operator fun iterator(): Iterator<T>
2.查看Iterator.kt这个接口类,这个接口提供了hasNext()函数和next()函数。
public interface Iterator<out T> {
/**
* Returns the next element in the iteration.
*/
public operator fun next(): T
/**
* Returns `true` if the iteration has more elements.
*/
public operator fun hasNext(): Boolean
}
var arrayListThree = arrayOf(2,'a',3,false,9)
var iterator: Iterator<Any> = arrayListThree.iterator()
while (iterator.hasNext()){
println(iterator.next())
}
输出结果为:
2
a
3
false
9
10.while循环
其同Java中的while循环一样。在此不做累述。
定义格式:
while(exp){ 其中exp为表达式
...
}
11.when表达式
取代了C风格语言的switch。
when会对所有的分支进行检查直到有一个条件满足。when 可以用做表达式或声明。如果用作表达式的话,那么满足条件的分支就是总表达式。如果用做声明,那么分支的的的值会被忽略。(像 if 表达式一样,每个分支是一个语句块,而且它的值就是最后一个表达式的值)
在其它分支都不匹配的时候默认匹配 else 分支。如果把 when 做为表达式的话 else 分支是强制的,除非编译器可以提供所有覆盖所有可能的分支条件。
when语句不仅可以替代掉switch语句,而且比switch语句更加强大
fun describe(obj: Any): String =
when (obj) {
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long"
!is String -> "Not a string"
else -> "Unknown"
}
如果有分支可以用同样的方式处理的话,分支条件可以连在一起:
when (x) {
0,1 -> print("x == 0 or x == 1")
else -> print("otherwise")
}
可以用任意表达式作为分支的条件
when (x) {
parseInt(s) -> print("s encode x")
else -> print("s does not encode x")
}
甚至可以用 in 或者 !in 检查值是否值在一个集合中:
when (x) {
in 1..10 -> print("x is in the range")
in validNumbers -> print("x is valid")
!in 10..20 -> print("x is outside the range")
else -> print("none of the above")
}
也可以用 is 或者 !is 来判断值是否是某个类型。注意,由于 smart casts ,你可以不用另外的检查就可以使用相应的属性或方法。
val hasPrefix = when (x) {
is String -> x.startsWith("prefix")
else -> false
}
when 也可以用来代替 if-else if 。如果没有任何参数提供,那么分支的条件就是简单的布尔表达式,当条件为真时执行相应的分支:
when {
x.isOdd() -> print("x is odd")
x.isEven() -> print("x is even")
else -> print("x is funny")
}
12.ranges
使用in操作符检查数值是否在某个范围内
检查数值在范围外 !in
在范围内迭代
或者使用步进
13.集合
对一个集合进行迭代(for循环)
使用 in 操作符检查集合中是否包含某个对象(when)
使用lambda表达式过滤和映射集合
基础语法部分就到这里,感觉有帮助的,还请关注我的博客,持续更新ing。