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 = {"\u0000\u0014\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0002\n\u0002\u0010\u000e\n\u0002\b\u0004\b?\u0002\u0018\u00002\u00020\u0001B\u0007\b\u0002￠\u0006\u0002\u0010\u0002R\u000e\u0010\u0003\u001a\u00020\u0004X\u0086T￠\u0006\u0002\n\u0000R\u0014\u0010\u0005\u001a\u00020\u0004X\u0086D￠\u0006\b\n\u0000\u001a\u0004\b\u0006\u0010\u0007¨\u0006\b"},
   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 = {"\u0000\f\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0003\u0018\u0000 \u00032\u00020\u0001:\u0001\u0003B\u0005￠\u0006\u0002\u0010\u0002¨\u0006\u0004"},
   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 = {"\u0000\u0014\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0002\n\u0002\u0010\b\n\u0002\b\u0004\b\u0086\u0003\u0018\u00002\u00020\u0001B\u0007\b\u0002￠\u0006\u0002\u0010\u0002R\u000e\u0010\u0003\u001a\u00020\u0004X\u0086T￠\u0006\u0002\n\u0000R\u0014\u0010\u0005\u001a\u00020\u0004X\u0086D￠\u0006\b\n\u0000\u001a\u0004\b\u0006\u0010\u0007¨\u0006\b"},
      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 = {"\u0000\u001c\n\u0000\n\u0002\u0010\b\n\u0002\b\u0004\n\u0002\u0010\u0002\n\u0000\n\u0002\u0010\u0011\n\u0002\u0010\u000e\n\u0002\b\u0002\u001a\u0019\u0010\u0005\u001a\u00020\u00062\f\u0010\u0007\u001a\b\u0012\u0004\u0012\u00020\t0\b￠\u0006\u0002\u0010\n\"\u000e\u0010\u0000\u001a\u00020\u0001X\u0086T￠\u0006\u0002\n\u0000\"\u0014\u0010\u0002\u001a\u00020\u0001X\u0086D￠\u0006\b\n\u0000\u001a\u0004\b\u0003\u0010\u0004¨\u0006\u000b"},
   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修饰的属性的原理就说完了。

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

时间： 2024-09-30 02:18:16

Kotlin---------------const详解的相关文章

c/c++中const详解

c/c++中const详解 来自http://blog.csdn.net/lwbeyond/article/details/6187501 一. cons 的作用 (1) 可以定义 const 常量 const int Max=100; int Array[Max]; (2) 可以保护被修饰的东西,防止意外的修改,增强程序的健壮性 如果在函数体内修改了i,编译器就会报错: void f (const int i) { i=10;//error! } (3) 为函数重载提供了一个参考 class 

【转】C++ 常量类型 const 详解

文章转自:http://www.cnblogs.com/daocaoren/archive/2011/07/14/2106278.html 1.什么是const? 常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的.(当然,我们可以偷梁换柱进行更新:) 2.为什么引入const? const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点. 3.cons有什么主要的作用?(1)可以定义const常量,具有不可变性. 例如: const in

const 详解

? 简单分类: 常变量        const 类型 变量名  或者   类型 const  变量名 常引用        const 类型& 引用名  或者  类型 const & 引用名 常对象        const 类名     对象名  或者  类名 const     对象名 常数组        const 类型     数组名   或者  类型  const     数组名 常成员函数    类名::fun(形参) const 常指针        const 类型*指

ECMAScript 6中let和const详解

1:Let命令 (1)Let定义块级作用域的变量,var定义的变量会提升.Let不会提升.如下.可以先用是undefined但是let在定义之前是不能用的.会报错Uncaught ReferenceError: letter is not defined(-) console.log(color) console.log(letter) var color = 'red'; let letter = 'a' 只要块级作用域内存在let命令,声明的变量不受外部影响. var tmp = 123;

Bill学C++ 第一季：const 详解

零.文章来由 打算将基础知识在看书的同时系统的整理一下,方便大家也方便自己.整理的知识尽量参照书本知识,比网上获取的资料有更高的可信度. 一.从 文字常量和常变量 开始 1.文字常量 程序中的特殊标识符或表达式,由于同时满足: (1)不可寻址(放在代码区) (2)值不可变 所以可视为文字常量.他们是 静态数组名.枚举变量.全局(静态变量)首地址.#define定义的常量. 整型文字常量: (1)前加0表示 八进制 (2)前加0x表示 十六进制 (3)后加L(推荐)或l,表示long类型 (4)后

c++ const详解

0x01:const常量 1 const int num = 10; 2 int a[num] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 3 cout << sizeof(a) << endl;//sizeof(a) 为 40  C++编译器对const做了优化,引用常量的地方,直接替换常量,不读内存,读取常量符号表 const int num = 10; int *p = const_cast<int *>(&num);*p =

[js高手之路] es6系列教程 - var, let, const详解

function show( flag ){             console.log( a );             if( flag ){                 var a = 'ghostwu';                 return a;             } else {                 console.log( a );                 return null;             }         } 我们从e

c++中const详解

C++中的const关键字的用法非常灵活,而使用const将大大改善程序的健壮性,本人根据各方面查到的资料进行总结如下,期望对朋友们有所帮助. Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的. 一.Const作用    如下表所示: No. 作用 说明 参考代码 1 可以定义const常量 const int Max = 100; 2 便于进行类型检查 const常量有数据类型,而宏常量没有数据类型.编译器可以对前者进行

let与const详解

在ES6中,js首次引入了块级作用域的概念,而什么是块级作用域? 众所就知,在js当中存在预解析的概念,就是变量提升.并且只存在全局作用域和私有作用域.在全局定义的变量就是全局变量,而在函数内部定义的变量称为私有变量.而在if判断和for循环之类的都是全局变量. 而块级作用域,就是在一个作用域中,该变量只能在声明后才能使用,并且该变量只在该作用域有效. 而let给js带来了块级作用域    那么我们就细讲一下let 1 //块级作用域的变量只能在块级作用域有效,否则报错 2 { 3 var a=

C++中的const详解

const的用法,特别是用在函数后面 在普通的非 const成员函数中,this的类型是一个指向类类型的 const指针.可以改变this所指向的值,但不能改变 this所保存的地址. 在 const成员函数中,this的类型是一个指向 const类类型对象的 const指针.既不能改变 this所指向的对象,也不能改变 this所保存的地址.   关键字:Const,Const函数,Const变量,函数后面的Const 看到const关键字,C++程序员首先想到的可能是const常量.这可不是