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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- รูปแบบ Observer: การแจ้งเตือนเหตุการณ์
- รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้
- รูปแบบ Command: การห่อหุ้มการกระทำ
- Template Method: การกำหนดโครงร่างอัลกอริทึม