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

Template Method: การกำหนดโครงร่างอัลกอริทึม

กำหนดโครงร่างอัลกอริทึมในคลาสฐาน และให้คลาสย่อยเติมขั้นตอนให้สมบูรณ์

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

เจตนาของเมธอดแม่แบบ

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

คลาสฐานแบบ abstract

คลาสฐานมีเมธอดแม่แบบ (โดยปกติเป็น final) ที่ประสานขั้นตอนต่าง ๆ เมธอด abstract แทนขั้นตอนที่แตกต่างกัน ส่วนเมธอดรูปธรรมจะมีพฤติกรรมเริ่มต้น

public abstract class DataProcessor {
    // Template method — final, defines the algorithm
    public final void process() {
        readData();
        processData();
        writeResult();
    }
    protected abstract void readData();
    protected abstract void processData();
    protected void writeResult() {
        System.out.println("Result written (default)");
    }
}

คลาสย่อยรูปธรรม

คลาสย่อยแต่ละตัวเติมรายละเอียดให้ขั้นตอน abstract เมธอดแม่แบบจะมีลำดับเดิมเสมอ มีเพียงการใช้งานของแต่ละขั้นตอนเท่านั้นที่แตกต่างกัน

public class CSVProcessor extends DataProcessor {
    protected void readData()    { System.out.println("Reading CSV..."); }
    protected void processData() { System.out.println("Parsing CSV rows..."); }
}
public class XMLProcessor extends DataProcessor {
    protected void readData()    { System.out.println("Reading XML..."); }
    protected void processData() { System.out.println("Parsing XML nodes..."); }
    @Override
    protected void writeResult() { System.out.println("Writing XML result."); }
}

เมธอดฮุก

ฮุกคือขั้นตอนเสริมที่มีการใช้งานเริ่มต้น ซึ่งมักเป็นการไม่ทำอะไร คลาสย่อยสามารถเขียนทับฮุกเพื่อเพิ่มพฤติกรรมเสริม โดยไม่ถูกบังคับให้ต้องใช้งานขั้นตอนนั้น

public abstract class Game {
    public final void play() {
        initialize();
        while (!isDone()) takeTurn();
        printWinner();
    }
    protected void initialize() {}  // hook — optional override
    protected abstract boolean isDone();
    protected abstract void takeTurn();
    protected abstract void printWinner();
}

เมธอดแม่แบบกับกลยุทธ์

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

Java InputStream ในฐานะเมธอดแม่แบบ

read(byte[], int, int) ของ java.io.InputStream ถูกใช้งานโดยอาศัย read() แบบ abstract คลาสย่อยใช้งานเวอร์ชันอ่านทีละไบต์ ส่วนการอ่านหลายไบต์คือแม่แบบ

เมธอดแม่แบบสำหรับการสร้างรายงาน

กำหนดแม่แบบรายงาน: รวบรวมข้อมูล จัดรูปแบบข้อมูล แล้วส่งออก สลับคลาสย่อยสำหรับเอาต์พุต PDF, HTML หรือ CSV ได้โดยไม่ต้องเปลี่ยนตรรกะการประสานงาน

public abstract class ReportGenerator {
    public final String generate() {
        List<Record> data = fetchData();
        String body = format(data);
        return wrap(body);
    }
    protected abstract List<Record> fetchData();
    protected abstract String format(List<Record> data);
    protected String wrap(String body) { return body; } // hook
}

การป้องกันการเขียนทับแม่แบบ

ประกาศเมธอดแม่แบบเป็น final เพื่อป้องกันไม่ให้คลาสย่อยเปลี่ยนโครงสร้างของอัลกอริทึม ควรอนุญาตให้เขียนทับได้เฉพาะเมธอดฮุกและเมธอด abstract

public final void process() {
    validate(); // abstract
    execute();  // abstract
    cleanup();  // hook with default
}

ขั้นตอน abstract กับรูปธรรม

กำหนดขั้นตอนเป็น abstract เมื่อคลาสย่อย ต้องจัดหาให้ กำหนดให้เป็นรูปธรรม (อาจไม่มีการใช้งานก็ได้) เมื่อคลาสย่อย อาจเขียนทับเพื่อปรับแต่ง

เมธอดแม่แบบใน JUnit

setUp() และ tearDown() ของ JUnit 4 เป็นฮุกในเมธอดแม่แบบที่ตัวรันการทดสอบกำหนด ตัวรันควบคุมเวลาที่เรียกใช้ฮุกเหล่านี้

เมธอดแม่แบบใน Spring

JdbcTemplate ของ Spring ใช้เมธอดแม่แบบภายใน แม่แบบจะควบคุมการเชื่อมต่อ การสร้างคำสั่ง และการล้างทรัพยากร ส่วนคุณจัดหาแลมบ์ดา RowMapper สำหรับขั้นตอน "แมปแถว" ที่แตกต่างกัน

List<User> users = jdbcTemplate.query(
    "SELECT * FROM users",
    (rs, row) -> new User(rs.getLong("id"), rs.getString("name"))
);

หลีกเลี่ยงการสืบทอดเชิงลึก

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

ตรวจสอบอย่างรวดเร็ว

คีย์เวิร์ดใดป้องกันไม่ให้คลาสย่อยเปลี่ยนลำดับของเมธอดแม่แบบ

ทบทวน

เมธอดแม่แบบตรึงโครงร่างอัลกอริทึมไว้ในคลาสฐานด้วย final คลาสย่อยใช้งานขั้นตอน abstract และอาจเขียนทับฮุกได้ตามต้องการ ควรรักษาลำดับชั้นให้ตื้น และใช้กลยุทธ์เมื่อต้องการความยืดหยุ่นมากขึ้น

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

บทเรียน “Template Method: การกำหนดโครงร่างอัลกอริทึม” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “Template Method: การกำหนดโครงร่างอัลกอริทึม”

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

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

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

บทเรียน “Template Method: การกำหนดโครงร่างอัลกอริทึม” ใช้เวลานานแค่ไหน

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

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

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

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

  1. รูปแบบ Observer: การแจ้งเตือนเหตุการณ์
  2. รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้
  3. รูปแบบ Command: การห่อหุ้มการกระทำ
  4. Template Method: การกำหนดโครงร่างอัลกอริทึม
← กลับไปที่ Java Academy