建议如何在Kotlin中创建常量?命名规则是什么?我在文档里没有找到。
companion object {
//1
val MY_CONST = "something"
//2
const val MY_CONST = "something"
//3
val myConst = "something"
}
或者…?
建议如何在Kotlin中创建常量?命名规则是什么?我在文档里没有找到。
companion object {
//1
val MY_CONST = "something"
//2
const val MY_CONST = "something"
//3
val myConst = "something"
}
或者…?
当前回答
在Kotlin中,如果你想创建在类中使用的局部常数,那么你可以像下面这样创建它
val MY_CONSTANT = "Constants"
如果你想在kotlin中创建一个公共常量,就像在java中创建public static final一样,你可以像下面这样创建它。
companion object{
const val MY_CONSTANT = "Constants"
}
其他回答
当地常量:
const val NAME = "name"
全局常量:
object MyConstants{
val NAME = "name"
val ID = "_id"
var EMAIL = "email"
}
访问MyConstants。的名字
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
在编译时已知的值可以(并且在我看来应该)被标记为常量。
命名约定应该遵循Java约定,并且在从Java代码中使用时应该正确可见(这在某种程度上很难通过伴生对象实现,但无论如何)。
正确的常量声明是:
const val MY_CONST = "something"
const val MY_INT = 1
像val一样,用const关键字定义的变量是不可变的。这里的区别在于,const用于编译时已知的变量。
声明一个变量const很像在Java中使用static关键字。
让我们看看如何在Kotlin中声明一个const变量:
const val COMMUNITY_NAME = "wiki"
用Java编写的类似代码是:
final static String COMMUNITY_NAME = "wiki";
加上上面的答案-
@JvmField可以用来指示Kotlin编译器不生成 getter /setter,并将其公开为字段。
@JvmField
val COMMUNITY_NAME = "Wiki"
静态字段
在命名对象或伴生对象中声明的Kotlin属性 将有静态支持字段,无论是在该命名对象或 包含伴生对象的类。
通常这些字段是私有的,但它们可以通过以下方式之一公开:
@JvmField注释; lateinit修饰语; const修饰符。
更多详情请访问:https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#instance-fields
Something that isn't mentioned in any of the answers is the overhead of using companion objects. As you can read here, companion objects are in fact objects and creating them consumes resources. In addition, you may need to go through more than one getter function every time you use your constant. If all that you need is a few primitive constants on a few instances of your class, you'll probably just be better off using val to get a better performance and avoid the companion object. The trade off is higher memory consumption if you have many instances of your class so everyone should make their own decision.
TL,博士;文章:
使用伴侣对象实际上会将以下Kotlin代码:
class MyClass {
companion object {
private val TAG = "TAG"
}
fun helloWorld() {
println(TAG)
}
}
在这段Java代码中:
public final class MyClass {
private static final String TAG = "TAG";
public static final Companion companion = new Companion();
// synthetic
public static final String access$getTAG$cp() {
return TAG;
}
public static final class Companion {
private final String getTAG() {
return MyClass.access$getTAG$cp();
}
// synthetic
public static final String access$getTAG$p(Companion c) {
return c.getTAG();
}
}
public final void helloWorld() {
System.out.println(Companion.access$getTAG$p(companion));
}
}