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

รูปแบบ Factory Method

กำหนดเมธอดโรงงานในคลาสฐาน และให้คลาสย่อยตัดสินใจว่าจะสร้างผลิตภัณฑ์ใด

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

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

เมธอดโรงงานกำหนดอินเทอร์เฟซสำหรับสร้างออบเจ็กต์ แต่เปิดให้คลาสย่อยตัดสินใจว่าจะสร้างคลาสใด เมธอดนี้แยกตรรกะการสร้างออกจากโค้ดฝั่งไคลเอ็นต์

ปัญหาเมื่อไม่มีเมธอดโรงงาน

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

// Client knows too much:
Shape shape;
if (type.equals("circle")) shape = new Circle(r);
else if (type.equals("rect")) shape = new Rectangle(w, h);
// Every new shape requires editing this code.

คลาสผู้สร้างนามธรรม

กำหนดคลาสผู้สร้างนามธรรมที่มีเมธอดโรงงาน createProduct() คลาสย่อยจะเขียนทับเมธอดนี้เพื่อส่งคืนประเภทผลิตภัณฑ์ที่เฉพาะเจาะจง

public abstract class Dialog {
    public void render() {
        Button btn = createButton(); // factory method
        btn.onClick();
    }
    protected abstract Button createButton();
}

ผู้สร้างรูปธรรม

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

public class WindowsDialog extends Dialog {
    @Override
    protected Button createButton() { return new WindowsButton(); }
}
public class WebDialog extends Dialog {
    @Override
    protected Button createButton() { return new HtmlButton(); }
}

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

ผลิตภัณฑ์รูปธรรมทั้งหมดใช้งานอินเทอร์เฟซร่วมกัน เพื่อให้ผู้สร้างสามารถทำงานกับผลิตภัณฑ์เหล่านั้นในลักษณะทั่วไปได้

public interface Button {
    void onClick();
    void render();
}
public class WindowsButton implements Button {
    public void onClick() { System.out.println("Windows click"); }
    public void render() { System.out.println("Render Windows button"); }
}

เมธอดโรงงานแบบสแตติกเทียบกับรูปแบบเมธอดโรงงาน

เมธอดโรงงานแบบสแตติก เช่น LocalDate.of() เป็นเพียงรูปแบบการตั้งชื่อ ไม่ใช่รูปแบบ GoF รูปแบบ GoF ใช้การสืบทอด ส่วนโรงงานแบบสแตติกใช้เมธอดสแตติกในคลาสเดียว

// Static factory (NOT the GoF pattern)
LocalDate d = LocalDate.of(2024, 6, 15);
// GoF Factory Method uses a class hierarchy

เมธอดโรงงานแบบรับพารามิเตอร์

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

public class ShapeFactory {
    public static Shape create(String type, double... dims) {
        return switch (type) {
            case "circle"    -> new Circle(dims[0]);
            case "rectangle" -> new Rectangle(dims[0], dims[1]);
            default -> throw new IllegalArgumentException("Unknown: " + type);
        };
    }
}

เมธอดโรงงานร่วมกับเจเนอริกส์

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

public abstract class Repository<T, ID> {
    public abstract T findById(ID id);
    protected abstract T createEmpty(); // factory method
}

การลงทะเบียนโรงงานด้วยแผนที่

โรงงานที่อิงรีจิสทรีจะจัดเก็บแผนที่จากสตริงประเภทไปยังแลมบ์ดา Supplier ซึ่งช่วยหลีกเลี่ยงชุดคำสั่ง if-else และทำให้การลงทะเบียนเป็นแบบไดนามิก

Map<String, Supplier<Notification>> registry = new HashMap<>();
registry.put("email", EmailNotification::new);
registry.put("sms",   SmsNotification::new);
Notification n = registry.getOrDefault(type, DefaultNotification::new).get();

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

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

ตัวอย่างจากโลกจริง: โรงงาน Logger

LoggerFactory.getLogger(Class) ของ SLF4J เป็นโรงงานแบบสแตติกที่ส่งคืนการใช้งาน Logger ที่ถูกต้อง (Logback, Log4j, JUL) โดยผู้เรียกไม่จำเป็นต้องทราบว่าเป็นการใช้งานแบบใด

Logger log = LoggerFactory.getLogger(MyService.class);
log.info("Service started");

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

ลักษณะสำคัญของรูปแบบเมธอดโรงงานคืออะไร

สรุปทบทวน

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

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

บทเรียน “รูปแบบ Factory Method” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบ Factory Method”

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

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

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

บทเรียน “รูปแบบ Factory Method” ใช้เวลานานแค่ไหน

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

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

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

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

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