การประกาศชนิดแบบปิดผนึก
จำกัดชนิดที่สามารถสืบทอดได้
การประกาศชนิดแบบปิดผนึก เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การประกาศชนิดแบบปิดผนึก
- ส่วนคำสั่ง permits
- ชนิดแบบปิดผนึกกับเรคคอร์ด
- switch แบบครบถ้วนบนชนิดแบบปิดผนึก