สมาชิกคลาสคงที่ X++

Note

กลุ่มที่น่าสนใจของชุมชนได้ย้ายจาก Yammer ไปยัง Microsoft Viva Engage แล้ว หากต้องการเข้าร่วมชุมชน Viva Engage และเข้าร่วมในการสนทนาล่าสุด ให้กรอก แบบฟอร์ม คําขอการเข้าถึงการเงินและการดําเนินงาน Viva Engage Community และเลือกชุมชนที่คุณต้องการเข้าร่วม

บทความนี้อธิบายสมาชิกคลาสแบบคงที่ใน X++ โดยทั่วไป วิธีการแบบคงที่มีไว้สําหรับกรณีเหล่านี้:

• เมธอด ไม่มีเหตุผลในการเข้าถึงตัวแปรสมาชิกที่ถูกประกาศในคลาส
• เมธอด ไม่มีเหตุผลในการเรียกใช้เมธอดอินสแตนซ์ (ไม่ใช่แบบคงที่) ของคลาส

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

วิธีการแบบคงที่

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

นี่คือตัวอย่างของวิธีการที่ประกาศโดยใช้คําสําคัญแบบคงที่

public class SoftwareKey
{
    static public boolean validateSoftwareKey(str _softwareKeyString)
    {
        // Your code here.
        return false;
    }
}

ในตัวอย่างต่อไปนี้ คุณไม่จําเป็นต้องสร้างอินสแตนซ์ของคลาส SoftwareKey ก่อนที่คุณจะเรียกใช้เมธอดแบบคงที่บนคลาส เมื่อคุณต้องการเรียกใช้เมธอด validateSoftwareKey แบบคงที่ ไวยากรณ์จะเริ่มต้นด้วยชื่อของคลาสที่ประกอบด้วยเมธอด คู่ของเครื่องหมายทวิภาค (::) จะถูกใช้เพื่อเชื่อมต่อชื่อคลาสกับชื่อเมธอดแบบคงที่

boolean yourBool = SoftwareKey::validateSoftwareKey(yourSoftwareKeyString);

เขตข้อมูลแบบคงที่

เขตข้อมูลแบบคงที่เป็นตัวแปรที่ถูกประกาศโดยใช้คําสําคัญแบบคงที่ ตามแนวคิดแล้ว ตัวกรองเหล่านี้นําไปใช้กับคลาส ไม่ใช่อินสแตนซ์ของคลาส

คอนสตรัคเตอร์แบบคงที่

คอนสตรักเตอร์แบบคงที่รับประกันว่าจะเรียกใช้ก่อนที่จะทําการเรียกใช้แบบคงที่หรืออินสแตนซ์ใด ๆ กับคลาส การดําเนินการของคอนสตรักเตอร์แบบคงที่จะเกี่ยวข้องกับเซสชันของผู้ใช้ คอนสตรักเตอร์แบบคงที่มีไวยากรณ์ต่อไปนี้

static void TypeNew()

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

ตัวอย่างรหัสต่อไปนี้แสดงวิธีการสร้างอินสแตนซ์ singleton โดยใช้คอนสตรักเตอร์แบบคงที่

public class Singleton
{
    private static Singleton instance;

    private void new()
    {
    }

    static void TypeNew()
    {
        instance = new Singleton();
    }

    public static Singleton Instance()
    {
        return Singleton::instance;
    }
}

Singleton รับประกันว่ามีเพียงอินสแตนซ์ของคลาสเดียวเท่านั้นที่จะถูกเรียก ตัวอย่างต่อไปนี้แสดงวิธีการสร้างอินสแตนซ์ singleton

Singleton i = Singleton::Instance();

วิธีการแบบคงที่

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

ClassName::methodName();

วิธีการแบบคงที่และอินสแตนซ์

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