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

Abstract Factory สำหรับตระกูลผลิตภัณฑ์

สร้างกลุ่มออบเจ็กต์ที่เกี่ยวข้องกัน เช่น องค์ประกอบ UI แยกตามแพลตฟอร์ม ด้วย Abstract Factory

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

เจตนาของโรงงานนามธรรม

โรงงานนามธรรมจัดเตรียมอินเทอร์เฟซสำหรับสร้างกลุ่มออบเจ็กต์ที่เกี่ยวข้องกัน โดยไม่ระบุคลาสรูปธรรมของออบเจ็กต์เหล่านั้น และรับรองว่าผลิตภัณฑ์จากโรงงานเดียวกันจะเข้ากันได้

ปัญหา: กลุ่มผลิตภัณฑ์ไม่สอดคล้องกัน

หากไม่มีโรงงานนามธรรม คุณอาจนำปุ่ม Windows มาใช้ร่วมกับช่องทำเครื่องหมาย Mac รูปแบบนี้บังคับให้ผลิตภัณฑ์ทั้งหมดมาจากโรงงานเดียวกัน จึงช่วยรับรองความสอดคล้องด้านรูปลักษณ์หรือพฤติกรรม

อินเทอร์เฟซโรงงานนามธรรม

กำหนดอินเทอร์เฟซที่มีเมธอดการสร้างสำหรับผลิตภัณฑ์แต่ละรายการในกลุ่ม โรงงานรูปธรรมแต่ละแห่งจะใช้งานเมธอดทั้งหมดสำหรับรูปแบบหนึ่งรูปแบบ

public interface UIFactory {
    Button   createButton();
    Checkbox createCheckbox();
    TextField createTextField();
}

โรงงานรูปธรรม

โรงงานรูปธรรมแต่ละแห่งจะสร้างผลิตภัณฑ์ทั้งหมดสำหรับแพลตฟอร์มหรือธีมหนึ่งแบบ โค้ดฝั่งไคลเอ็นต์จะอ้างอิงเฉพาะอินเทอร์เฟซ ไม่ใช่โรงงานรูปธรรม

public class WindowsUIFactory implements UIFactory {
    public Button    createButton()    { return new WindowsButton(); }
    public Checkbox  createCheckbox()  { return new WindowsCheckbox(); }
    public TextField createTextField() { return new WindowsTextField(); }
}
public class MacUIFactory implements UIFactory {
    public Button    createButton()    { return new MacButton(); }
    public Checkbox  createCheckbox()  { return new MacCheckbox(); }
    public TextField createTextField() { return new MacTextField(); }
}

อินเทอร์เฟซผลิตภัณฑ์นามธรรม

ประเภทผลิตภัณฑ์แต่ละประเภทมีอินเทอร์เฟซของตนเอง ผลิตภัณฑ์รูปธรรมจะใช้งานอินเทอร์เฟซนั้นสำหรับแต่ละแพลตฟอร์ม โค้ดฝั่งไคลเอ็นต์จะเขียนโดยอิงผลิตภัณฑ์นามธรรม ไม่ใช่ผลิตภัณฑ์รูปธรรม

public interface Button   { void render(); void onClick(); }
public interface Checkbox  { void render(); boolean isChecked(); }
public interface TextField { void render(); String getValue(); }

ไคลเอ็นต์ที่ใช้โรงงาน

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

public class Application {
    private final UIFactory factory;
    public Application(UIFactory factory) { this.factory = factory; }
    public void buildUI() {
        Button btn = factory.createButton();
        Checkbox cb = factory.createCheckbox();
        btn.render();
        cb.render();
    }
}

การเลือกโรงงานขณะทำงาน

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

String os = System.getProperty("os.name").toLowerCase();
UIFactory factory = os.contains("mac") ? new MacUIFactory() : new WindowsUIFactory();
new Application(factory).buildUI();

การเพิ่มผลิตภัณฑ์ใหม่ลงในกลุ่ม

การเพิ่มผลิตภัณฑ์ใหม่ เช่น Slider ต้องแก้ไขอินเทอร์เฟซโรงงานนามธรรมและโรงงานรูปธรรมทั้งหมด ซึ่งเป็นข้อเสียของรูปแบบนี้

public interface UIFactory {
    Button   createButton();
    Checkbox createCheckbox();
    Slider   createSlider(); // new product — must update ALL factories
}

โรงงานนามธรรมเทียบกับเมธอดโรงงาน

เมธอดโรงงานสร้างผลิตภัณฑ์หนึ่งรายการผ่านการสืบทอด ส่วนโรงงานนามธรรมสร้างชุดผลิตภัณฑ์ผ่านการประกอบ โดยทั่วไปโรงงานนามธรรมจะใช้งานผ่านชุดของเมธอดโรงงาน

โรงงานนามธรรมสำหรับไดรเวอร์ฐานข้อมูล

โรงงานนามธรรม ConnectionFactory สามารถสร้างออบเจ็กต์ Connection, Statement และ ResultSet ได้ คุณสามารถสลับระหว่าง MySQL และ PostgreSQL ได้ด้วยการเปลี่ยนโรงงาน

public interface DBFactory {
    Connection  createConnection();
    Statement   createStatement();
}
public class MySQLFactory implements DBFactory { ... }
public class PgFactory   implements DBFactory { ... }

โรงงานนามธรรมร่วมกับโพรไฟล์ Spring

ใน Spring Boot ให้กำหนดบีน UIFactory แตกต่างกันสำหรับแต่ละโพรไฟล์ แอปพลิเคชันจะฉีด UIFactory อยู่เสมอ ส่วน Spring จะเลือกโรงงานรูปธรรมที่ถูกต้องสำหรับโพรไฟล์ที่กำลังทำงาน

@Configuration
@Profile("mac")
public class MacConfig {
    @Bean UIFactory uiFactory() { return new MacUIFactory(); }
}

การรับรองความสอดคล้อง

ประโยชน์หลักคือโรงงานจะสร้างเฉพาะผลิตภัณฑ์ที่เข้ากันได้ คุณจะไม่มีทางได้รับช่องทำเครื่องหมาย Mac ที่จับคู่กับปุ่ม Windows โดยไม่ตั้งใจเมื่อใช้โรงงานนามธรรมอย่างถูกต้อง

ตรวจสอบความเข้าใจอย่างรวดเร็ว

โรงงานนามธรรมรับรองสิ่งใดที่เมธอดโรงงานไม่สามารถรับรองได้

สรุปทบทวน

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

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

บทเรียน “Abstract Factory สำหรับตระกูลผลิตภัณฑ์” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “Abstract Factory สำหรับตระกูลผลิตภัณฑ์”

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

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

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

บทเรียน “Abstract Factory สำหรับตระกูลผลิตภัณฑ์” ใช้เวลานานแค่ไหน

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

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

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

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

  1. Singleton: การใช้งานที่ปลอดภัยต่อเธรด
  2. รูปแบบ Factory Method
  3. Abstract Factory สำหรับตระกูลผลิตภัณฑ์
  4. รูปแบบ Builder กับ Fluent API
← กลับไปที่ Java Academy