0Pricing
Java Academy · บทเรียน

การประกาศชนิดแบบปิดผนึก

จำกัดชนิดที่สามารถสืบทอดได้

การประกาศชนิดแบบปิดผนึก เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

ชนิดแบบปิดคืออะไร

คลาสหรืออินเทอร์เฟซแบบ ปิด จะจำกัดว่าชนิดอื่นใดสามารถสืบทอดหรือนำไปใช้ได้บ้าง ทำให้คุณสร้างแบบจำลองชุดความเป็นไปได้แบบ ปิด ซึ่งคอมไพเลอร์สามารถวิเคราะห์เหตุผลได้

ปัญหาที่แก้ได้

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

คีย์เวิร์ดชนิดแบบปิด

กำหนดชนิดให้เป็น sealed แล้วระบุชนิดย่อยที่อนุญาตด้วย permits ชนิดย่อยที่ได้รับอนุญาตทุกชนิดต้องประกาศตัวปรับแต่งการสืบทอดของตนเอง

public class Main {
    sealed interface Shape permits Circle, Square {}
    record Circle(double radius) implements Shape {}
    record Square(double side) implements Shape {}

    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.println(s);
    }
}

ตัวปรับแต่งชนิดย่อย

ชนิดย่อยที่ได้รับอนุญาตแต่ละชนิดต้องเป็นหนึ่งในตัวเลือกต่อไปนี้: final (ไม่ให้สร้างคลาสย่อยต่อ) sealed (จำกัดการสืบทอดต่อไป) หรือ non-sealed (เปิดให้ขยายต่อได้อย่างอิสระ) เรคคอร์ดจะเป็น final โดยปริยาย

คลาสย่อยที่ปิดการสืบทอดต่อ

การกำหนดให้คลาสย่อยเป็น final จะปิดลำดับชั้นที่แขนงนั้น

public class Main {
    sealed interface Animal permits Dog, Cat {}
    static final class Dog implements Animal {
        public String toString() { return "Dog"; }
    }
    static final class Cat implements Animal {
        public String toString() { return "Cat"; }
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a);
    }
}

คลาสย่อยที่เปิดให้สืบทอดต่อ

ชนิดย่อยแบบ non-sealed จะเปิดให้สืบทอดต่ออีกครั้งโดยเจตนา ทำให้คลาสที่ไม่รู้จักสามารถสืบทอดจากชนิดย่อยนี้ได้อีก ใช้อย่างระมัดระวังเมื่อมีแขนงหนึ่งที่ต้องเปิดให้ขยายต่อ

public class Main {
    sealed interface Plugin permits CorePlugin, ExternalPlugin {}
    static final class CorePlugin implements Plugin {}
    static non-sealed class ExternalPlugin implements Plugin {}
    static class ThirdParty extends ExternalPlugin {}

    public static void main(String[] args) {
        Plugin p = new ThirdParty();
        System.out.println(p.getClass().getSimpleName());
    }
}

คลาสแบบปิดก็ทำได้

การทำให้ชนิดเป็นแบบปิดไม่ได้จำกัดอยู่แค่อินเทอร์เฟซ คลาส sealed class แบบนามธรรมทำงานในลักษณะเดียวกัน และสามารถเก็บสถานะกับพฤติกรรมที่ใช้ร่วมกันได้

public class Main {
    sealed static abstract class Expr permits Num, Add {}
    static final class Num extends Expr {
        final int value;
        Num(int value) { this.value = value; }
    }
    static final class Add extends Expr {
        final Expr left, right;
        Add(Expr left, Expr right) { this.left = left; this.right = right; }
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(1), new Num(2));
        System.out.println(e.getClass().getSimpleName());
    }
}

โมดูลหรือแพ็กเกจเดียวกัน

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

การบังคับใช้โดยคอมไพเลอร์

หากคลาสพยายามสืบทอดจากชนิดแบบปิดโดยไม่ได้ระบุไว้ใน permits โค้ดจะ ไม่สามารถคอมไพล์ได้ ชุดชนิดที่ปิดจึงได้รับการรับประกันตั้งแต่เวลาคอมไพล์

เหตุใดจึงสำคัญ

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

ลำดับชั้นที่สมบูรณ์

นี่คือตัวอย่างลำดับชั้นขนาดเล็กแบบปิดที่ใช้เป็นแบบจำลองค่า

public class Main {
    sealed interface Json permits JsonNull, JsonNumber, JsonString {}
    record JsonNull() implements Json {}
    record JsonNumber(double value) implements Json {}
    record JsonString(String value) implements Json {}

    public static void main(String[] args) {
        Json[] values = { new JsonNull(), new JsonNumber(3.5), new JsonString("hi") };
        for (Json j : values) {
            System.out.println(j);
        }
    }
}

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจเรื่องการประกาศชนิดแบบปิดของคุณ

ทบทวน

คุณได้เรียนรู้การประกาศชนิดแบบปิด

  • sealed จะจำกัดผู้ที่สามารถสืบทอดหรือนำชนิดนั้นไปใช้ได้
  • ส่วนคำสั่ง permits จะแสดงรายการชนิดย่อยที่อนุญาต
  • ชนิดย่อยแต่ละชนิดต้องเป็น final, sealed หรือ non-sealed
  • ชนิดย่อยต้องอยู่ในโมดูลหรือแพ็กเกจเดียวกัน และมีคอมไพเลอร์เป็นผู้บังคับใช้

คำถามที่พบบ่อย

บทเรียน “การประกาศชนิดแบบปิดผนึก” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การประกาศชนิดแบบปิดผนึก” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การประกาศชนิดแบบปิดผนึก”

จำกัดชนิดที่สามารถสืบทอดได้ คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การประกาศชนิดแบบปิดผนึก” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การประกาศชนิดแบบปิดผนึก
  2. ส่วนคำสั่ง permits
  3. ชนิดแบบปิดผนึกกับเรคคอร์ด
  4. switch แบบครบถ้วนบนชนิดแบบปิดผนึก
← กลับไปที่ Java Academy