kotlin基础语法

Kotlin基础语法一

个人语录：人生的艰难困苦我们无法选择，但是可以选择让自己无坚不摧，战无不胜，时间不负有心人，星光不问赶路人

kotlin来源：Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，被称之为 Android 世界的Swift，由 JetBrains 设计开发并开源。Kotlin 可以编译成Java字节码，也可以编译成 JavaScript，方便在没有 JVM 的设备上运行。

为啥选择kotlin：

• 简洁: 大大减少样板代码的数量。
• 安全: 避免空指针异常等整个类的错误。
• 互操作性: 充分利用 JVM、Android 和浏览器的现有库。
• 工具友好: 可用任何 Java IDE 或者使用命令行构建。

1. 类型声明

java:

String a = "I am Java";

kotlin:

val a:String="I am Kotlin"

2. 自动类型推导

package com.qifei.day01

// 自动类型推导
fun main(){
    val a: String = "I am Kotlin"
    val float:Float = 5.5f
    println(a.javaClass.name)
    println(float.javaClass.name)
}

----------
java.lang.String
float

3. 函数的使用

   1.带有两个 Int 参数、返回 Int 的函数：
   fun main() {
       var a = sum(5, 7)
       println("sum is $a")
       println(a.javaClass.name)
   }
   fun sum(a:Int,b:Int):Int{
       return a+b
   }
   ------
   sum is 12
   int
   
   2.将表达式作为函数体、返回值类型自动推断的函数：
   fun main() {
       var a = sum(5, 7)
       println("sum is $a")
       println(a.javaClass.name)
   }
   fun sum(a:Int,b:Int) = a+b
   
   3.函数返回无意义的值：
   fun main() {
       var a = sum(5, 7)
       println("sum is $a")
       println(a.javaClass.name)
   }
   fun sum(a:Int,b:Int):Unit{
       println("Like Nananana")
   }
   
   4.Unit返回类型可以省略：
   fun main() {
       var a = sum(5, 7)
       println("sum is $a")
       println(a.javaClass.name)
   }
   fun sum(a:Int,b:Int){
       println("Like Nananana")
   }
   

4. 定义只读局部变量使用关键字 val 定义。只能为其赋值一次。

   val a: Int = 1  // 立即赋值
   val b = 2   // 自动推断出 `Int` 类型
   val c: Int  // 如果没有初始值类型不能省略
   c = 3       // 明确赋值
   

5. 全局变量定义 PI

   val PI = 3.14
   fun main() {
       var a = sum(5, 7)
       println("sum is $a")
       println(a.javaClass.name)
       println(PI.javaClass.name)
   }
   fun sum(a:Int,b:Int){
       println("Like Nananana")
       println(PI.javaClass.name)
   }
   

6. 字符串模板

   
   fun main() {
       var a = 1
       // 模板中的简单名称：
       val s1 = "a is $a"
       println(s1)
   
       a = 2
       // 模板中的任意表达式：
       val s2 = "${s1.replace("is", "was")}, but now is $a"
       println(s2)
   }
   
   --------
   a is 1
   a was 1, but now is 2
   

7. 条件表达式

   fun main(){
       print(maxOf(5,7));
   }
   fun maxOf(a:Int,b:Int):Int{
       if(a>b)
           return a;
       else
           return b;
   }
   

   kotlin简写

   fun main(){
       print(maxOf(5,7));
   }
   fun maxOf(a:Int,b:Int):Int = if (a>b) a else b
   

8. 空值与null检测

   当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空。

   如果 str 的内容不是数字返回 null：

   fun parseInt(str: String): Int? {
       // ……
   }
   

   使用返回可空值的函数:

   fun parseInt(str: String): Int? {
       return str.toIntOrNull()
   }
   
   fun printProduct(arg1: String, arg2: String) {
       val x = parseInt(arg1)
       val y = parseInt(arg2)
   
       // 直接使用 `x * y` 会导致编译错误，因为它们可能为 null
       if (x != null && y != null) {
           // 在空检测后，x 与 y 会自动转换为非空值（non-nullable）
           println(x * y)
       }
       else {
           println("'$arg1' or '$arg2' is not a number")
       }
   }
   
   fun main() {
       printProduct("6", "7")
       printProduct("a", "7")
       printProduct("a", "b")
   }
   

9. 类型检测与自动类型转换
   is 运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换：

   fun getStringLength(obj: Any): Int? {
       if (obj is String) {
           // `obj` 在该条件分支内自动转换成 `String`
           return obj.length
       }
   
       // 在离开类型检测分支后，`obj` 仍然是 `Any` 类型
       return null
   }
   
   
   fun main() {
       fun printLength(obj: Any) {
           println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a string"} ")
       }
       printLength("Incomprehensibilities")
       printLength(1000)
       printLength(listOf(Any()))
   }
   

10. for循环

    fun main() {
        val items = listOf("apple", "banana", "kiwifruit")
        for (item in items) {
            println(item)
        }
    }
    ----
    apple
    banana
    kiwifruit
    

11. while循环

    fun main() {
        val items = listOf("apple", "banana", "kiwifruit")
        var index = 0
        while (index < items.size) {
            println("item at $index is ${items[index]}")
            index++
        }
    }
    --------
    item at 0 is apple
    item at 1 is banana
    item at 2 is kiwifruit
    

12. when表达式

    fun describe(obj: Any): String =
        when (obj) {
            1          -> "One"
            "Hello"    -> "Greeting"
            is Long    -> "Long"
            !is String -> "Not a string"
            else       -> "Unknown"
        }
    
    fun main() {
        println(describe(1))
        println(describe("Hello"))
        println(describe(1000L))
        println(describe(2))
        println(describe("other"))
    }
    
    ---------
    One
    Greeting
    Long
    Not a string
    Unknown
    

13. 使用区间（range）

    使用 in 运算符来检测某个数字是否在指定区间内：

    fun main() {
        val x = 10;
        val y = 9;
        if (x in 1..y+1)
            println("fits in range")
    }
    ---------------
    fits in range
    

    检测某个数字是否在指定区间外:

    fun main() {
        val list = listOf("a", "b", "c")
    
        if (-1 !in 0..list.lastIndex) {
            println("-1 is out of range")
        }
        
        if (list.size !in list.indices) {
            println("list size is out of valid list indices range, too")
        }
    }
    ----
    -1 is out of range
    list size is out of valid list indices range, too
    

    区间迭代

    fun main() {
        for (x in 1..5) {
            println(x)
        }
    }
    

    或数列迭代：

    fun main() {
        for (x in 1..10 step 2) {
            print(x)
        }
        println()
        for (x in 9 downTo 0 step 3) {
            print(x)
        }
    }
    ----------
    13579
    9630
    

14. 集合

    对集合进行迭代:

    fun main() {
        val items = listOf("apple", "banana", "kiwifruit")
        for (item in items) {
            println(item)
        }
    }
    -------
    apple
    banana
    kiwifruit
    

    使用 in 运算符来判断集合内是否包含某实例

    fun main() {
        val items = setOf("apple", "banana", "kiwifruit")
        when {
            "orange" in items -> println("juicy")
            "apple" in items -> println("apple is fine too")
        }
    }
    ------
    apple is fine too
    

15. 创建基本累及实例

    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))
        }
    }
    -------
    Area of rectangle is 10.0, its perimeter is 14.0
    Area of triangle is 6.0, its perimeter is 12.0