Kotlin开始基本知识（一）：基本语法

一、基本语法

1、包的定义与导入

package xxx包
import xxx模块

和Java基本相同

2、程序入口

fun main() {
       println("xxxxxxx一个字符串")
}

在主函数main()之前，要加上“fun”

3、函数

1）基本的函数定义和主函数main()定义

fun sum(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    print("sum of 3 and 5 is ")
    println(sum(3, 5))
}

在Kotlin中，“fun”相当于定义一个函数，相当于python中的“def”
在函数的输入变量中，使用冒号，来定义变量类型。

//在Kotlin中定义一个函数
fun sum(a: Int, b: Int): Int {
    return a + b
}
#在python中定义一个函数
def sum(a:int,b:int):
     return a+b

比较类似。
(1)、不同点在于在sum():函数的后面，把函数体放在一个大括号里面。
(2)、在主函数main()后面，使用大括号{}，替代了冒号:
※※※需要注意，
在Kotlin中，一般的普通函数，在函数名称后，需要加了冒号:，还要加大括号{}。而主函数main()，不同于普通函数，它只需要在其后加大括号{}，不需要加冒号:。

2)将表达式作为函数体的用法

//表达式作为函数体的高级写法
fun sum(a: Int, b: Int) = a + b

fun main() {
    println("sum of 19 and 23 is ${sum(19, 23)}")
}

和普通的写法对比

//普通写法
fun sum(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    print("sum of 19 and 23 is ")
    println(sum(19, 23))
}

(1)、高级写法直接在函数名sum()后面，写上这个函数的表达式，并且用等于号"="，把函数名sum()和表达式相连。
(2)、在主函数main()的函数体中，把函数赋值的操作，直接写到字符串里面。把函数赋值的操作，放入大括号{}之内，然后使用$符号，直接将二者相连。

3)把主函数main里面的输出语句，写进普通函数

//复杂写法
fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

fun main() {
    printSum(19, 23)
}

和表达式作为函数体的写法对比

//表达式作为函数体的高级写法
fun sum(a: Int, b: Int) = a + b

fun main() {
    println("sum of 19 and 23 is ${sum(19, 23)}")
}

(1)、复杂写法直接在函数名之后，把主函数main()大括号{}里的内容，还有大括号，放在后面，并用冒号:和Unit相连。
(2)、这个冒号:和Unit，是可以不写的。

4、变量

$变量名，为取这个变量的值

1）只读局部变量

fun main() {
    val a: Int = 1  // 立即赋值
    val b = 2   // 自动推断出 `Int` 类型
    val c: Int  // 如果没有初始值类型不能省略
    c = 3       // 明确赋值
    println("a = $a, b = $b, c = $c")
}

val定义的值不可以变。value：值

2）可重新赋值变量

fun main() {
    var x = 5 // 自动推断出 `Int` 类型
    x += 1
    println("x = $x")
}

var定义的值可以变。various：各种

5、注释

1）单行注释

两个斜杠

//这个呢，就是单行注释

2）多行和嵌套注释

多行注释

/*这个呢，就是多行注释
多行注释呢，就是这样写*/

嵌套注释

/*66666666666
/*666666666
/* 注释从这里开始
/* 注释从这里开始
/* 包含嵌套的注释    
并且在这里结束。 */

※※※注意在嵌套注释里面，注释开始符号/*，可以有很多个。但是注释结束符号，只可以有一个。

6、字符串模板

1）$加变量名，就是取某个变量的值

2）某个变量，经过某个方法后，再取值的话。就应该先用大括号把变量名和方法括起来，然后再在前面加上$

7、条件表达式

1）if表达式，判断条件写在小括号()里面，表达式写在大括号{}里面。

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

2）if表达式，写成一行

fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

8、空值与null检测

1）定义变量后，始终不赋值，它就是一个空值。

2）定义变量后，不确定会不会被赋值或者本身是空值，就在类型那里定义为Int？。

9、类型检测与自动类型转换

1）不确定输入的某obj是哪种类型时，就obj:any

10、for循环

1）for循环的表达式，和if判断一样，都放在小括号()里面

2）可以直接遍历listof类型的小括号里的内容。或者先items.indices,取出这个items的所有成员的索引index(从0开始)。

11、while循环

1）和for几乎一样，不同在于表达式是索引小于最大值。然后在循环体中，索引自增。

12、when表达式

1）类似于函数一一对应，when()括号里输入一个值。这个值进入大括号{}后，按照里面使用"->"一一对应的一行行式子，自己匹配x，输出y。

//函数的一一对应，如下
fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }

13、使用区间

1）区间是从小到大的话，就直接1…10，表示从1到10。

kotlin区间迭代

//input
for (x in 1..5) {
    print(x)
}
//output
12345

python

#input
for x in range(1,5):
    print(x)
#output
12345

2）区间是从大到小的话，就用downTo。

//input
for (x in 5 downTo 1 step 1) {
    print(x)
}
//output
54321

14、集合

1）迭代集合，见for循环。

2）集合中是否包含某实例，使用in。然后可以使用when，来输出是否包含

15、创建基本类及其实例

1）代码例子

fun main() {
    val rectangle = Rectangle(5.0, 2.0)
    val triangle = Triangle(3.0, 4.0, 5.0)
    println("Area of rectangle is ${rectangle.calculateArea()}, its perimeter is ${rectangle.perimeter}")
    println("Area of triangle is ${triangle.calculateArea()}, its perimeter is ${triangle.perimeter}")
}

abstract class Shape(val sides: List<Double>) {
    val perimeter: Double get() = sides.sum()
    abstract fun calculateArea(): Double
}

interface RectangleProperties {
    val isSquare: Boolean
}

class Rectangle(
    var height: Double,
    var length: Double
) : Shape(listOf(height, length, height, length)), RectangleProperties {
    override val isSquare: Boolean get() = length == height
    override fun calculateArea(): Double = height * length
}

class Triangle(
    var sideA: Double,
    var sideB: Double,
    var sideC: Double
) : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double {
        val s = perimeter / 2
        return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC))
    }
}