在 Kotlin 中创建常量

1. 在 Kotlin 中使用类常量
2. 在 Kotlin 中使用单例
3. 在 Kotlin 中使用顶级常量
4. 在 Kotlin 中使用包含常量的单独文件
5. 结论

常量用于存储其值始终已知的数据，并且在程序执行期间数据不会改变。常量与变量的区别在于变量可以在程序执行期间改变数据。

例如，假设你正在开发一个摩托车模拟器。摩托车的不同特性在其整个生命周期中永远不会改变，例如车轮的数量。

为确保车轮数量不变，我们在应用程序中声明一个常量，并将其分配给摩托车可以拥有的车轮数量。我们使用常量来避免用户输入的错误，例如为摩托车提供四个轮子而不是两个轮子。

在本教程中，我们将学习如何在 Kotlin 中创建常量、使用的命名约定以及如何将它们包含在你的应用程序中。

在 Kotlin 中使用类常量

转到 IntelliJ 并选择 File > New > Project 创建一个新的 Kotlin 项目。输入 kotlinConstants 作为项目名称或任何首选名称。

在 Language 部分选择 Kotlin，在 Build System 部分选择 Intellij。按创建按钮创建项目。

在 kotlin 文件夹下创建文件夹结构 com/constants。在 constants 文件夹下创建一个 Main.kt 文件，并将以下代码复制并粘贴到该文件中。

package com.constants

class Car(private val name: String){
    /**
     * This is a constant that is only used
     * inside this class
     */
    private val numberOfWheels = 4
    /**
     * The companion object defines a constant
     * that exists only as a single copy and
     * Can also be used outside the class
     */
    companion object{
        const val NUMBER_OF_WHEELS = 4
    }
    fun showMessage(): String{
        return "A ${this.name} has ${this.numberOfWheels} wheels"
    }

}
fun main() {
    val nissan = Car("Nissan");
    println(nissan.showMessage());
    println("Number of wheels = ${Car.NUMBER_OF_WHEELS}");
}

我们在 Car 类中声明了两个常量；使用 private 关键字声明的第一个常量仅用于此类，不能从类外部访问。

至于命名约定，我们使用了驼峰命名约定，因为它只在类内部使用。

第二个常量在类的伴生对象中声明。伴随对象用于声明属于此类的常量和函数，这意味着它不能使用类对象实例化。

这些常量类似于 Java 中的静态字段和方法。为了调用常量，我们通常使用类，因为只存在一个常量副本。

伴随对象内声明的常量可以从类外部访问，这些常量使用的命名约定是大写字母和下划线的组合。

主方法调用 Car() 创建一个新的 Car 对象。showMessage() 方法使用类中使用的常量将包含该值的消息记录到控制台。

最后一条 println() 消息记录了使用伴随对象声明的常量的值。运行代码以验证程序是否输出以下内容。

输出：

A Nissan has 4 wheels
Number of wheels = 4

在 Kotlin 中使用单例

单例是编程中的一种设计模式，尤其是在高级语言中。当我们有需要在应用程序中共享的资源以及创建资源成本高昂的情况时，使用单例设计模式。

请注意，当你使用单例时，在应用程序的整个生命周期中只会创建一个实例。

注释前面的代码，将下面的代码复制粘贴到注释后的 Main.kt 文件中。

package com.constants

object Configuration{
    const val USERNAME = "john"
    const val PASSWORD = "1234"
}

fun userLogin(user: String, pass: String): String{
    return "$user logged in with password $pass"
}

fun main() {
    println(userLogin(Configuration.USERNAME,
        Configuration.PASSWORD));
}

在这个例子中，我们使用 object 关键字创建了一个单例。当你想在 Kotlin 中创建单例时，请始终使用此语法。

在幕后，编译器将构造函数设为私有，创建我们的 Configuration 的引用，并在静态块中对其进行初始化。只有在我们第一次访问任何静态字段时，才会初始化单例。

userLogin() 是我们定义的用于使用单例属性的自定义方法。要访问这些值，我们调用单例名称后跟属性名称。

这类似于我们对伴随对象中声明的常量所做的事情，但这种方法的资源密集度较低。运行代码并验证程序是否输出以下内容。

输出：

john logged in with password 1234

在 Kotlin 中使用顶级常量

注释前面的代码，将下面的代码复制粘贴到注释后的 Main.kt 文件中。

package com.constants

const val CONNECTION_POOL = 10

class DBDriver{
   companion object{
       fun isConnectionExceeded(value: Int): Boolean{
           return (value > CONNECTION_POOL)
       }
   }
}

fun main() {
    println(DBDriver.isConnectionExceeded(11));
}

顶级常量不包含在函数、类或接口中，这意味着你可以从类外部调用它们而无需创建任何对象。

在此示例中，我们声明了一个名为 CONNECTION_POOL 的顶级常量，并通过传递其名称在 isConnectionExceeded() 方法中使用它。

运行代码并注意常量值像往常一样被读取以执行预期的计算，如下所示。

输出：

true

在 Kotlin 中使用包含常量的单独文件

在 com​​ 文件夹下创建一个名为 consts 的新包。在 consts 文件夹下创建一个名为 NetConstants.kt 的文件，然后将以下代码复制并粘贴到该文件中。

package com.consts

const val PORT = 8080
const val PROTOCOL = "DNS"
const val HOST_ADDRESS = "192.168.1.0"

上述文件中定义的常量类似于顶级常量，但与其他应用程序部分在单独的文件中声明。

以下示例显示了在同一应用程序的单独文件中使用常量。注释我们在 Main.kt 文件中介绍的最后一个示例，并将以下代码复制并粘贴到注释后的文件中。

package com.constants

import com.consts.HOST_ADDRESS
import com.consts.PORT
import com.consts.PROTOCOL

class Server{
   companion object{
       fun connectServer(port: Int, protocol: String, host: String): String{
           return "application connected to " +
                   "$host using port " +
                   "$port through" +
                   " $protocol"
       }
   }
}
fun main() {
    println(Server.connectServer(PORT, PROTOCOL, HOST_ADDRESS));
}

此示例定义了在类的伴随对象中声明的 connectServer() 方法。该方法使用我们在 NetConstants.kt 文件中定义的三个常量。

这是通过将常量名称传递给方法并将完全限定的常量名称导入类来实现的。以下是我们运行应用程序后的输出：

application connected to 192.168.1.0 using port 8080 through DNS

结论

在本教程中，我们学习了在 Kotlin 应用程序中创建常量的不同方法。我们学习的方法包括：使用类常量、单例和顶级常量，最后，我们介绍了如何使用在单独文件中声明的常量。