ในฐานะภาษาโปรแกรม Kotlin มีคุณสมบัติและประโยชน์มากมายที่ทำให้เป็นตัวเลือกที่น่าสนใจสำหรับนักพัฒนา

แง่มุมหนึ่งของ Kotlin ที่ทำให้ Kotlin แตกต่างจากภาษาอื่นๆ เช่น Java คือวิธีการใช้คลาสยูทิลิ ตี้ โปรแกรมอรรถประโยชน์สามารถเป็นเครื่องมือที่มีประโยชน์ในการพัฒนาซอฟต์แวร์ แม้ว่าจะไม่ใช่ตัวเลือกที่ดีที่สุดเสมอไปเมื่อพูดถึงการออกแบบระบบเชิงวัตถุ

ในบทความนี้ เราจะสำรวจวิธีต่างๆ ในการใช้คลาสยูทิลิตี้ใน Kotlin และสิ่งที่ Kotlin ทำภายใต้ประทุนจากมุมมองของนักพัฒนา Java ตั้งแต่การลดโค้ดต้นแบบไปจนถึงการปรับปรุงการอ่านโค้ด Kotlin นำเสนอวิธีการต่างๆ มากมายที่สามารถทำให้การเปลี่ยนจาก Java ราบรื่นขึ้นเล็กน้อย

ไม่ว่าคุณจะเป็นนักพัฒนา Java ที่มีประสบการณ์ซึ่งต้องการเพิ่มพูนชุดทักษะของคุณหรือเป็นมือใหม่ในโลกของการเขียนโปรแกรม การทำความเข้าใจความแตกต่างระหว่างการใช้คลาสยูทิลิตี้ใน Kotlin และ Java เป็นขั้นตอนสำคัญในการฝึกฝนภาษาที่ทรงพลังนี้ให้เชี่ยวชาญ

อย่างที่เราทราบกันดีว่า กระบวนการสร้างคลาส util ใน Java นั้นค่อนข้างตรงไปตรงมาและอธิบายไว้ด้านล่าง:

• สร้างคลาสสุดท้าย (เพราะไม่ควรเป็นคลาสย่อย)
• เพิ่มตัวสร้างส่วนตัวเพื่อหลีกเลี่ยงการสร้างอินสแตนซ์ของคลาสโดยไม่จำเป็น
• เพิ่มวิธียูทิลิตี้แบบคงที่ (foo ในกรณีนั้น)

public final class UtilClass {
    private UtilClass(){}
    
    public static String foo() {
        return "bar";
    }
}

1. การประกาศอ็อบเจกต์:รูปแบบซิงเกิลตันมีประโยชน์ในหลายสถานการณ์ และ Kotlin มอบวิธีที่สะดวกในการใช้งานซิงเกิลตัน

object UtilObject {
    fun foo(): String = "bar"
}

การทำงานร่วมกันของ Kotlin-Java

เมื่อคุณเขียนโค้ด Kotlin ภายใต้ประทุน โค้ดจะถูกคอมไพล์เป็น Java bytecode ที่สามารถทำงานบน Java Virtual Machine (JVM) ได้เหมือนกับโค้ด Java ซึ่งหมายความว่าสามารถใช้ Kotlin เพื่อพัฒนาแอปพลิเคชันที่ทำงานบนแพลตฟอร์มใดก็ได้ที่รองรับ JVM รวมถึงแพลตฟอร์มเดสก์ท็อป เว็บ และมือถือ

Kotlin ได้รับการออกแบบมาให้ทำงานร่วมกับ Java ได้อย่างสมบูรณ์ ซึ่งหมายความว่าโค้ด Kotlin สามารถเรียกโค้ด Java และในทางกลับกันได้ สิ่งนี้ทำให้ง่ายสำหรับนักพัฒนาในการค่อยๆ ย้ายโค้ดเบส Java ของตนไปยัง Kotlin หรือใช้ Kotlin ร่วมกับโค้ด Java ที่มีอยู่

หมายเหตุ:โค้ด Java ที่เทียบเท่าที่เราจะเห็นในบทความถูกสร้างขึ้นโดยการคอมไพล์ kotlin เป็นโค้ด Java byte แล้วทำการ decompile เป็น Java

มาดู Java เทียบเท่ากับโค้ดที่สร้างขึ้นโดยคอมไพเลอร์ Kotlin:

public final class UtilObject {
   @NotNull
   public static final UtilObject INSTANCE;

   @NotNull
   public final String foo() {
      return "bar";
   }

   private UtilObject() {
   }

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

การใช้งานจะเป็นดังนี้:

UtilObject.foo()

2. Companion Objects: Companion object ยังเป็น singleton object ที่มีตัวแปรหรือฟังก์ชันที่เกี่ยวข้องกับคลาส แต่ไม่ใช่กับอินสแตนซ์เฉพาะของคลาสนั้น

แต่จะสร้างคลาสอื่นที่เรียกว่าCompanion (หรือชื่อที่คุณเลือก) และวางคุณสมบัติและฟังก์ชันทั้งหมดไว้ในนั้นแทน

class UtilClass {
    companion object{
        fun foo(): String = "bar"
    }
}

public final class UtilClass {
    @NotNull
    public static final Companion Companion = new Companion(null);

    public static final class Companion {
        @NotNull
        public final String foo() {
            return "bar";
        }

        private Companion() {
        }

        public Companion(DefaultConstructorMarker $constructor_marker) {
            this();
        }
    }
}

อันที่สอง (“คู่หู”) เป็นอ็อบเจกต์ singleton (เริ่มต้นอย่างกระตือรือร้น) ซึ่งหมายถึงอินสแตนซ์เฉพาะที่สามารถเข้าถึงได้โดยไม่ต้องเรียกคอนสตรัคเตอร์ สิ่งนี้ทำให้มองเห็นวัตถุที่แสดงร่วมและเข้าถึงได้จากทุกที่

ในกรณีนี้ การใช้งานจะยังคงเป็นดังนี้:

UtilClass.foo()

Utils.kt

package com.yourdomain.utils

fun foo(): String = "bar"

public final class UtilPackageKt {
   @NotNull
   public static final String foo() {
      return "bar";
   }
}

ตามเอกสารประกอบของ Kotlin แนะนำให้ใช้ฟังก์ชันระดับแพ็คเกจเป็นโซลูชันสำหรับกรณีส่วนใหญ่ที่ต้องการฟังก์ชันแบบสแตติก

การใช้งานจะเป็นดังนี้:

foo()

บทสรุป

ความชอบอาจแตกต่างกันไปขึ้นอยู่กับความต้องการเฉพาะ และไม่ตรงไปตรงมาเสมอไปในการพิจารณาว่าวิธีใดเป็นทางเลือกที่ดีที่สุด แต่ละสถานการณ์ควรได้รับการประเมินเป็นรายบุคคล

ในบทความนี้ เราได้ให้ภาพรวมของตัวเลือกต่างๆ ที่มีอยู่ใน Kotlin และวิธีที่ Java จัดการกับพวกมันเบื้องหลัง เราหวังว่าการสนทนานี้จะช่วยให้คุณเข้าใจความเหมือนและความแตกต่างระหว่างการใช้งานฟังก์ชันยูทิลิตี้ต่างๆ ใน ​​Kotlin ได้ดียิ่งขึ้น

เพื่อสรุปสิ่งที่เราครอบคลุม:

• พิจารณาใช้การประกาศอ็อบเจกต์หากคุณต้องการสร้างออบเจกต์ singleton ที่เริ่มต้นแบบขี้เกียจและป้องกันเธรด
• พิจารณาการใช้ออบเจกต์ร่วมหากคุณต้องการสร้างส่วนขยายเดี่ยว "Java static-like" ที่เริ่มต้นอย่างกระตือรือร้นของคลาสของคุณ
• ลองใช้ฟังก์ชันระดับแพ็คเกจหากคุณต้องการสร้างฟังก์ชัน "real java-static" (ไม่มีอินสแตนซ์) โดยไม่จำเป็นต้องใช้เนมสเปซ

คำแนะนำและคำติชมจะได้รับการชื่นชมเสมอ