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

• 1. val 和 var
• 2. fun
• 3. when
• 4. is 和 !is
• 5. lateinit
• 6. by
• 7. reified
• 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特有的关键字为开发者提供了更丰富、灵活的编程方式，使得代码更加简洁、易读和高效。