refactor(oop): simplify customer communication generation and update factory method

Remove Template Patterns and use only Factory Patterns

Author: PunGrumpy

Design-Patterns-in-OOP/05-lab/customer-email-app/Customer.java

@@ -1,33 +1,12 @@
 public abstract class Customer {
-    /**
-     * Template method that defines the algorithm for creating a communications
-     * 
-     * @return the communication
-     */
-    public final String createCommunication() {
-        StringBuilder communication = new StringBuilder();
-        communication.append(createMail());
+    public String generateCommunication() {
+        String mail = createMail();
+        String brochure = createBrochure();
 
-        if (shouldIncludeBrochure()) {
-            communication.append("\n").append(createBrochure());
-        }
-        return communication.toString();
+        return brochure == null ? mail : mail + "\n" + brochure;
     }
 
-    /**
-     * Abstract method to be implemented by concrete customer types for mail creation
-     */
     protected abstract String createMail();
 
-    /**
-     * Abstract method to be implemented by concrete customer types for brochure creation
-     */
     protected abstract String createBrochure();
-
-    /**
-     * Hook method that can be overridden by subclasses to control brochure inclusion
-     */
-    protected boolean shouldIncludeBrochure() {
-        return true;
-    }
 }

Design-Patterns-in-OOP/05-lab/customer-email-app/CustomerFactory.java

@@ -1,38 +1,9 @@
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.Supplier;
-
 public class CustomerFactory {
-    private static final Map<String, Supplier<Customer>> CUSTOMER_TYPES = new HashMap<>();
-
-    static {
-        CUSTOMER_TYPES.put("Regular", RegularCustomer::new);
-        CUSTOMER_TYPES.put("Mountain", MountainCustomer::new);
-        CUSTOMER_TYPES.put("Delinquent", DelinquentCustomer::new);
-    }
-
-    /**
-     * Factory method to create customer instances
-     * 
-     * @param customerType the type of customer to create
-     * @return Customer instance
-     * @throws IllegalArgumentException if customer type is not supported
-     */
-    public static Customer createCustomer(String customerType) {
-        Supplier<Customer> supplier = CUSTOMER_TYPES.get(customerType);
-        if (supplier == null) {
-            throw new IllegalArgumentException("Unsupported customer type: " + customerType);
-        }
-        return supplier.get();
-    }
-
-    /**
-     * Register a new customer type
-     * 
-     * @param type customer type identifier
-     * @param supplier supplier function to create customer instance
-     */
-    public static void registerCustomerType(String type, Supplier<Customer> supplier) {
-        CUSTOMER_TYPES.put(type, supplier);
+    public static Customer createCustomer(CustomerType type) {
+        return switch (type) {
+            case REGULAR -> new RegularCustomer();
+            case MOUNTAIN -> new MountainCustomer();
+            case DELINQUENT -> new DelinquentCustomer();
+        };
     }
 }

Design-Patterns-in-OOP/05-lab/customer-email-app/CustomerMailApplication.java

@@ -1,39 +1,29 @@
-import java.util.Objects;
 import java.util.Scanner;
 
 public class CustomerMailApplication {
-    private final Customer customer;
+    private static final Scanner scanner = new Scanner(System.in);
 
-    public CustomerMailApplication(Customer customer) {
-        this.customer = Objects.requireNonNull(customer, "Customer cannot be null");
-    }
-
-    public static String getCustomerTypeFromUser() {
-        try (Scanner scanner = new Scanner(System.in)) {
-            System.out.print("Please choose customer type 1. Regular, 2. Mountain, 3. Delinquent ");
-            int type = scanner.nextInt();
-
-            return switch (type) {
-                case 1 -> "Regular";
-                case 2 -> "Mountain";
-                case 3 -> "Delinquent";
-                default -> throw new IllegalArgumentException("Invalid customer type: " + type);
-            };
-        }
-    }
+    private static CustomerType getCustomerTypeFromUser() {
+        System.out.print("Please choose customer type 1. Regular, 2. Mountain, 3. Delinquent: ");
+        int choice = scanner.nextInt();
 
-    public String generateCommunication() {
-        return customer.createCommunication();
+        return switch (choice) {
+            case 1 -> CustomerType.REGULAR;
+            case 2 -> CustomerType.MOUNTAIN;
+            case 3 -> CustomerType.DELINQUENT;
+            default -> throw new IllegalArgumentException("Invalid choice");
+        };
     }
 
     public static void main(String[] args) {
         try {
-            String customerType = getCustomerTypeFromUser();
-            Customer customer = CustomerFactory.createCustomer(customerType);
-            CustomerMailApplication app = new CustomerMailApplication(customer);
-            System.out.println(app.generateCommunication());
-        } catch (Exception e) {
-            System.err.println("An error occurred: " + e.getMessage());
+            CustomerType type = getCustomerTypeFromUser();
+            Customer customer = CustomerFactory.createCustomer(type);
+            System.out.println(customer.generateCommunication());
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+        } finally {
+            scanner.close();
         }
     }
 }

Design-Patterns-in-OOP/05-lab/customer-email-app/CustomerType.java

@@ -0,0 +1,3 @@
+public enum CustomerType {
+    REGULAR, MOUNTAIN, DELINQUENT
+}

Design-Patterns-in-OOP/05-lab/customer-email-app/DelinquentCustomer.java

@@ -6,11 +6,6 @@ protected String createMail() {
 
     @Override
     protected String createBrochure() {
-        return "Delinquent Customer Brochure";
-    }
-
-    @Override
-    protected boolean shouldIncludeBrochure() {
-        return false; // Delinquent customers don't receive brochures
+        return null; // Delinquent customers don't receive brochures
     }
 }

Design-Patterns-in-OOP/05-lab/customer-email-app/README.md

@@ -1,60 +1,39 @@
 # Explaining the use of Design Patterns in customer emails
 
-## Design Patterns used in the system
+## Design Pattern used in the system
 
-### 1. Template Method Pattern
+### Factory Method Pattern
 
 #### Usage
 
-Pattern นี้ถูกใช้ในคลาส `Customer` เพื่อกำหนดโครงสร้างการสร้างการสื่อสารกับลูกค้า
+Pattern นี้ถูกใช้ในการสร้างออบเจ็กต์ของ Customer แต่ละประเภท โดยแยกส่วนการสร้างออบเจ็กต์ออกจากส่วนที่ใช้งาน
 
 #### Components
 
-- **Template Method**: `createCommunication()` ในคลาส `Customer`
+- **Abstract Product**: `Customer` (Abstract Class)
 
-  - กำหนดลำดับขั้นตอนการทำงานหลัก
-  - เรียกใช้ `createMail()` และ `createBrochure()`
-  - ควบคุมการแสดงผลรวม
+  - กำหนด abstract method `createMail()` ที่ลูกทุกคลาสต้องนำไป implement
 
-- **Abstract Methods**:
+- **Concrete Products**:
 
-  - `createMail()` - เมธอดที่คลาสลูกต้องกำหนดวิธีการสร้างจดหมาย
-  - `createBrochure()` - เมธอดที่คลาสลูกต้องกำหนดวิธีการสร้างโบรชัวร์
+  - `RegularCustomer` - สำหรับลูกค้าทั่วไป
+  - `MountainCustomer` - สำหรับลูกค้าแถบภูเขา
+  - `DelinquentCustomer` - สำหรับลูกค้าที่ค้างชำระ
 
-- **Hook Method**:
-  - `shouldIncludeBrochure()` - ให้คลาสลูกควบคุมว่าจะรวมโบรชัวร์หรือไม่
-  - ตัวอย่างการใช้: คลาส `DelinquentCustomer` override เพื่อไม่ส่งโบรชัวร์
+- **Factory Class**: `CustomerMailApplication`
+  - มีเมธอด `getCustomerTypeFromUser()` สำหรับรับประเภทลูกค้าจากผู้ใช้
+  - สร้างออบเจ็กต์ Customer ตามประเภทที่ผู้ใช้เลือก
 
 #### Benefits
 
-- แยกส่วนที่เหมือนกันไว้ใน parent class ลดการเขียนโค้ดซ้ำ
-- child class สามารถปรับเปลี่ยนเฉพาะส่วนที่ต้องการได้
-- รักษาโครงสร้างการทำงานหลักให้เหมือนกันทุกประเภทลูกค้า
+- แยกการสร้างออบเจ็กต์ออกจากส่วนที่ใช้งาน ทำให้โค้ดมีความยืดหยุ่น
+- สามารถเพิ่มประเภทลูกค้าใหม่ได้โดยไม่ต้องแก้ไขโค้ดเดิม
+- โค้ดส่วนที่ใช้งานไม่จำเป็นต้องรู้รายละเอียดการสร้างออบเจ็กต์
+- ทำให้ระบบรองรับการขยายตัวในอนาคตได้ง่าย
 
-### 2. Factory Pattern
+#### How the system works
 
-#### Usage
-
-Pattern นี้ถูกใช้ในคลาส `CustomerFactory` เพื่อจัดการการสร้างอ็อบเจกต์ลูกค้าประเภทต่างๆ
-
-#### Components
-
-- **Factory Class**: `CustomerFactory`
-  - มีเมธอด `createCustomer()` สำหรับสร้างอ็อบเจกต์ลูกค้า
-  - ใช้ Map เก็บความสัมพันธ์ระหว่างประเภทลูกค้ากับวิธีการสร้าง
-  - มีเมธอด `registerCustomerType()` สำหรับเพิ่มประเภทลูกค้าใหม่
-
-#### Benefits
-
-- แยกการสร้างอ็อบเจกต์ออกจาก Usage
-- รองรับการเพิ่มประเภทลูกค้าใหม่โดยไม่ต้องแก้ไขโค้ดเดิม
-- ลดการเชื่อมโยงระหว่างโค้ดที่ใช้งานกับคลาสลูกค้าแต่ละประเภท
-
-## How Design Patterns work together
-
-Design Patterns ทั้งสองทำงานร่วมกันดังนี้:
-
-1. `CustomerFactory` สร้างอ็อบเจกต์ลูกค้าประเภทที่ต้องการ
-2. อ็อบเจกต์ที่สร้างขึ้นใช้ Template Method Pattern ในการสร้างการสื่อสาร
-3. แต่ละประเภทลูกค้ากำหนดรายละเอียดเฉพาะของตนเองผ่าน abstract methods
-4. การควบคุมพิเศษ (เช่น การไม่ส่งโบรชัวร์) ทำได้ผ่าน hook method
+1. ผู้ใช้เลือกประเภทลูกค้าผ่านเมธอด `getCustomerTypeFromUser()`
+2. ระบบสร้างออบเจ็กต์ Customer ตามประเภทที่เลือก
+3. เรียกใช้เมธอด `createMail()` เพื่อสร้างข้อความสำหรับลูกค้าแต่ละประเภท
+4. แสดงผลข้อความที่สร้างขึ้น