Kotlin初级【基本语法、数据类型、循环】

1、第一个kotlin程序

fun main(){
    //在控制台输出Hello Kotlin!
    println("Hello Kotlin!")
}
1
2
3
4

2、注释

2.1 单行注释

//这里是单行注释内容
1

2.2 多行注释

/*
这里是多行注释内容
这里是多行注释内容
这里是多行注释内容
*/
     
/**
 * 多行注释也可这样写
 * 多行注释也可这样写
 * 多行注释也可这样写
 */
1
2
3
4
5
6
7
8
9
10
11

3、基本数据类型

3.1 变量（var）VS常量（val）

整型变量

var x: Int = 5 //定义一个整型变量x，初值为5
x = 10         //可以修改变量的值
1
2

整型常量

val c = 10  //定义常量c，初值为10
c = 6       //会报错，常量不可被修改
1
2

3.2 推断类型

var a = 10     //Kotlin可自动推断类型，整型默认为Int
1

3.3 整数类型

有符号整数

无符号整数

定义整型变量

var x: Int = 5 //定义一个整型变量x，初值为5

var a: Int     //定义一个整型变量a，没有初值
a=5            //可以使用时再赋值

var b = a      //把a的值赋给b
var b = a + a  //把a+a的值赋给b
1
2
3
4
5
6
7

类型转换

var a: Long = 89   //89本身是Int类型，被Long类型变量接收，发生了类型转换

var b: Long = 89L  //89本身是Long类型，被Long类型变量接收
1
2
3

二进制、八进制、十六进制

var a: Int = 1_000_000  //0的数量数不清，可用"_"分割
var b: Int = 0x16       //十六进制，0x前缀
var c: Int = 0b1010     //二进制，0b前缀
//kotlin默认不支持八进制
1
2
3
4

无符号整数

var a: UInt = 12u  //无符号整数12，后缀u(大写小写都行)
var b: ULong = 12UL  //无符号Long类型整数12，后缀UL
//U表示unsigned，L表示Long
1
2
3

3.4 浮点数类型（小数）

Kotlin的浮点数符合IEEE754标准

var exp = 2.71828      //默认推断为Double类型
var pi: Float = 3.14f  //后缀f，表示是Float类型数据

var a1:Double=1    //错误写法，1不是小数，无法编译通过
var a2:Double=1.0  //正确写法，1.0是小数
1
2
3
4
5

Kotlin中，Int和Float/Double能直接转换，用函数可以（如toDouble）

3.4 数据运算

本质：通过运算符重载实现功能

自增/自减

var a: Int = 1
a++            //a自增1
a = a + 2      //a自增2
a += 2         //a自增2

a--            //a自减1
a = a - 2      //a自减2
a -= 2         //a自减2
1
2
3
4
5
6
7
8

a += 2等价于a = a + 2
a -= 2等价于a = a - 2
a *= 2等价于a = a * 2
a /= 2等价于a = a / 2

a++，a–，++a，–a
设a的初值为2
a++这个表达式的值为2（a+1之前的值）
++a 这个表达式的值为3（a+1之后的值）
a--这个表达式的值为2（a-1之前的值）
--a 这个表达式的值为1（a-1之后的值）

移位

var a: Int = 1
var b = a shl 2  //把a左移两位后的值赋给b，即b=4
1
2

3.5 布尔类型

布尔类型的变量只有两种值

var a: Boolean = true   //定义一个Boolean类型的变量
var b: Boolean = 1>=2   //1大于等于2吗？显然结果为false

var c:Int =100
var c1:Boolean=c in 0..101//判断c是否在[0,101]内。结果为true
1
2
3
4
5

Boolean之间的运算

var a = true
var b = false

println(a && b)  //逻辑与。输出false
println(a || b)  //逻辑或。输出true
println(!a)  //逻辑取反。输出false

println(1 > 2 && 6 == 7)  //表达式。有短路性质
//短路：1>2已经是false，则后面的6==7不会进行比较（不会运行）
println(1 < 2 || 6 == 7)//表达式。有短路性质
1
2
3
4
5
6
7
8
9
10

3.6 字符类型（Char）

• 默认ASCII码，如'a'
• 也可用Unicode码，如'\u2713'(一个对勾符号'✓')

var c: Char = 'a'       //定义一个Char类型的变量
var c: Char = '\u2713'  //定义一个Char类型的变量
1
2

转义字符

3.6 字符串类型（String）

• String就是一串Char
• 不可修改
• 双引号包裹，如"abc123"

var s: String = "abcde"
s="12345"  //此时s为"12345"，是一个新的String。原来的"abcde"还在，只是不知道在哪里
1
2

多行String

//多行String，用三个引号
//不能用转义字符了
//每行前面的空格不会被忽略
var str:String="""
    asdf
    asdf
    qwerq
    123
"""
println(str)
//用trimIndent()忽略每行前面的空格等
var str:String="""
    asdf
    asdf
    qwerq
    123
""".trimIndent()
println(str)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

字符串拼接

var a = "abc"
var b = "123"
println(a + b + 999 + true)//字符串拼接
//拼接时，最左边的元素必须是字符串
1
2
3
4

字符串模板

var a = 25
var b = "$a 个用户"  //字符串模板
println(b) //输出“25 个用户”（25后面有空格）
var c = "${a}个用户"  //字符串模板
println(c) //输出“25个用户”（25后面没有空格）

println("\$${a}个用户")//想使用美元符，用转义字符即可
1
2
3
4
5
6
7

4、流程控制

判断条件必须是布尔类型，如

• true
• a>0
• s==3 && a<4

4.1 if-else

var a = 1
if (a > 0) {
	println("a大于0！")
} else {
	println("a小于等于0！")
}
1
2
3
4
5
6

var score = 85

if (score >= 0 && score<60) {
    println("不及格！")
} else if (score < 80){
    println("中等！")
}else if (score < 90){
    println("良好！")
}else if (score <= 1000){
    println("优秀！")
}else{
    println("输入不合法！")
}
1
2
3
4
5
6
7
8
9
10
11
12
13

用判断条件赋值

var score = 100
var str = if (score == 100) "excellent" else "no"
println(str)  //输出：excellent
1
2
3

var score = 100
var str = if (score == 100) {
    println("牛")
    "满分"   //默认最后一行作为返回值
} else {
    println("不牛")
    "不是满分"
}
println(str)
1
2
3
4
5
6
7
8
9

4.2 when（相当于switch-case）

类比C语言中的switch-case语句

var s = 'B'
var mvalue = when (s) {
    'A' -> {
        println("是A班")
        "A班"  //类似if-else，最后一行可用于赋值
    }
    'B' -> {
        println("是B班")
        "B班"
    }
    'C' -> {
        println("是C班")
        "C班"
    }
    'D' -> {
        println("是D班")
        "D班"
    }
    else -> {
        println("是非法数据")
        "非法数据"
    }
}
println(mvalue)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

范围判断的另一种写法

var s = 123
when (s) {
    in 10..20 -> println("s属于[10,20]")
    in 20..1000 -> println("s属于[20,1000]")
    //也可以加花括号，变为多行
}
1
2
3
4
5
6

4.3 for循环

//输出0到6
for (i in 0..6)  //闭区间[0,6]
    println(i)
1
2
3

//输出0到6中间的偶数
for (i in 0..6 step 2) //控制步长为2
    println(i)
//也可以这样写
var mrange = 0..6 step 2
for (i in mrange) //控制步长为2
    println(i)
1
2
3
4
5
6
7

倒序输出

//输出0到6中间的偶数（倒序）
for (i in 6 downTo 0 step 2) //控制步长为2
    println(i)
1
2
3

跳过一轮循环

• 关键字continue
• 只能控制一层循环（他所在的那一层）

//输出0到6（跳过0）
for (i in 0..6) {  //闭区间[0,6]
    if(i == 0) continue  //跳过0
    println(i)
}
1
2
3
4
5

跳过一层循环

• 关键字break
• 只能控制一层循环（他所在的那一层）

//输出0到1
for (i in 0..6) {  //闭区间[0,6]
    if(i == 2) break  //跳出循环
    println(i)
}
1
2
3
4
5

可指定break和coutinue控制哪一层循环

aa@ for(i in 1..5){
    for(j in 1..5){
        if(i==j) continue@aa  //i==j时，跳过一轮最外层循环
        print("($i,$j)")
    }
    println()
}
/*代码输出
(2,1)(3,1)(3,2)(4,1)(4,2)(4,3)(5,1)(5,2)(5,3)(5,4)
*/
1
2
3
4
5
6
7
8
9
10

4.4 while循环

• 不知道循环几次，但知道循环结束条件

var i = 1
while (i < 10) {
    println(i)
    i++
}
1
2
3
4
5

4.5 do-while循环

• 不知道循环几次，但知道循环结束条件
• 会先执行一次循环体内的内容

var i = 1
do {
    println(i)
    i++
} while (i < 10)
1
2
3
4
5

参考

https://www.bilibili.com/video/BV1P94y1c7tV?p=4&vd_source=c708def0a324eac06f3f31f597632be7