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

รูปแบบ 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 sort

Strategy แบบแลมบ์ดา

เมื่ออินเทอร์เฟซ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

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