Sharing is caring!

Design Pattern ที่โปรแกรมเมอร์ควรเข้าใจ

ในโลกของการเขียนโปรแกรม ไม่ว่าคุณจะเป็นมือใหม่หรือมืออาชีพ คำว่า “Design Pattern” มักจะโผล่มาให้เราได้ยินอยู่เสมอ มันคือแนวทางแก้ปัญหาที่ผ่านการพิสูจน์มาแล้วในการพัฒนาซอฟต์แวร์ ช่วยให้โค้ดของเรายืดหยุ่นมากขึ้น ซ่อมบำรุงได้ง่าย และรองรับการเปลี่ยนแปลงในอนาคต

Design Pattern คืออะไร?

Design Pattern คือรูปแบบในการแก้ปัญหาโปรแกรมที่เกิดขึ้นบ่อย ๆ โดยใช้หลักการเขียนโค้ดที่ดี ซึ่งสามารถนำกลับมาใช้ซ้ำได้ และใช้ในบริบทที่หลากหลาย มันไม่ได้ระบุโค้ดสำเร็จรูป แต่ให้แนวคิดเชิงโครงสร้างและวิธีการ

3 หมวดหมู่หลักของ Design Pattern

• Creational Pattern: เกี่ยวกับการสร้างอ็อบเจกต์
• Structural Pattern: เกี่ยวกับโครงสร้างและองค์ประกอบของอ็อบเจกต์
• Behavioral Pattern: เกี่ยวกับพฤติกรรมการทำงานร่วมกันของอ็อบเจกต์

ตัวอย่าง Design Pattern ที่ควรเข้าใจ

1. Singleton Pattern

ใช้เมื่อเราต้องการให้อ็อบเจกต์มีเพียงหนึ่ง instance เท่านั้น เช่น Logger, Database connection

      public class Singleton { 
         private static Singleton instance; private Singleton() {

         } 
         public static Singleton getInstance() { 
            if (instance == null) { 
                  instance = new Singleton(); 
            } 
            return instance; 
         } 
      }
      

2. Factory Method

ช่วยสร้างอ็อบเจกต์โดยไม่ต้องบอกชนิดที่แน่นอนล่วงหน้า ใช้บ่อยในระบบที่รองรับคลาสหลายแบบ

         interface Shape {
            void draw();
         }
         class Circle implements Shape {
            public void draw() {
               System.out.println("Circle");
            }
         }
         class ShapeFactory {
            public Shape getShape(String type) {
               if ("circle".equals(type))
                  return new Circle();
               return null;
            }
         }
      

3. Strategy Pattern

เปลี่ยนพฤติกรรมของอ็อบเจกต์ในขณะ runtime โดยแยก logic ออกเป็น strategy หลายแบบ

         interface PaymentStrategy {
            void pay(int amount);
         }
         class CreditCardPayment implements PaymentStrategy {
            public void pay(int amount) {
               System.out.println("Paid by credit card");
            }
         }
         class ShoppingCart {
            private PaymentStrategy strategy;
            public void setPayment(PaymentStrategy strategy) {
               this.strategy = strategy;
            }
            public void checkout() {
               strategy.pay(100);
            }
         }
      

4. Observer Pattern

ใช้เมื่อมีอ็อบเจกต์หนึ่งต้องการแจ้งการเปลี่ยนแปลงไปยังอ็อบเจกต์อื่น เช่น ระบบ notification หรือ pub/sub

         interface Observer {
            void update();
         }
         class User implements Observer {
            public void update() {
               System.out.println("User notified");
            }
         }
         class Notifier {
            List lt;
            Observer gt;
            observers = new ArrayList();
            public void register(Observer o) {
               observers.add(o);
            }
            public void notifyAllObservers() {
               for (Observer o : observers) o.update();
            }
         }
      

ข้อดีของการใช้ Design Pattern

• เพิ่มความสามารถในการ reuse โค้ด
• ทำให้โค้ดอ่านง่าย และบำรุงรักษาได้ง่าย
• ลดความซับซ้อนในการออกแบบ
• ช่วยในการทำงานร่วมกันในทีม เพราะทุกคนใช้ pattern ที่เข้าใจตรงกัน

ข้อควรระวัง

• ไม่ควรใช้ Pattern โดยไม่เข้าใจหรือไม่จำเป็น
• บาง Pattern อาจทำให้โค้ดยุ่งยากขึ้นหากใช้ไม่เหมาะสม

สรุป

Design Pattern เป็นเครื่องมือทรงพลังสำหรับนักพัฒนาในการสร้างระบบที่ maintainable และ flexible ไม่จำเป็นต้องเรียนรู้ทุก pattern ทันที แต่อย่างน้อยควรรู้จักพื้นฐาน เช่น Singleton, Factory, Strategy และ Observer เพื่อให้สามารถนำไปประยุกต์ใช้ได้อย่างมั่นใจ

บทความนี้ใช้เวลาอ่านประมาณ 10-15 นาที หวังว่าจะเป็นแนวทางให้คุณเข้าใจและเริ่มต้นใช้งาน Design Pattern ได้อย่างถูกต้อง