รูปแบบวิธีการเทมเพลตของรูปแบบการออกแบบ Java กำหนดเฟรมเวิร์กของอัลกอริธึมปฏิบัติการและเลื่อนบางขั้นตอนไปยังคลาสย่อย เพื่อให้คลาสย่อยสามารถกำหนดขั้นตอนเฉพาะบางอย่างในอัลกอริทึมใหม่โดยไม่ต้องเปลี่ยนโครงสร้างของอัลกอริทึม รูปแบบพฤติกรรม
ดังที่แสดงด้านล่าง:
ในความเป็นจริง วิธีการเทมเพลตเป็นรูปแบบที่ใช้บ่อยในการเขียนโปรแกรม มาดูตัวอย่างกันก่อน วันหนึ่ง โปรแกรมเมอร์ A ได้รับงาน: กำหนดอาร์เรย์ของจำนวนเต็ม เรียงลำดับตัวเลขในอาร์เรย์จากเล็กไปใหญ่ แล้วพิมพ์ผลลัพธ์ที่เรียงลำดับออกมา หลังจากการวิเคราะห์ งานนี้แบ่งคร่าวๆ ได้เป็นสองส่วน ได้แก่ การเรียงลำดับและการพิมพ์ ฟังก์ชันการพิมพ์นั้นใช้งานง่าย แต่การเรียงลำดับจะยุ่งยากเล็กน้อย แต่ A มีวิธีทำให้ฟังก์ชันการพิมพ์สมบูรณ์ก่อนแล้วจึงหาคนอื่นมาทำหน้าที่เรียงลำดับ
abstract class AbstractSort { /** * เรียงลำดับอาเรย์อาร์เรย์จากเล็กไปใหญ่ * @param array */ การเรียงลำดับโมฆะนามธรรมที่ได้รับการป้องกัน (int [] array); โมฆะสาธารณะ showSortResult (อาร์เรย์ int []) { this.sort (อาร์เรย์); System.out.print("เรียงลำดับผลลัพธ์: "); for (int i = 0; i < array.length; i++){ System.out.printf("%3s", array[i]);หลังจากเขียนเสร็จ A ก็พบเพื่อนร่วมงาน B ที่เพิ่งสำเร็จการศึกษาและเข้าร่วมงานเมื่อเร็วๆ นี้ และพูดว่า: มีงานชิ้นหนึ่ง ฉันได้เขียนตรรกะหลักไปแล้ว คุณสามารถนำตรรกะที่เหลือไปใช้ได้ ดังนั้นฉันจึงให้คลาส AbstractSort แก่ B และขอให้ B เขียนการนำไปใช้งาน B หยิบมันขึ้นมาดู มันง่ายเกินไป สามารถทำได้ใน 10 นาที
class ConcreteSort ขยาย AbstractSort { @Override protected void sort(int[] array){ for(int i=0; i<array.length-1; i++){ selectSort(array, i); } } โมฆะส่วนตัว selectSort(int[ ] อาร์เรย์, ดัชนี int) { int MinValue = 32767; // ตัวแปรค่าต่ำสุด int indexMin = 0; // ตัวแปรดัชนีค่าต่ำสุด int Temp; // ตัวแปรที่เก็บข้อมูลชั่วคราวสำหรับ (int i = index; i < array.length; i++) { if (array[i] < MinValue){ // ค้นหาค่าต่ำสุด MinValue = array[i]; // เก็บค่าต่ำสุด indexMin = i } } Temp = array[ ดัชนี] ; // แลกเปลี่ยนสองค่า array[index] = array[indexMin]; array[indexMin] = Temp;หลังจากเขียนแล้ว ให้ส่งให้กับ A และ A จะดำเนินการ:
ไคลเอ็นต์คลาสสาธารณะ { public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // ค่าเริ่มต้นอาร์เรย์ข้อมูล โมฆะคงที่สาธารณะ main (String [] args) { AbstractSort s = ConcreteSort ใหม่ (); s.showSortResult (a); ผลการวิ่ง:
การเรียงลำดับผลลัพธ์: 0 1 3 4 5 7 9 10 12 32
มันทำงานได้ดี โอเค ภารกิจสำเร็จแล้ว ใช่ นี่คือรูปแบบวิธีการของเทมเพลต ผู้สำเร็จการศึกษาส่วนใหญ่ที่เพิ่งเข้าทำงานควรมีประสบการณ์คล้ายกับบี สำหรับงานที่ซับซ้อน คนที่ดีที่สุดในบริษัทจะเขียนตรรกะหลัก จากนั้นจึงเขียนวิธีการที่ดูเรียบง่ายให้เป็นนามธรรม และปล่อยให้เพื่อนร่วมงานคนอื่นๆ พัฒนาต่อไป แผนกแรงงานนี้มักใช้ในบริษัทที่มีระดับพนักงานเขียนโปรแกรมที่ชัดเจน ตัวอย่างเช่น หากทีมงานโครงการมีสถาปนิก วิศวกรอาวุโส และวิศวกรรุ่นน้อง โดยทั่วไปสถาปนิกจะใช้อินเทอร์เฟซและคลาสนามธรรมจำนวนมากเพื่อรวมตรรกะของทั้งระบบเข้าด้วยกัน และโค้ดการใช้งานจะถูกส่งต่อไปยัง วิศวกรอาวุโสและวิศวกรรุ่นน้องตามลำดับตามความยากของวิศวกร คุณเคยใช้รูปแบบวิธีการเทมเพลตหรือไม่?
โครงสร้างของรูปแบบวิธีการแม่แบบ:
รูปแบบวิธีการเทมเพลตประกอบด้วยคลาสนามธรรมและคลาสการใช้งานหนึ่ง (หรือกลุ่ม) ผ่านโครงสร้างการสืบทอด วิธีการในคลาสนามธรรมแบ่งออกเป็นสามประเภท:
1. วิธีการเชิงนามธรรม : มันถูกประกาศในคลาสพาเรนต์เท่านั้น แต่ไม่ได้นำไปใช้ แต่จะกำหนดข้อกำหนดและนำไปใช้โดยคลาสย่อยแทน
2. วิธีการเทมเพลต : ประกาศและนำไปใช้โดยคลาสนามธรรม โดยทั่วไปแล้ว วิธีการเทมเพลตจะเรียกวิธีนามธรรมเพื่อทำให้ฟังก์ชันลอจิคัลหลักสมบูรณ์ และวิธีการเทมเพลตส่วนใหญ่จะถูกกำหนดให้เป็นประเภทสุดท้าย ซึ่งบ่งชี้ว่าฟังก์ชันลอจิคัลหลักไม่สามารถเขียนทับในคลาสย่อยได้
3. วิธี Hook : ประกาศและนำไปใช้โดยคลาสนามธรรม แต่คลาสย่อยสามารถขยายได้ และคลาสย่อยอาจส่งผลต่อตรรกะของวิธีเทมเพลตโดยการขยายวิธี hook
งานของคลาสนามธรรมคือการสร้างกรอบงานเชิงตรรกะ ซึ่งโดยปกติจะเขียนโดยบุคลากรที่มีประสบการณ์ เนื่องจากคุณภาพของคลาสนามธรรมจะกำหนดความเสถียรของโปรแกรมโดยตรง
คลาสการใช้งานใช้เพื่อนำรายละเอียดไปใช้ วิธีการเทมเพลตในคลาสนามธรรมทำให้ตรรกะทางธุรกิจสมบูรณ์โดยการใช้วิธีการขยายคลาส ตราบใดที่วิธีการขยายในคลาสการใช้งานผ่านการทดสอบหน่วยและวิธีการเทมเพลตถูกต้อง โดยทั่วไปจะไม่มีข้อผิดพลาดที่สำคัญในฟังก์ชันโดยรวม
ข้อดีและสถานการณ์จำลองที่ใช้ได้ของวิธีการเทมเพลต:
ง่ายต่อการขยาย โดยทั่วไปแล้ว วิธีเทมเพลตในคลาสนามธรรมเป็นส่วนที่เปลี่ยนแปลงย้อนหลังได้ไม่ง่าย ในขณะที่วิธีนามธรรมเป็นส่วนที่เปลี่ยนแปลงย้อนหลังได้ง่าย ดังนั้น โดยทั่วไปแล้วการเพิ่มคลาสการใช้งานจึงเป็นเรื่องง่ายที่จะขยายฟังก์ชัน ซึ่งเป็นไปตามหลักการเปิดและปิด
ดูแลรักษาง่าย สำหรับรูปแบบวิธีการของเทมเพลต เป็นเพราะตรรกะหลักเหมือนกับวิธีการของเทมเพลตที่ใช้ หากไม่ได้ใช้วิธีการของเทมเพลต โค้ดเดียวกันจะได้รับอนุญาตให้กระจัดกระจายในคลาสที่แตกต่างกัน ซึ่งไม่สะดวกอย่างยิ่งที่จะดูแลรักษา .
มีความยืดหยุ่นมากขึ้น เนื่องจากวิธี hook การนำคลาสย่อยไปใช้อาจส่งผลต่อการดำเนินการของตรรกะหลักในคลาสพาเรนต์ด้วย อย่างไรก็ตาม แม้จะมีความยืดหยุ่น เนื่องจากคลาสย่อยส่งผลกระทบต่อคลาสพาเรนต์ แต่ก็ฝ่าฝืนหลักการทดแทน Liskov และยังนำความเสี่ยงมาสู่โปรแกรมด้วย สิ่งนี้ทำให้มีข้อกำหนดที่สูงขึ้นในการออกแบบคลาสนามธรรม
เมื่อคลาสย่อยหลายคลาสมีเมธอดเดียวกันและตรรกะของเมธอดเหล่านี้เหมือนกัน คุณสามารถพิจารณาใช้รูปแบบเมธอดเทมเพลตได้ โหมดนี้ยังเหมาะกับสถานการณ์ที่เฟรมเวิร์กหลักของโปรแกรมเหมือนกันแต่รายละเอียดต่างกัน