在Kotlin中，当我们声明变量时，有两个选项。'var'或'val'。 遵循变量的命名惯例，我认为我们可以简单地生成“常量”，这意味着我想要一个固定的值分配给一个特定的变量，就像下面的示例代码。

private val tag = "MainActivity"

我认为我们不需要像在Java世界中所做的那样，麻烦地使用大写字母来区分“常量”和变量。

当地常量:

const val NAME = "name"

全局常量:

object MyConstants{
    val NAME = "name"
    val ID = "_id"
    var EMAIL = "email"
}

访问MyConstants。的名字

在编译时已知的值可以(并且在我看来应该)被标记为常量。

命名约定应该遵循Java约定，并且在从Java代码中使用时应该正确可见(这在某种程度上很难通过伴生对象实现，但无论如何)。

正确的常量声明是:

const val MY_CONST = "something"
const val MY_INT = 1

在Kotlin中，如果你想创建在类中使用的局部常数，那么你可以像下面这样创建它

val MY_CONSTANT = "Constants"

如果你想在kotlin中创建一个公共常量，就像在java中创建public static final一样，你可以像下面这样创建它。

companion object{

     const val MY_CONSTANT = "Constants"

}

class Myclass {

    companion object {
        const val MYCONSTANT = 479
    }
}

你有两个选择，你可以使用const关键字或使用@JvmField，这使它成为java的静态最终常量。

class Myclass {

    companion object {
        @JvmField val MYCONSTANT = 479
    }
}

如果您使用@JvmField注释，那么在它编译之后，常量就会以java中调用它的方式为您放入。 就像你在java中调用它一样，当你在代码中调用同伴常量时，编译器会为你替换它。

但是，如果使用const关键字，则常量的值将内联。内联是指在编译后使用实际值。

所以总结一下编译器将为你做什么:

//so for @JvmField:

Foo var1 = Constants.FOO;

//and for const:

Foo var1 = 479

在Kotlin中有几种定义常量的方法，

使用伴随对象

    companion object {
        const val ITEM1 = "item1"
        const val ITEM2 = "item2"
    }

你可以在任何类中使用上面的同伴对象块，并在这个块中定义你的所有字段。但是这种方法有一个问题，文档说，

尽管伴随对象的成员看起来像其他语言中的静态成员，但在运行时，它们仍然是实际对象的实例成员，并且可以实现接口。

当你使用同伴对象创建常量，并看到反编译的字节码时，你会像下面这样:

  ClassName.Companion Companion = ClassName.Companion.$$INSTANCE;
  @NotNull
  String ITEM1 = "item1";
  @NotNull
  String ITEM2 = "item2";
 
  public static final class Companion {
     @NotNull
     private static final String ITEM1 = "item1";
     @NotNull
     public static final String ITEM2 = "item2";
     
     // $FF: synthetic field
     static final ClassName.Companion $$INSTANCE;

     private Companion() {
     }

     static {
        ClassName.Companion var0 = new ClassName.Companion();
        $$INSTANCE = var0;
     }
  }

从这里你可以很容易地看到文档说了什么，即使伴随对象的成员看起来像其他语言中的静态成员，在运行时，它们仍然是实际对象的实例成员。

现在有另一种方法，我们不需要像下面这样使用同伴对象，

object ApiConstants {
      val ITEM1: String = "item1"
 }

同样，如果你看到上述片段的字节代码的反编译版本，你会发现这样的东西，

public final class ApiConstants {
     private static final String ITEM1 = "item1";

     public static final ApiConstants INSTANCE;

     public final String getITEM1() {
           return ITEM1;
      }

     private ApiConstants() {
      }

     static {
         ApiConstants var0 = new ApiConstants();
         INSTANCE = var0;
         CONNECT_TIMEOUT = "item1";
      }
    }

现在，如果您看到上面的反编译代码，它正在为每个变量创建get方法。这个get方法根本不是必需的。

要摆脱这些get方法，你应该在val之前使用const，如下所示:

object ApiConstants {
     const val ITEM1: String = "item1"
 }

现在，如果您看到上述代码片段的反编译代码，您会发现它更容易阅读，因为它为您的代码进行了最少的后台转换。

public final class ApiConstants {
    public static final String ITEM1 = "item1";
    public static final ApiConstants INSTANCE;

    private ApiConstants() {
     }

    static {
        ApiConstants var0 = new ApiConstants();
        INSTANCE = var0;
      }
    }

所以这是创建常数的最好方法。