vlambda博客
学习文章列表

如前所述，类可以具有状态。在 Kotlin 中，类的状态由 属性<表示 /跨度>。让我们看一下蓝莓纸杯蛋糕的例子：

class BlueberryCupcake {
  var flavour = "Blueberry"
}

  BlueberryCupcake 类有一个 has-a 属性String 类型的“literal">风味。

当然，我们可以有 BlueberryCupcake 类的 instances：

fun main(args: Array<String>) {
    val myCupcake = BlueberryCupcake()
    println("My cupcake has ${myCupcake.flavour}")
}

现在，因为我们将 flavour 属性声明为变量，所以它的内部值可以在运行时更改：

fun main(args: Array<String>) {
    val myCupcake = BlueberryCupcake()
    myCupcake.flavour = "Almond"
    println("My cupcake has ${myCupcake.flavour}")
}

这在现实生活中是不可能的。纸杯蛋糕不会改变它们的味道（除非它们变得陈旧）。如果我们将 flavour 属性更改为一个值，它就不能被修改：

class BlueberryCupcake {
    val flavour = "Blueberry"
}

fun main(args: Array<String>) {
    val myCupcake = BlueberryCupcake()
    myCupcake.flavour = "Almond" //Compilation error: Val cannot be reassigned
    println("My cupcake has ${myCupcake.flavour}")
}

让我们为杏仁纸杯蛋糕声明一个新类：

class AlmondCupcake {
    val flavour = "Almond"
}

fun main(args: Array<String>) {
    val mySecondCupcake = AlmondCupcake()
    println("My second cupcake has ${mySecondCupcake.flavour} flavour")
}

这里有一些可疑的东西。 BlueberryCupcake 和AlmondCupcake结构相同；只有一个内部值被改变。

在现实生活中，您没有不同的烤模来搭配不同的纸杯蛋糕口味。同一个质量好的烤盘可以用来做各种口味。同样，一个设计良好的 Cupcake 类可以用于不同的实例：

class Cupcake(flavour: String) { 
  val flavour = flavour
}

Cupcake 类有一个带有参数 flavour 的构造函数，该参数分配给 flavour 值。

因为这是一个很常见的习语，所以 Kotlin 有一点语法糖来更简洁地定义它：

class Cupcake(val flavour: String)

现在，我们可以定义几个instances 有不同的口味：

fun main(args: Array<String>) {
    val myBlueberryCupcake = Cupcake("Blueberry")
    val myAlmondCupcake = Cupcake("Almond")
    val myCheeseCupcake = Cupcake("Cheese")
    val myCaramelCupcake = Cupcake("Caramel")
}

在 Kotlin 中，类的行为由方法定义。从技术上讲，method 是 member函数，因此，我们在接下来的章节中学到的任何关于函数的知识也适用于方法：

class Cupcake(val flavour: String) {
  fun eat(): String {
    return "nom, nom, nom... delicious $flavour cupcake"
  }
}

eat() 方法返回一个 String 值。现在，让我们调用 eat() 方法，如下代码所示：

fun main(args: Array<String>) {
    val myBlueberryCupcake = Cupcake("Blueberry")
    println(myBlueberryCupcake.eat())
}

following 表达式是 preceding 代码：

没有什么令人兴奋的，但这是我们的第一种方法。稍后，我们会做更多有趣的事情。

对象也可以有名称。这种object称为object declaration ：

object Oven {
  fun process(product: Bakeable) {
    println(product.bake())
  }
}

fun main(args: Array<String>) {
    val myAlmondCupcake = Cupcake("Almond")
    Oven.process(myAlmondCupcake)
}

对象是单例；你不需要实例化 Oven 来使用它。对象还可以扩展其他类型：

interface Oven {
  fun process(product: Bakeable)
}

object ElectricOven: Oven {
  override fun process(product: Bakeable) {
    println(product.bake())
  }
}

fun main(args: Array<String>) {
    val myAlmondCupcake = Cupcake("Almond")
    ElectricOven.process(myAlmondCupcake)
}

在类/接口中声明的 Objects 可以标记为 companion 对象。观察以下代码中 companion 对象的使用：

class Cupcake(flavour: String) : BakeryGood(flavour), Bakeable {
  override fun name(): String { 
    return "cupcake" 
  } 

  companion object { 
    fun almond(): Cupcake { 
      return Cupcake("almond") 
    } 

    fun cheese(): Cupcake { 
      return Cupcake("cheese") 
    } 
  } 
}

现在，可以直接使用伴生对象中的方法，使用类名而不实例化它：

fun main(args: Array<String>) {
    val myBlueberryCupcake: BakeryGood = Cupcake("Blueberry")
    val myAlmondCupcake = Cupcake.almond()
    val myCheeseCupcake = Cupcake.cheese()
    val myCaramelCupcake = Cupcake("Caramel")
}

伴随对象的方法不能从实例中使用：

fun main(args: Array<String>) {
    val myAlmondCupcake = Cupcake.almond()
    val myCheeseCupcake = myAlmondCupcake.cheese() //Compilation error: Unresolved reference: cheese
}

Companion 对象可以在类外部用作名称为 Companion 的值：

fun main(args: Array<String>) {
    val factory: Cupcake.Companion = Cupcake.Companion
}

或者，Companion 对象可以有一个名称：

class Cupcake(flavour: String) : BakeryGood(flavour), Bakeable {
    override fun name(): String {
        return "cupcake"
    }

    companion object Factory {
        fun almond(): Cupcake {
            return Cupcake("almond")
        }

        fun cheese(): Cupcake {
            return Cupcake("cheese")
        }
    }
}

fun main(args: Array<String>) {
    val factory: Cupcake.Factory = Cupcake.Factory
}

它们也可以不带名称使用，如以下代码所示：

fun main(args: Array<String>) {
    val factory: Cupcake.Factory = Cupcake
}

不要被这种语法所迷惑。  Cupcake 不带括号的值是伴生对象； Cupcake() 是一个实例。

检查 null 作为 if 块中的条件：

fun main(args: Array<String>) {
    val nullableCupcake: Cupcake? = Cupcake.almond()

    if (nullableCupcake != null) {
      nullableCupcake.eat()
    }
}

Kotlin 将做一个聪明的演员。在 if 块中，nullableCupcake 是 Cupcake，而不是 纸杯蛋糕？;因此，可以访问任何方法或属性。

这类似于 previous 之一，但它直接检查类型：

if (nullableCupcake is Cupcake) {
  nullableCupcake.eat()
}

它也适用于 when：

when (nullableCupcake) {
  is Cupcake -> nullableCupcake.eat()
}

检查 null 和非 null 类型的这两个选项都有点冗长。让我们检查一下其他选项。

安全调用让您可以访问方法和属性 如果值不为空，则为可空值（在底层，在字节码级别，安全调用被转换为 if(x != null)）：

nullableCupcake?.eat()

但是，如果你在表达式中使用它呢？

val result: String? = nullableCupcake?.eat()

如果我们的值为 null，它将返回 null，因此 result 必须具有 String? 类型。

这为在链上使用安全调用提供了机会，如下所示：

val length: Int? = nullableCupcake?.eat()?.length

如果为 null，则 Elvis 运算符 (?:) 返回 alternative 值值用于表达式：

val result2: String = nullableCupcake?.eat() ?: ""

如果 nullabluCupcake?.eat() 为 null，则 ?:  ;运算符将返回替代值 ""。

显然，Elvis 运算符可以与一系列安全调用一起使用：

val length2: Int = nullableCupcake?.eat()?.length ?: 0

代替 null 值， !! 运算符将 throw 一个 NPE：

val result: String = nullableCupcake!!.eat()

如果您可以处理 NPE， !! 运算符为您提供了一个非常方便的功能，即免费的智能转换：

val result: String = nullableCupcake!!.eat()

val length: Int = nullableCupcake.eat().length

如果 nullableCupcake!!.eat() 没有抛出 NPE，Kotlin 会将其类型从 Cupcake? 更改为 Cupcake 从下一行开始。

Kotlin 中的所有类型都扩展自 Any 类型（稍等，实际上这不是真的，但为了便于解释，请耐心等待）。

我们创建的每个类和接口隐式 扩展Any。所以，如果我们写一个 method 以 Any 作为参数，它将收到任何值：

fun main(args: Array<String>) {

    val myAlmondCupcake = Cupcake.almond()

    val anyMachine = object : Machine<Any> {
      override fun process(product: Any) {
        println(product.toString())
      }
    }

    anyMachine.process(3)

    anyMachine.process("")

    anyMachine.process(myAlmondCupcake)    
}

可空值呢？让我们看一下：

fun main(args: Array<String>) {

    val anyMachine = object : Machine<Any> {
      override fun process(product: Any) {
        println(product.toString())
      }
    }

    val nullableCupcake: Cupcake? = Cupcake.almond()

    anyMachine.process(nullableCupcake) //Error:(32, 24) Kotlin: Type mismatch: inferred type is Cupcake? but Any was expected
}

Any 与任何其他类型相同，也有一个可以为空的对应物，Any?。  Any 扩展自 Any?。所以，最后，Any? 是 Kotlin 类型系统层次结构的顶级类。

由于其类型推断和表达式评估，有时在 Kotlin 中存在 expressions 并不清楚返回的是哪种类型。大多数语言通过返回可能的类型选项之间的最小公共类型来解决这个问题。 Kotlin 采取了不同的路线。

让我们看一个模棱两可的表达式的例子：

fun main(args: Array<String>) {
    val nullableCupcake: Cupcake? = Cupcake.almond()

    val length = nullableCupcake?.eat()?.length ?: ""
}

length 有什么类型？ Int 还是 String？不，length value 的类型是 Any。很合乎逻辑。 Int 和 String 之间的最小通用类型是 Any。到目前为止，一切都很好。现在让我们看下面的代码：

val length = nullableCupcake?.eat()?.length ?: 0.0

按照该逻辑，在这种情况下，length 应该具有 Number type ( Int 和 Double 之间的通用类型，不是吗？

错了， length 仍然是 Any。在这些情况下，Kotlin 不会搜索最小通用类型。如果你想要一个特定的类型，它必须显式声明：

val length: Number = nullableCupcake?.eat()?.length ?: 0.0

Kotlin 没有返回 void 的方法（就像 Java 或 C 那样）。相反，一个方法（或者，准确地说，一个表达式）可以有一个 Unit 类型。

Unit 类型意味着调用 expression 是因为它的副作用，而不是它的回报。 classic Unit 表达式的示例是 println()，一种仅为其副作用而调用的方法。

Unit 与任何其他 Kotlin 类型一样，从 Any 扩展而来，并且可以为空。 Unit? 看起来很奇怪而且没有必要，但需要与类型系统保持一致。拥有一致的类型系统有几个优点，包括更好的编译时间和工具：

anyMachine.process(Unit)

Nothing 是位于整个 Kotlin 层次结构的 bottom 的类型. Nothing 扩展了所有 Kotlin 类型，包括 Nothing?。

但是，为什么我们需要 Nothing 和 Nothing? 类型？

Nothing 表示无法执行的表达式（基本上是抛出异常):

val result: String = nullableCupcake?.eat() ?: throw RuntimeException() // equivalent to nullableCupcake!!.eat()

在 Elvis 运算符的一方面，我们有一个 String。另一方面，我们有 Nothing。因为 String 和 Nothing 的共同类型是 String （而不是 < code class="literal">Any)，值 result 是一个 String。

Nothing 对编译器也有特殊意义。一旦在表达式上返回 Nothing type，之后的行将被标记为不可访问。

Nothing? 是空值的类型：

val x: Nothing? = null

val nullsList: List<Nothing?> = listOf(null)

创建主要目的是保存数据的类是 Kotlin 中的 common 模式（在其他语言中也是一种常见模式，想想JSON 或 Protobuff）。

为此，Kotlin 有一个特殊的类：

data class Item(val product: BakeryGood,
  val unitPrice: Double,
  val quantity: Int)

声明数据类，有一些限制：

有了这些限制，数据类带来了很多好处。

val myItem = Item(myAlmondCupcake, 0.40, 5)

val mySecondItem = myItem.copy(product = myCaramelCupcake) //named parameter

val (prod: BakeryGood, price: Double, qty: Int) = mySecondItem

val (prod, price, qty) = mySecondItem

val (prod, _, qty) = mySecondItem

注释是一种将元信息附加 元信息（例如文档、配置等）的方法。

让我们看下面的示例代码：

annotation class Tasty

annotation 本身可以被注释以修改其行为：

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Tasty

在这种情况下，可以在类、接口和对象上设置Tasty注解，并且可以在运行时进行查询。

有关选项的完整列表，请查看 Kotlin 文档。

注释可以有一个限制参数，它们不能为空：

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Tasty(val tasty:Boolean = true)

@Tasty(false)
object ElectricOven : Oven {
  override fun process(product: Bakeable) {
    println(product.bake())
  }
}

@Tasty
class CinnamonRoll : Roll("Cinnamon")

@Tasty
interface Fried {
  fun fry(): String
}

要在运行时查询注解值，我们必须使用反射 API（kotlin-reflect.jar 必须在您的类路径中）：

fun main(args: Array<String>) {
    val annotations: List<Annotation> = ElectricOven::class.annotations

    for (annotation in annotations) {
        when (annotation) {
            is Tasty -> println("Is it tasty? ${annotation.tasty}")
            else -> println(annotation)
        }
    }
}

Kotlin 中的枚举是一种定义 一组常量值的方法。 枚举作为配置值非常有用，但不限于此：

enum class Flour {
  WHEAT, CORN, CASSAVA
}

每个元素都是一个扩展 Flour 类的对象。

像任何对象一样，它们可以扩展接口：

interface Exotic {
  fun isExotic(): Boolean
}

enum class Flour : Exotic {
  WHEAT {
    override fun isExotic(): Boolean {
      return false 
    }
  },

  CORN {
    override fun isExotic(): Boolean {
      return false
    }
  },

  CASSAVA {
    override fun isExotic(): Boolean {
      return true
    }
  }
}

枚举也可以有抽象方法：

enum class Flour: Exotic {
  WHEAT {
    override fun isGlutenFree(): Boolean {
      return false
    }

    override fun isExotic(): Boolean {
      return false
    }
  },

  CORN {
    override fun isGlutenFree(): Boolean {
      return true
    }

    override fun isExotic(): Boolean {
      return false
    }
  },

  CASSAVA {
    override fun isGlutenFree(): Boolean {
      return true
    }

    override fun isExotic(): Boolean {
      return true
    }
  };

  abstract fun isGlutenFree(): Boolean
}

任何方法定义都必须在 (;) 分隔最后一个元素之后声明。

当枚举与 when 表达式一起使用时，Kotlin 的编译器会检查是否涵盖了所有情况（单独或使用 else）：

fun flourDescription(flour: Flour): String {
  return when(flour) { // error
    Flour.CASSAVA -> "A very exotic flavour"
  }
}

在这种情况下，我们只检查 CASSAVA 而不是其他元素；因此，它失败了：

fun flourDescription(flour: Flour): String {
  return when(flour) {
    Flour.CASSAVA -> "A very exotic flavour"
    else -> "Boring"
  }
}