详解 kotlin 相对 Java 特有的关键字及使用

文章目录

• • • [1. `val` 和 `var`](#1. val 和 var)
    • [2. `fun`](#2. fun)
    • [3. `when`](#3. when)
    • [4. `is` 和 `!is`](#4. is 和 !is)
    • [5. `lateinit`](#5. lateinit)
    • [6. `by`](#6. by)
    • [7. `reified`](#7. reified)
    • [8. `companion`](#8. companion)

本文首发地址：https://h89.cn/archives/366.html

最新更新地址：https://gitee.com/chenjim/chenjimblog

Kotlin 在兼容Java的基础上，引入了许多特有的关键字，这些关键字为Kotlin带来了简洁、高效的编程体验。以下详细介绍一些Kotlin特有的关键字及其使用：

1. val 和 var

• 作用 ：用于声明变量。val 声明的是不可变变量（类似于Java中的 final 变量），一旦赋值后不能再更改；var 声明的是可变变量。

• 示例 ：

  val name: String = "John"
  // name = "Jane" // 这行代码会报错，因为val声明的变量不可变
  
  var age: Int = 30
  age = 31

2. fun

• 作用：用于定义函数。与Java相比，Kotlin的函数定义语法更加简洁，参数类型在参数名之后声明。

• 示例 ：

  fun greet(name: String): String {
      return "Hello, $name!"
  }
  
  // 单表达式函数
  fun square(x: Int): Int = x * x

3. when

• 作用 ：替代Java中的 switch - case 语句，功能更强大，不仅可以用于基本类型，还可以用于对象、范围等，并且支持更灵活的条件判断。

• 示例 ：

  val number = 2
  val result = when (number) {
      1 -> "One"
      2 -> "Two"
      else -> "Other"
  }
  
  // 使用范围匹配
  val age = 25
  val ageGroup = when (age) {
      in 0..12 -> "Child"
      in 13..19 -> "Teenager"
      else -> "Adult"
  }
  
  // 使用对象类型匹配
  fun describe(obj: Any): String =
      when (obj) {
          is String -> "It's a string with length ${obj.length}"
          is Int -> "It's an integer"
          else -> "I don't know what it is"
      }

4. is 和 !is

• 作用 ：用于类型检查。is 检查对象是否为指定类型，!is 则相反。

• 示例 ：

  fun printType(obj: Any) {
      if (obj is String) {
          println("It's a string: $obj")
      } else if (obj!is Int) {
          println("It's not an integer")
      }
  }

5. lateinit

• 作用 ：用于声明一个非空类型的变量，但延迟初始化。这在变量无法在声明时初始化，但又不想使用可空类型的情况下很有用，比如在Android开发中，一些视图变量在 onCreate 方法中通过 findViewById 初始化。

• 示例 ：

  lateinit var myTextView: TextView
  
  fun setupView() {
      myTextView = findViewById(R.id.my_text_view)
      myTextView.text = "Hello"
  }

6. by

• 作用：用于委托属性和委托类。通过委托，一个类可以将部分功能委托给另一个类来实现，使代码更简洁、复用性更高。
• 示例 ：

  • 委托属性：

    class User {
        var name: String by Delegates.notNull()
    }
    
    fun main() {
        val user = User()
        user.name = "Alice"
        println(user.name)
    }

  • 委托类：

    interface MyInterface {
        fun doSomething()
    }
    
    class MyImplementation : MyInterface {
        override fun doSomething() {
            println("Doing something")
        }
    }
    
    class MyDelegator(myImplementation: MyImplementation) : MyInterface by myImplementation
    
    fun main() {
        val delegator = MyDelegator(MyImplementation())
        delegator.doSomething()
    }

7. reified

• 作用 ：用于内联函数中，使我们能够在运行时获取泛型参数的实际类型。在Java中，泛型类型在运行时会被擦除，而 reified 关键字可以解决这个问题。

• 示例 ：

  inline fun <reified T> printType() {
      println("The type is ${T::class.simpleName}")
  }
  
  fun main() {
      printType<String>()
  }

8. companion

• 作用：用于在类中定义伴生对象。伴生对象类似于Java中的静态成员，但功能更强大。它可以包含属性和方法，并且可以访问类的私有成员。

• 示例 ：

  class MyClass {
      private val privateValue = 42
  
      companion object {
          fun create(): MyClass {
              return MyClass()
          }
  
          val companionValue = 10
      }
  }
  
  fun main() {
      val myObject = MyClass.create()
      println(MyClass.companionValue)
  }

这些Kotlin特有的关键字为开发者提供了更丰富、灵活的编程方式，使得代码更加简洁、易读和高效。