Kotlin基础语法

因为自已不想重新学习Java所以学习一下kotlin

变量

1. 使用val或者var这样的关键字作为开头
2. 后面跟变量名称，接着是变量类型和赋值语句
3. 最后以分号结尾

var price: Int = 100;
//可以省略分号
var price: Int = 100
//支持类型推导
var price = 100
1
2
3
4
5

还有一点要注意，就是在Kotlin当中，我们应该尽量避免使用var,尽可能使用val

var price = 100
price = 101

val i = 0
i = 1//编辑器会出错
1
2
3
4
5

总结：

1. val声明的变量，我们叫做不可变变量，它的值在初始化以后就无法修改，相当与Java中的final修饰的变量
2. var 声明的变量，我们叫做可变变量，对应着Java中的普通变量

基础类型

Java中基础类型分为原始类型和封装类型

int j = 1;
Integer j = 2;//封装类型
1
2

Integer作为包装类型，它是有成员函数以及成员方法的，这就是它作为对象的优势

但是在Kotlin语言体系中，一切都是对象

kotlin是完全面向对象的

val i : Double = 1.toDouble()//整数类型可以被看成对象
1

空安全

val i : Double = null//编译器报错
1

对象可能为空，但是上面这种写法不会通过，对于可能为null的变量，我们需要在声明的时候，在变量类型后面加一个?

val i: Double? = null
1

var i: Doule = 1.0;
var j: Double = null;
i = j;//编译器会报错
j = i;//编译器不会报错
1
2
3
4

这个例子告诉我们可能为空的变量是不可以赋值给不为空的变量的

为了避免这种错误我们可以直接写一个判断语句

var i: Double = 1.0
val j: Double = 2.0
if (j != null) {
	i = j;
}
1
2
3
4
5

数字类型

val a = 1//默认是Int类型
val a1 = 200000L//如果是Long类型需要加一个L
val b = 2.0//默认为Double类型
val b1 = 13.14F//如果是Float类型加一个F
1
2
3
4

可以使用0x来表示十六进制的字面量，使用0b来表示二进制字面量

在Kotlin中不支持隐式类型的转化，

例如：

val i = 100
val j: Long = i//编译器报错
1
2

正确的做法是显式的调用Int类型的toLong()方法

val i = 100
val j: Long = i.toLong()//编译通过
1
2

类似这种函数还有很多比如:

toShort(),toInt(),toLong(),toFloat()、toDouble()、toChar()

布尔类型

布尔类型只有两种值，分别是true和false, 布尔类型支持一些逻辑操作
“&”代表“与运算”；
“|”代表“或运算”；
“!”代表“非运算”；
“&&”和“||”分别代表它们对应的“短路逻辑运算”

val a = 1
val b = 2
val c = 3
val d: Boolean = a < b || b > c //true
val d: Boolean = a < b && b > c //false
1
2
3
4
5

字符类型

val char = 'A'
val i: Int = c.toInt()//编译通过
1
2

字符串

1. 字符串不可变
2. 字符串模版
3. 多行字符串

val str = "wang"
//在字符串中直接使用变量
print("Hello, $str")
//多行字符串
val str1 = """
			窗前明月光
			疑是地上霜"""
print(str1)
1
2
3
4
5
6
7
8

数组
在Kotlin中使用arrayOf()来创建数组，括号中可以传入参数进行初始化，同时编译器会进行类型推导

val  arr = arrayOf(1, 2, 3)
var arrString = arrayOf("apple", "pear")
1
2

输出数组的size和通过索引访问数组元素

val array = arrayOf("apple", "pear")
println("array size is ${array.size}")
println("first element is ${array[0]}")
//使用get
println("second element is ${array.get(1)}")
1
2
3
4
5

函数声明
4. 关键字fun
5. 函数名
6. 参数类型, 多个参数可以竖着写
7. 返回值类型

fun helloFunction(name: String): String {
	return "hello, $name"
}
1
2
3

如果函数中只有一行代码，我们可以省略函数体的花括号，直接使用=赋值，

fun helloFunction (name : String): String = "hello $name"
1

可以将return给去掉

函数调用

//第一种
helloFunction("Kotlin")
//第二种
helloFunction(name = "Kotlin")
1
2
3
4

多个形参

fun createUser {
	name: String,//注意这里的逗号
	age: Int,
	gender: String,
} {
//函数体
}
1
2
3
4
5
6
7

流程控制

• if语句

val a = 2
if (a > 1) {
	print("大于1")
} else {
	print("小于1")
}
//可以将这个if语句写在一行
val answer = if (a > 1) "大于1" else "小于1"
print(answer)
1
2
3
4
5
6
7
8
9

注意函数的形式参数可能为空

fun getLength(text: String?): Int {
	return if (text != null) text.length else 0
}
1
2
3

Kotlin 针对这种情况就提供了一种简写，叫做 Elvis 表达式

fun getLength(text: String?): Int {
	return text?.length?: 0
}
1
2
3

• when语句

val i: Int = 1
when(i) {
	1 -> println("1")
	2 -> println("2")
	3 -> println("3")
	else -> println("找不到")
}
1
2
3
4
5
6
7

注意这里的else不可以去掉, when中的表达式要求它的分支必须是完整的

• while语句

var i = 0
while (i < 2) {
	println(i)
	i++
}
//-------------
var j = 0
do {
	j++
} while (j <= 2)
1
2
3
4
5
6
7
8
9
10

• for循环

遍历数组

val array = arrayOf(1, 2, 3, 4)
for (i in array) {
	println(i)
}
1
2
3
4

遍历区间
在Kotlin中使用..来定义一个区间

val oneToThree = 1..3//[1, 3]
for (i in oneToThreee) {
	println(i)
}
1
2
3
4

还可以使用downTo,step顺序迭代一个区间

for (i in 6 downTo 0 step 2) {
	println(i)
}
1
2
3

需要特别注意的是，逆序区间我们不能使用“6…0”来定义，如果用这样的方式来定义的话，代码将无法正常运行