ค่าคงที่ใน Kotlin - วิธีที่แนะนำในการสร้างพวกเขาคืออะไร?

แนะนำให้สร้างค่าคงที่ใน Kotlin อย่างไร และแบบแผนการตั้งชื่อคืออะไร? ฉันไม่พบว่าในเอกสารประกอบ

companion object {
    //1
    val MY_CONST = "something"

    //2
    const val MY_CONST = "something"

    //3
    val myConst = "something"
}

หรือ ...?

ใน Kotlin ถ้าคุณต้องการสร้างค่าคงที่ท้องถิ่นซึ่งควรจะใช้กับในชั้นเรียนจากนั้นคุณสามารถสร้างมันได้ดังต่อไปนี้

val MY_CONSTANT = "Constants"

และถ้าคุณต้องการสร้างค่าคงที่สาธารณะใน kotlin เหมือนกับpublic static finalใน java คุณสามารถสร้างมันได้ดังต่อไปนี้

companion object{

     const val MY_CONSTANT = "Constants"

}

หลีกเลี่ยงการใช้วัตถุร่วม เบื้องหลังฮูดเมธอดอินสแตนซ์ getter และ setter ถูกสร้างขึ้นสำหรับฟิลด์ที่สามารถเข้าถึงได้ วิธีการโทรอินสแตนซ์มีราคาแพงกว่าการเรียกวิธีการทางเทคนิค

public class DbConstants {
    companion object {
        val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        val TABLE_USER_ATTRIBUTE_DATA = "data"
    }

objectแทนที่จะกำหนดค่าคงที่ใน

วิธีปฏิบัติที่แนะนำ :

object DbConstants {
        const val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        const val TABLE_USER_ATTRIBUTE_DATA = "data"
}

และเข้าถึงพวกเขาทั่วโลกเช่นนี้ DbConstants.TABLE_USER_ATTRIBUTE_EMPID

ก่อนอื่นแผนการตั้งชื่อใน Kotlin สำหรับค่าคงที่นั้นเหมือนกันใน java (เช่น: MY_CONST_IN_UPPERCASE)

ฉันจะสร้างมันได้อย่างไร

1. เป็นค่าระดับบนสุด (แนะนำ)

คุณเพียงแค่ต้องวาง const ของคุณนอกประกาศของชั้นเรียน

สองความเป็นไปได้ : ประกาศ const ของคุณในไฟล์คลาสของคุณ (const ของคุณมีความสัมพันธ์ที่ชัดเจนกับชั้นเรียนของคุณ)

private const val CONST_USED_BY_MY_CLASS = 1

class MyClass { 
    // I can use my const in my class body 
}

สร้างไฟล์ constants.kt เฉพาะที่จะเก็บ const ส่วนกลางทั้งหมด (ที่นี่คุณต้องการใช้ const ของคุณอย่างกว้างขวางในโครงการของคุณ):

package com.project.constants
const val URL_PATH = "https:/"

จากนั้นคุณเพียงแค่ต้องนำเข้าที่คุณต้องการ:

import com.project.constants

MyClass {
    private fun foo() {
        val url = URL_PATH
        System.out.print(url) // https://
    }
}

2. ประกาศในวัตถุที่เป็นคู่หู (หรือการประกาศวัตถุ)

สิ่งนี้น้อยกว่ามากเพราะอยู่ภายใต้ประทุนเมื่อมีการสร้างไบต์การ์ดจะสร้างวัตถุที่ไร้ประโยชน์:

MyClass {
    companion object {
        private const val URL_PATH = "https://"
        const val PUBLIC_URL_PATH = "https://public" // Accessible in other project files via MyClass.PUBLIC_URL_PATH
    }
}

ยิ่งแย่ไปกว่านั้นถ้าคุณประกาศว่ามันเป็น val แทนที่จะเป็น const (คอมไพเลอร์จะสร้างวัตถุที่ไร้ประโยชน์ + ฟังก์ชั่นไร้ประโยชน์):

MyClass {
    companion object {
        val URL_PATH = "https://"
    }
}

บันทึก :

ใน kotlin const สามารถเก็บประเภทดั้งเดิมได้ หากคุณต้องการส่งผ่านฟังก์ชั่นนั้นคุณต้องเพิ่มคำอธิบายประกอบ @JvmField ณ เวลารวบรวมมันจะถูกแปลงเป็นตัวแปรสแตติกสุดท้ายสาธารณะ แต่มันช้ากว่าแบบดั้งเดิม พยายามหลีกเลี่ยง

@JvmField val foo = Foo()

ค่าที่ทราบในเวลารวบรวมสามารถทำเครื่องหมาย (และในความเห็นของฉัน) ว่าเป็นค่าคงที่

ข้อตกลงการตั้งชื่อควรเป็นไปตามจาวาและควรมองเห็นได้อย่างถูกต้องเมื่อใช้จากโค้ดจาวา

ประกาศคงที่ที่เหมาะสมคือ:

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

คุณไม่ต้องการชั้นเรียนวัตถุหรือวัตถุร่วมเพื่อประกาศค่าคงที่ใน Kotlin คุณสามารถประกาศไฟล์ที่เก็บค่าคงที่ทั้งหมด (เช่นConstants.ktหรือคุณสามารถใส่ไว้ในไฟล์ Kotlin ที่มีอยู่) และประกาศค่าคงที่ภายในไฟล์นั้น ๆ ค่าคงที่ที่รู้จักในเวลารวบรวมจะต้องทำเครื่องหมายด้วยconstคงเป็นที่รู้จักกันที่รวบรวมเวลาต้องถูกทำเครื่องหมายด้วย

ดังนั้นในกรณีนี้มันควรจะเป็น:

const val MY_CONST = "something"

จากนั้นคุณสามารถนำเข้าค่าคงที่โดยใช้:

import package_name.MY_CONST

คุณสามารถอ้างอิงถึงลิงค์นี้

หากคุณใส่ const val valName = valValueก่อนชื่อคลาสด้วยวิธีนี้มันจะสร้าง

public static final YourClass.Ktที่จะมีpublic static finalค่า

Kotlin :

const val MY_CONST0 = 0
const val MY_CONST1 = 1
data class MyClass(var some: String)

Java decompiled:

public final class MyClassKt {
    public static final int MY_CONST0 = 0;
    public static final int MY_CONST1 = 1;
}
// rest of MyClass.java

class Myclass {

 companion object {
        const val MYCONSTANT = 479
}

คุณมีสองตัวเลือกคุณสามารถใช้constคำหลักหรือใช้@JvmFieldซึ่งทำให้ค่าคงที่สุดท้ายของจาวา

class Myclass {

     companion object {
           @JvmField val MYCONSTANT = 479
    }

หากคุณใช้@JvmFieldคำอธิบายประกอบแล้วหลังจากนั้นก็จะรวบรวมค่าคงที่ที่จะใส่เข้าไปในแบบที่คุณจะเรียกมันในภาษาจาวา
เช่นเดียวกับที่คุณเรียกมันว่าใน java คอมไพเลอร์จะแทนที่สิ่งนั้นให้คุณเมื่อคุณเรียกค่าคงที่ที่เป็นคู่หูในโค้ด

อย่างไรก็ตามถ้าคุณใช้คำสำคัญ const แล้วค่าของค่าคงที่จะได้รับการแทรก โดย inline i หมายถึงค่าจริงจะใช้หลังจากรวบรวม

เพื่อสรุปที่นี่คือสิ่งที่คอมไพเลอร์จะทำเพื่อคุณ:

//so for @JvmField:

Foo var1 = Constants.FOO;

//and for const:

Foo var1 = 479

Kotlin ค่าคงที่และค่าคงที่และวิธีการประกาศ

object MyConstant {

@JvmField   // for access in java code 
val PI: Double = 3.14

@JvmStatic // JvmStatic annotation for access in java code
fun sumValue(v1: Int, v2: Int): Int {
    return v1 + v2
}

}

เข้าถึงคุณค่าได้ทุกที่

val value = MyConstant.PI
val value = MyConstant.sumValue(10,5)

เช่นเดียวกับvalตัวแปรที่กำหนดด้วยconstคำสำคัญนั้นไม่เปลี่ยนรูป ความแตกต่างที่นี่คือที่constใช้สำหรับตัวแปรที่รู้จักกันในเวลารวบรวม

การประกาศตัวแปรconstนั้นเหมือนกับการใช้staticคำสำคัญใน Java

เรามาดูวิธีการประกาศตัวแปร const ใน Kotlin:

const val COMMUNITY_NAME = "wiki"

และรหัสอะนาล็อกที่เขียนใน Java จะเป็น:

final static String COMMUNITY_NAME = "wiki";

การเพิ่มคำตอบข้างต้น -

@JvmField จะถูกใช้เพื่อแนะนำคอมไพเลอร์ Kotlin ไม่ให้สร้าง getters / setters สำหรับคุณสมบัตินี้และแสดงเป็นฟิลด์

 @JvmField
 val COMMUNITY_NAME: "Wiki"

ฟิลด์คงที่

คุณสมบัติ Kotlin ที่ประกาศในวัตถุที่มีชื่อหรือวัตถุที่เป็นเพื่อนจะมีเขตข้อมูลสำรองคงที่ทั้งในวัตถุที่มีชื่อนั้นหรือในชั้นเรียนที่มีวัตถุสหาย

โดยปกติแล้วฟิลด์เหล่านี้จะเป็นแบบส่วนตัว แต่สามารถเปิดเผยได้ด้วยวิธีใดวิธีหนึ่งต่อไปนี้:

• @JvmField คำอธิบายประกอบ;
• lateinit ปรับปรุง;
• const ส่วนขยาย

รายละเอียดเพิ่มเติมได้ที่นี่ - https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#instance-fields

companion objectsบางสิ่งบางอย่างที่ไม่ได้กล่าวถึงในคำตอบที่เป็นค่าใช้จ่ายของการใช้ ตามที่คุณสามารถอ่านได้ที่นี่วัตถุสหายเป็นวัตถุในความเป็นจริงและสร้างพวกเขาใช้ทรัพยากร นอกจากนี้คุณอาจต้องใช้มากกว่าหนึ่งฟังก์ชัน getter ทุกครั้งที่คุณใช้ค่าคงที่ หากสิ่งที่คุณต้องการคือค่าคงที่แบบดั้งเดิมคุณจะใช้งานvalได้ดีขึ้นและหลีกเลี่ยงcompanion objectและหลีกเลี่ยง

TL; DR; ของบทความ:

การใช้ออบเจกต์ร่วมจะเปลี่ยนรหัสนี้จริง ๆ

class MyClass {

    companion object {
        private val TAG = "TAG"
    }

    fun helloWorld() {
        println(TAG)
    }
}

เป็นรหัสนี้:

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));
    }
}

ดังนั้นพยายามหลีกเลี่ยงพวกเขา

ค่าคงที่ท้องถิ่น:

const val NAME = "name"

ค่าคงที่ทั่วโลก:

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

เข้าถึง MyConstants.NAME

มีกี่วิธีที่คุณสามารถกำหนดค่าคงที่ใน 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 สำหรับแต่ละตัวแปร วิธีการรับนี้ไม่จำเป็นเลย

เพื่อกำจัดวิธีการรับเหล่านี้คุณควรใช้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;
      }
    }

ดังนั้นนี่คือวิธีที่ดีที่สุดในการสร้างค่าคงที่

สำหรับดั้งเดิมและเงื่อนไข:

/** The empty String. */
const val EMPTY_STRING = ""

สำหรับกรณีอื่น ๆ :

/** The empty array of Strings. */
@JvmField val EMPTY_STRING_ARRAY = arrayOfNulls<String>(0)

ตัวอย่าง:

/*
 * Copyright 2018 Vorlonsoft LLC
 *
 * Licensed under The MIT License (MIT)
 */

package com.vorlonsoft.android.rate

import com.vorlonsoft.android.rate.Constants.Utils.Companion.UTILITY_CLASS_MESSAGE

/**
 * Constants Class - the constants class of the AndroidRate library.
 *
 * @constructor Constants is a utility class and it can't be instantiated.
 * @since       1.1.8
 * @version     1.2.1
 * @author      Alexander Savin
 */
internal class Constants private constructor() {
    /** Constants Class initializer block. */
    init {
        throw UnsupportedOperationException("Constants$UTILITY_CLASS_MESSAGE")
    }

    /**
     * Constants.Date Class - the date constants class of the AndroidRate library.
     *
     * @constructor Constants.Date is a utility class and it can't be instantiated.
     * @since       1.1.8
     * @version     1.2.1
     * @author      Alexander Savin
     */
    internal class Date private constructor() {
        /** Constants.Date Class initializer block. */
        init {
            throw UnsupportedOperationException("Constants.Date$UTILITY_CLASS_MESSAGE")
        }

        /** The singleton contains date constants. */
        companion object {
            /** The time unit representing one year in days. */
            const val YEAR_IN_DAYS = 365.toShort()
        }
    }

    /**
     * Constants.Utils Class - the utils constants class of the AndroidRate library.
     *
     * @constructor Constants.Utils is a utility class and it can't be instantiated.
     * @since       1.1.8
     * @version     1.2.1
     * @author      Alexander Savin
     */
    internal class Utils private constructor() {
        /** Constants.Utils Class initializer block. */
        init {
            throw UnsupportedOperationException("Constants.Utils$UTILITY_CLASS_MESSAGE")
        }

        /** The singleton contains utils constants. */
        companion object {
            /** The empty String. */
            const val EMPTY_STRING = ""
            /** The empty array of Strings. */
            @JvmField val EMPTY_STRING_ARRAY = arrayOfNulls<String>(0)
            /** The part 2 of a utility class unsupported operation exception message. */
            const val UTILITY_CLASS_MESSAGE = " is a utility class and it can't be instantiated!"
        }
    }
}