Kotlin基础语法
/*
Kotlin特点
* ·支持类型推导;
* ·代码末尾不需要分号;
* ·字符串模板;
* ·原始字符串,支持复杂文本格式;
* ·单一表达式函数,简洁且符合直觉;
* ·函数参数支持默认值,替代 Builder 模式的同时,可读性还很强;
* ·if 和 when 可以作为表达式。
同时,JetBrains 也非常清楚开发者在什么情况下容易出错,所以,它在语言层面也做了很多改进:
* ·强制区分“可为空变量类型”和“不可为空变量类型”,规避空指针异常;
* ·推崇不可变性(val),对于没有修改需求的变量,IDE 会智能提示开发者将“var”改为“val”;
* ·基础类型不支持隐式类型转换,这能避免很多隐藏的问题;
* ·数组访问行为与集合统一,不会出现 array.length、list.size 这种恼人的情况;
* ·函数调用支持命名参数,提高可读性,在后续维护代码的时候不易出错;
* ·when 表达式,强制要求逻辑分支完整,让你写出来的逻辑永远不会有漏洞。
*/
fun main(){
/*
关键字 变量类型
↓ ↓ */
var price: Int = 100; /*
↑ ↑
变量名 变量值 */
//var m : Int = 10
//Kotlin支持类型推导,大部分情况下,变量类型可以省略不写
var m = 10 // 默认推导类型为: Int
/*
* val 声明的变量,我们叫做不可变变量,它的值在初始化以后就无法再次被修改,它相当于Java里面的final变量。
* var 声明的变量,我们叫做可变变量,它对应 Java 里的普通变量。
*/
val b = 20
//b = 25报错
var a = 100
a = 15
/* 在Java 里面,基础类型分为原始类型(Primitive Types)和包装类型(Wrapper Type)。
比如,整型会有对应的int 和Iinteger,前者是原始类型,后者是包装类型
int i = 0; //原始类型
Integer j = 1; //包装类型
*/
//在Kotlin语言体系当中,是没有原始类型这个概念的。这也就意味着,在Kotlin里,一切都是对象。
val n: Double = 1.toDouble() //整型数字"1"被看作是对象了,所以我们可以调用它的成员方法toDouble()
/* Kotlin 强制要求开发者在定义变量的时候,指定这个变量是否可能为 null。
对于可能为null的变量,我们需要在声明的时候,在变量类型后面加一个问号“?”
*/
//val i: Double = null // 编译器报错
val o: Double? = null // 编译通过
//在数字类型上,Kotlin和Java几平是一致的
/*
整数默认会被推导为“int”类型;
Long 类型,我们则需要使用“L”后缀;
小数默认会被推导为“Double”,我们也可以使用“D”后缀;
Float 类型,我们需要使用“F”后缀;
使用“0x”,来代表十六进制字面量;
使用“0b”,来代表二进制字面量。
*/
//对于数字类型的转换,Kotlin 与 Java 的转换行为是不一样的。
val int = 1
val long = 1234567L
val double = 13.14
val float = 13.14F
val hexadecimal = 0xAF
val binary = 0b01010101
//Java 可以隐式转换数宇类型,而 Kotlin 更推崇显式转换。
val i = 100
//val j: Long = i // 编译器报错
val j: Long = i.toLong() // 编译通过
//toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()、toChar()
val c: Char = 'A'
//val i: Int = c // 编译器报错
val k: Int = c.toInt() // 编译通过
println(k)
val s = "Hello Kotlin!"
val name = "Kotlin"
print("Hello $name!")
/* ↑
直接在字符串中访问变量
*/
// 输出结果:
// Hello Kotlin!
val array = arrayOf("Java", "Kotlin")
print("Hello ${array.get(1)}!")
/* ↑
复杂的变量,使用${}
*/
// 输出结果:
// Hello Kotlin!
val y = """
当我们的字符串有复杂的格式时
原始字符串非常的方便
因为它可以做到所见即所得。 """
println(y)
//在Kotlin中,一般用arrayOf()创建数组
val arrayInt = arrayOf(1, 2, 3)
val arrayString = arrayOf("apple", "pear")
val array2 = arrayOf("apple", "pear")
println("Size is ${array2.size}")
println("First element is ${array2[0]}")
// 输出结果:
// Size is 2
// First element is apple
helloFunction("Kotlin")
helloFunction(name = "Kotlin")
createUser("Tom", 30, 1, 78, 2093, 10937, 3285)
createUser(
name = "Tom",
age = 30,
gender = 1,
friendCount = 78,
feedCount = 2093,
likeCount = 10937,
commentCount = 3285
)
createUser2(
name = "Tom",
age = 30,
commentCount = 3285
)
val i1 = 1
if (i1 > 0) {
println("Big")
} else {
println("Small")
}
//还可以作为表达式来使用
val message = if (i1 > 0) "Big" else "Small"
println(message)
//输出结果:
//Big
val i2: Int = 1
when(i2) {
1 -> print("一")
2 -> print("二")
else -> print("i 不是一也不是二")
}
//输出结果:
//一
//Kotlin 的 when 更加强大,它同时也可以作为表达式,为变量赋值
val i3: Int = 1
val message2 = when(i3) {
1 -> "一"
2 -> "二"
else -> "i 不是一也不是二" // 如果去掉这行,会报错
}
print(message2)
//while 循环在使用上和 Java 也没有什么区别
//对于 for 语句,Kotlin 和 Java 的用法就明显不一样
//以下代码就代表了迭代 array 这个数组里的所有元素
val array1 = arrayOf(1, 2, 3)
for (i in array1) {
println(i)
}
//Kotlin 还支持迭代一个“区间”,
//我们可以使用“..”来连接数值区间的两端,比如“1..3”就代表从 1 到 3 的闭区间,左闭右闭
val oneToThree = 1..3 // 代表 [1, 3]
for (i in oneToThree) {
println(i)
}
//输出结果:
//1
//2
//3
//还可以逆序迭代一个区间
//
for (i in 6 downTo 0 step 2) {
println(i)
}
//以上代码的含义就是逆序迭代一个区间,从 6 到 0,每次迭代的步长是 2,这意味着 6 迭代过后,到 4、2,最后到 0。
//输出结果:
//6
//4
//2
//0
}
/*
关键字 函数名 参数类型 返回值类型
↓ ↓ ↓ ↓ */
fun helloFunction(name: String): String {
return "Hello $name !"
}/* ↑
花括号内为:函数体
*/
//单一表达式函数
//fun helloFunction(name: String): String = "Hello $name !"
//fun helloFunction(name: String) = "Hello $name !"
fun createUser(
name: String,
age: Int,
gender: Int,
friendCount: Int,
feedCount: Int,
likeCount: Long,
commentCount: Int
) {
//..
}
/*
* gender、friendCount、feedCount、likeCount、commentCount 这几个参数都被赋予了默认值。
* 这样做的好处就在于,我们在调用的时候可以省很多事情。比如说,下面这段代码就只需要传 3 个参数,
* 剩余的 4 个参数没有传,但是 Kotlin 编译器会自动帮我们填上默认值。
createUser2(
name = "Tom",
age = 30,
commentCount = 3285
)
*/
fun createUser2(
name: String,
age: Int,
gender: Int = 1,
friendCount: Int = 0,
feedCount: Int = 0,
likeCount: Long = 0L,
commentCount: Int = 0
) {
//..
}
/*
Kotlin 当中明确规定了类型分为“可空类型”“不可空类型”,
因此,我们会经常遇到可空的变量,并且要判断它们是否为空。
*/
fun getLength(text: String?): Int {
return if (text != null) text.length else 0
}
//Elvis 表达式写法————
fun getLength2(text: String?): Int {
//上述第一个问号,如果text为空,就不会执行后面获取长度的操作,返回默认值-1。
/*
语法格式为“表达式?:表达式”的,如果左侧表达式非空,
则返回左侧表达式的值,否则返回右侧表达式的值。
当且仅当左侧为空时,才会对右侧表达式求值。
*/
return text?.length ?: 0
}