รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้
ห่อหุ้มอัลกอริทึมการเรียงลำดับหรือการชำระเงินไว้เบื้องหลังอินเทอร์เฟซ Strategy เพื่อสลับใช้งานขณะทำงาน
รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้ เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน
เจตนาของ Strategy
Strategy กำหนดกลุ่มอัลกอริทึม ห่อหุ้มแต่ละอัลกอริทึมไว้ และทำให้อัลกอริทึมเหล่านั้นสับเปลี่ยนกันได้ ช่วยให้อัลกอริทึมเปลี่ยนแปลงได้อย่างอิสระจากบริบทที่นำไปใช้
ปัญหาเมื่อไม่มี Strategy
เมื่อไม่มี Strategy การเลือกอัลกอริทึมจะถูกฝังอยู่ในชุดคำสั่ง if-else การเพิ่มอัลกอริทึมใหม่หมายถึงต้องแก้ไขคลาสบริบท ซึ่งเป็นการละเมิดหลักการเปิด/ปิด
public double sort(List<Integer> data, String method) {
if (method.equals("bubble")) { /* bubble sort */ }
else if (method.equals("merge")) { /* merge sort */ }
// adding quicksort requires editing this class
}อินเทอร์เฟซ Strategy
กำหนด @FunctionalInterface หรืออินเทอร์เฟซทั่วไปที่แทนสัญญาของอัลกอริทึม การใช้งานแต่ละแบบจะห่อหุ้มอัลกอริทึมที่แตกต่างกันไว้
public interface SortStrategy {
void sort(List<Integer> data);
}
public class BubbleSortStrategy implements SortStrategy {
public void sort(List<Integer> data) { /* bubble sort logic */ }
}
public class QuickSortStrategy implements SortStrategy {
public void sort(List<Integer> data) { Collections.sort(data); }
}คลาสบริบท
บริบทจะเก็บการอ้างอิงไปยัง Strategy และมอบหมายการทำงานของอัลกอริทึมให้ Strategy นั้น คุณสามารถสับเปลี่ยน Strategy ได้ขณะทำงาน
public class Sorter {
private SortStrategy strategy;
public Sorter(SortStrategy strategy) { this.strategy = strategy; }
public void setStrategy(SortStrategy s) { this.strategy = s; }
public void sort(List<Integer> data) { strategy.sort(data); }
}การสับเปลี่ยน Strategy ขณะทำงาน
เปลี่ยน Strategy ได้ทันทีโดยไม่ต้องแก้ไขบริบท ทำให้สามารถกำหนดค่าพฤติกรรมจากภายนอกคลาสได้
Sorter sorter = new Sorter(new BubbleSortStrategy());
sorter.sort(data); // uses bubble sort
sorter.setStrategy(new QuickSortStrategy());
sorter.sort(data); // now uses quick sortStrategy แบบแลมบ์ดา
เมื่ออินเทอร์เฟซ Strategy เป็น @FunctionalInterface ให้ใช้แลมบ์ดาโดยตรงได้ ไม่จำเป็นต้องสร้างคลาสอย่างชัดเจนสำหรับ Strategy แบบง่าย
Sorter sorter = new Sorter(data -> Collections.sort(data)); // lambda strategy
// or method reference:
Sorter sorter2 = new Sorter(Collections::sort);Strategy สำหรับการประมวลผลการชำระเงิน
ตัวอย่างการใช้งานจริงที่พบได้ทั่วไปคือ บริบทการชำระเงินรับ Strategy การชำระเงินที่แตกต่างกัน เช่น บัตรเครดิต, PayPal หรือคริปโตเคอร์เรนซี โดยไม่จำเป็นต้องรู้รายละเอียดของแต่ละแบบ
public interface PaymentStrategy {
void pay(double amount);
}
new PaymentProcessor(new CreditCardStrategy("4111...")).pay(99.99);
new PaymentProcessor(new PayPalStrategy("user@email.com")).pay(99.99);Strategy สำหรับการบีบอัด
ตัวประมวลผลไฟล์สามารถใช้ CompressionStrategy ได้ คุณสามารถเสียบ GZIP, ZIP หรือ LZ4 ได้โดยไม่ต้องเปลี่ยนไปป์ไลน์การประมวลผลไฟล์
public interface CompressionStrategy {
byte[] compress(byte[] data) throws IOException;
}
public class GzipStrategy implements CompressionStrategy {
public byte[] compress(byte[] data) throws IOException { /* gzip */ return new byte[0]; }
}การรวม Strategy เข้ากับโรงงาน
ใช้โรงงานเพื่อเลือก Strategy ตามการกำหนดค่า โดยแยกตรรกะการเลือกออกจากทั้งบริบทและ Strategy เอง
SortStrategy strategy = switch (config.getSortMethod()) {
case "bubble" -> new BubbleSortStrategy();
case "merge" -> new MergeSortStrategy();
default -> Collections::sort;
};
new Sorter(strategy).sort(data);Strategy เทียบกับเมธอด Template
เมธอด Template ใช้การสืบทอด โครงร่างจะอยู่ในคลาสฐาน และคลาสย่อยจะเขียนทับขั้นตอนต่าง ๆ ส่วน Strategy ใช้การประกอบ โดยอัลกอริทึมจะอยู่ภายนอกทั้งหมด ควรเลือก Strategy เมื่อต้องการความยืดหยุ่นมากกว่า
กลยุทธ์ใน JDK
Comparator คือกลยุทธ์มาตรฐานของ JDK ส่งตัวเปรียบเทียบที่แตกต่างกันให้กับ Collections.sort เพื่อเปลี่ยนอัลกอริทึมการจัดลำดับโดยไม่ต้องแก้โค้ดคอลเลกชัน
List<String> names = List.of("Bob", "Alice", "Charlie");
names.stream().sorted(Comparator.comparingInt(String::length)).forEach(System.out::println);การทดสอบกลยุทธ์
กลยุทธ์สามารถทดสอบแยกเดี่ยวได้ง่าย เพียงเรียก strategy.sort(data) ในการทดสอบหน่วย แทรกกลยุทธ์จำลองลงในบริบทเพื่อทดสอบตรรกะการประสานงานของบริบท
ตรวจสอบอย่างรวดเร็ว
ความแตกต่างเชิงโครงสร้างที่สำคัญระหว่างกลยุทธ์กับเมธอดแม่แบบคืออะไร
ทบทวน
กลยุทธ์ห่อหุ้มอัลกอริทึมที่สับเปลี่ยนได้ไว้เบื้องหลังอินเทอร์เฟซร่วม ใช้แลมบ์ดาสำหรับกลยุทธ์ง่าย ๆ และใช้คลาสสำหรับกลยุทธ์ที่ซับซ้อน ผสานกับโรงงานเพื่อเลือกตามการกำหนดค่า
คำถามที่พบบ่อย
บทเรียน “รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้”
ห่อหุ้มอัลกอริทึมการเรียงลำดับหรือการชำระเงินไว้เบื้องหลังอินเทอร์เฟซ Strategy เพื่อสลับใช้งานขณะทำงาน คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม
ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- รูปแบบ Observer: การแจ้งเตือนเหตุการณ์
- รูปแบบ Strategy: อัลกอริทึมที่สลับใช้ได้
- รูปแบบ Command: การห่อหุ้มการกระทำ
- Template Method: การกำหนดโครงร่างอัลกอริทึม