Kotlin中const修饰符详解

在kotlin中一个变量如果可修改则申明为var，只读则申明为val，这大家都知道，但是有个小问题不禁让我陷入了沉思……

这const修饰符是干啥用的？跟其他语言比一下，const就是代表不可修改，然而val已经能表达出类似的意思了呢。

查看kotlin in action，pdf文档里面介绍const的用法如下（E文的，以我这辣鸡水平都能看个大概，此书也没有多少生僻的单词，如果有，还有啥是翻译不能解决的呢？如果有道不行，那就谷歌）：

大致意思是在kotlin中的顶级属性，会以getter（val 和 var）/setter（var才有）的形式暴露给Java，如果你想让其以public static final的字段呈现给调用者，可以在var 或者val前面加上const修饰符。

话说回来，那么cosnt到底可以在哪些地方修饰val或者var变量呢？官方文档也没有文字明确说在哪里可以使用const，但是有个例子，然后结合kotlin in action里面的只言片语，如下：

不难得出结论：

kotlin中const只能用在顶级属性，以及object对象的属性中（伴随对象也是obejct）。

按照第一个图E文表达的意思，那我是不是可以认为const对于纯kotlin开发者来说，此修饰符可有可无？（大胆假设，小心求证）来写段代码验证下。

MainTest.kt

@file:JvmName("ConstTest")

import kotlin.reflect.jvm.internal.impl.load.kotlin.JvmType

fun main(args: Array<String>) {
    println(age)
    println(test1.name)
    println(Person.sex)

    println(age1)
    println(test1.name1)
    println(Person.sex1)
}

const val age: Int = 28
val age1: Int = 28

object test1 {
    const val name: String = "liuliqianxiao"
    val name1: String = "liuliqianxiao"
}

class Person {
    companion object {
        const val sex: Int = 1
        val sex1: Int = 1
    }
}

带1的属性是没有用const修饰的，没带1的属性是用了const修饰的，可以看见在kotlin中，有没有const修饰好像没有任何影响。（每当要下结论的时候，心里总是忐忑的，害怕盲人摸象，以偏概全）

那我们继续看从java中调用kotlin是，const修饰符的影响。

先贴出正确的调用，然后说说为什么这样。

public class Test {

    public static void main(String[] args) {
        //top-level属性，单利对象的属性，类的伴随对象的属性，在没有加const修饰时应该如此调用
        System.out.println(ConstTest.getAge1());
        System.out.println(test1.INSTANCE.getName1());
        System.out.println(Person.Companion.getSex1());

        //加了const修饰之后的调用
        System.out.println(ConstTest.age);
        System.out.println(test1.name);
        System.out.println(Person.sex);

    }

}

为什么会有这些差别呢？大略一看，没用cosnt修饰的，都是用的getter去获取的，猜测应该是编译成了备用字段，然后生成了getter方法。而用了const修饰符的属性则直接是静态属性。

同时，从这的调用方式来看，这里会有一个假象，那就是加了const修饰符，就有点像在java中给属性加了static一样。

进一步从kotlin文件编译成的java文件去印证，先贴出整个kotlin文件反编译之后的java文件：

// test1.java
import kotlin.Metadata;
import org.jetbrains.annotations.NotNull;

@Metadata(
   mv = {1, 1, 1},
   bv = {1, 0, 0},
   k = 1,
   d1 = {"u0000u0014
u0002u0018u0002
u0002u0010u0000
u0002u0002
u0002u0010u000e
u0002u0004Æu0002u0018u00002u00020u0001Bu0007u0002¢u0006u0002u0010u0002Ru000eu0010u0003u001au00020u0004Xu0086T¢u0006u0002
u0000Ru0014u0010u0005u001au00020u0004Xu0086D¢u0006
u0000u001au0004u0006u0010u0007¨u0006"},
   d2 = {"Ltest1;", "", "()V", "name", "", "name1", "getName1", "()Ljava/lang/String;", "production sources for module LearnKotlin"}
)
public final class test1 {
   @NotNull
   public static final String name = "liuliqianxiao";
   @NotNull
   private static final String name1 = "liuliqianxiao";
   public static final test1 INSTANCE;

   @NotNull
   public final String getName1() {
      return name1;
   }

   private test1() {
      INSTANCE = (test1)this;
      name1 = "liuliqianxiao";
   }

   static {
      new test1();
   }
}
// Person.java
import kotlin.Metadata;
import kotlin.jvm.internal.DefaultConstructorMarker;

@Metadata(
   mv = {1, 1, 1},
   bv = {1, 0, 0},
   k = 1,
   d1 = {"u0000f
u0002u0018u0002
u0002u0010u0000
u0002u0003u0018u0000 u00032u00020u0001:u0001u0003Bu0005¢u0006u0002u0010u0002¨u0006u0004"},
   d2 = {"LPerson;", "", "()V", "Companion", "production sources for module LearnKotlin"}
)
public final class Person {
   public static final int sex = 1;
   private static final int sex1 = 1;
   public static final Person.Companion Companion = new Person.Companion((DefaultConstructorMarker)null);

   @Metadata(
      mv = {1, 1, 1},
      bv = {1, 0, 0},
      k = 1,
      d1 = {"u0000u0014
u0002u0018u0002
u0002u0010u0000
u0002u0002
u0002u0010
u0002u0004u0086u0003u0018u00002u00020u0001Bu0007u0002¢u0006u0002u0010u0002Ru000eu0010u0003u001au00020u0004Xu0086T¢u0006u0002
u0000Ru0014u0010u0005u001au00020u0004Xu0086D¢u0006
u0000u001au0004u0006u0010u0007¨u0006"},
      d2 = {"LPerson$Companion;", "", "()V", "sex", "", "sex1", "getSex1", "()I", "production sources for module LearnKotlin"}
   )
   public static final class Companion {
      public final int getSex1() {
         return Person.sex1;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
// ConstTest.java
import kotlin.Metadata;
import kotlin.jvm.JvmName;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

@Metadata(
   mv = {1, 1, 1},
   bv = {1, 0, 0},
   k = 2,
   d1 = {"u0000u001c
u0000
u0002u0010
u0002u0004
u0002u0010u0002
u0000
u0002u0010u0011
u0002u0010u000e
u0002u0002u001au0019u0010u0005u001au00020u00062fu0010u0007u001au0012u0004u0012u00020	0¢u0006u0002u0010
"u000eu0010u0000u001au00020u0001Xu0086T¢u0006u0002
u0000"u0014u0010u0002u001au00020u0001Xu0086D¢u0006
u0000u001au0004u0003u0010u0004¨u0006u000b"},
   d2 = {"age", "", "age1", "getAge1", "()I", "main", "", "args", "", "", "([Ljava/lang/String;)V", "production sources for module LearnKotlin"}
)
@JvmName(
   name = "ConstTest"
)
public final class ConstTest {
   public static final int age = 28;
   private static final int age1 = 28;

   public static final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
   }

   public static final int getAge1() {
      return age1;
   }
}

默认kotlin文件编译成的类名应该是kotlin文件名+“KT.java”，比如我这里应该是叫MainTestKT.java,但是我在kotlin文件的第一行用了如下注解

@file:JvmName("ConstTest")，到时候顶级属性，顶级函数等等都可以归属到ConstTest这个类下面去。这一点要稍微说明一下。

首先我们要说的是为什么说加了const，就相当于在java中给变量加上了static是一种假象。

public static final int age = 28;
private static final int age1 = 28;

public static final String name = "liuliqianxiao";
private static final String name1 = "liuliqianxiao";

public static final int sex = 1;
private static final int sex1 = 1;

可以发现，有没有加const，这里用来测试的几个属性都被编译成static final。我们知道val对应java中final，var对应java中就是非final，所以const并不能决定static。（通过这里的介绍，我相信在此例的基础上稍加修改，不难发现static是在那些地方产生的。）

同时最明显的不同就是加了const就是public，不加const就是private修饰。const的作用就是把此处的默认的private给变成public，这里kotlin 官方文档也指出了此点：

没加const的时候，采用getter获取属性，对于顶级属性和object里定义的属性调用方法还略有不同：

System.out.println(ConstTest.getAge1());
System.out.println(test1.INSTANCE.getName1());
System.out.println(Person.Companion.getSex1());

top-lelve属性没加const时，直接是在编译后的java类名下调用getter。而object和company object里面的属性没加const时，要通过实例去调用getter。看看反编译的文件内容，也能知道这是为什么。

至此cosnt用法以及从从java中调用kotlin中带const修饰的属性的原理就说完了。

思维很混乱，一本正经的胡说八道。