🎓 Danh sách khóa học Thầy Lê Chí Tuyền

// Singleton – C++17. Biên dịch: g++ -std=c++17 01-singleton.cpp
// Trên Arduino/ESP32: thay std::cout bằng Serial.println.
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <thread>
#include <mutex>
#include <vector>

// Cách 1 – "Meyers Singleton": biến static cục bộ trong hàm.
// Từ C++11, chuẩn đảm bảo việc khởi tạo biến static cục bộ là thread-safe
// và chỉ diễn ra MỘT lần, ở lần gọi đầu tiên (lazy).
class AppConfig {
public:
    static AppConfig& getInstance() {
        static AppConfig instance;          // nằm ở vùng nhớ tĩnh, không dùng heap
        return instance;
    }
    // Cấm sao chép và gán -> không thể tạo bản thứ hai
    AppConfig(const AppConfig&) = delete;
    AppConfig& operator=(const AppConfig&) = delete;

    void set(const std::string& k, const std::string& v) { props_[k] = v; }
    std::string get(const std::string& k) const { return props_.at(k); }

private:
    AppConfig() { std::cout << ">> AppConfig được khởi tạo (chỉ 1 lần)\n"; }
    std::map<std::string, std::string> props_;
};

// Cách 2 – Singleton quản lý một ngoại vi phần cứng (UART giả lập).
// Trên vi điều khiển chỉ có MỘT bộ UART0 thật, nên đối tượng điều khiển nó
// cũng chỉ nên có một. std::call_once đảm bảo init phần cứng chạy đúng 1 lần.
class Uart0 {
public:
    static Uart0& getInstance() {
        static Uart0 instance;
        std::call_once(initFlag_, [] { instance.initHardware(115200); });
        return instance;
    }
    Uart0(const Uart0&) = delete;
    Uart0& operator=(const Uart0&) = delete;

    static inline int initCount = 0;
private:
    Uart0() = default;
    void initHardware(int baud) { ++initCount; baud_ = baud; /* cấu hình thanh ghi... */ }
    int baud_ = 0;
    static inline std::once_flag initFlag_;
};

int main() {
    AppConfig& c1 = AppConfig::getInstance();
    AppConfig& c2 = AppConfig::getInstance();
    c1.set("wifi.ssid", "BKSTAR-Lab");
    std::cout << "&c1 == &c2 ? " << std::boolalpha << (&c1 == &c2) << "\n";
    std::cout << "Đọc qua c2: wifi.ssid = " << c2.get("wifi.ssid") << "\n";

    // 50 luồng cùng gọi getInstance()
    std::set<const void*> addrs;
    std::mutex m;
    std::vector<std::thread> threads;
    for (int i = 0; i < 50; ++i)
        threads.emplace_back([&] {
            const void* p = &Uart0::getInstance();
            std::lock_guard<std::mutex> lock(m);
            addrs.insert(p);
        });
    for (auto& t : threads) t.join();
    std::cout << "Số địa chỉ Uart0 khác nhau từ 50 luồng: " << addrs.size() << "\n";
    std::cout << "Số lần initHardware() chạy: " << Uart0::initCount << "\n";

    // AppConfig x;                 // LỖI biên dịch: constructor là private
    // AppConfig y = c1;            // LỖI biên dịch: copy constructor đã bị delete
}

"""Singleton – Python 3.
Trong Python, MODULE chính là singleton tự nhiên: import nhiều lần vẫn chỉ nạp một lần.
Ở đây minh hoạ thêm 2 cách viết bằng lớp. (MicroPython trên ESP32 dùng được cách 1 và module.)"""
import threading


# Cách 1 – ghi đè __new__: mọi lần gọi AppConfig() đều trả về cùng một đối tượng
class AppConfig:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls):
        if cls._instance is None:                 # kiểm tra nhanh, không khoá
            with cls._lock:
                if cls._instance is None:         # double-checked locking
                    print(">> AppConfig được khởi tạo (chỉ 1 lần)")
                    cls._instance = super().__new__(cls)
                    cls._instance.props = {}
        return cls._instance


# Cách 2 – metaclass: tái sử dụng cho nhiều lớp
class SingletonMeta(type):
    _instances = {}
    _lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        with cls._lock:
            if cls not in cls._instances:
                cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]


class Uart0(metaclass=SingletonMeta):
    init_count = 0

    def __init__(self, baud=115200):
        Uart0.init_count += 1                     # chỉ chạy 1 lần nhờ metaclass
        self.baud = baud


if __name__ == "__main__":
    c1 = AppConfig()
    c2 = AppConfig()
    c1.props["wifi.ssid"] = "BKSTAR-Lab"
    print("c1 is c2 ?", c1 is c2)
    print("Đọc qua c2: wifi.ssid =", c2.props["wifi.ssid"])

    ids = set()
    threads = [threading.Thread(target=lambda: ids.add(id(Uart0()))) for _ in range(50)]
    for t in threads: t.start()
    for t in threads: t.join()
    print("Số đối tượng Uart0 khác nhau từ 50 luồng:", len(ids))
    print("Số lần __init__ của Uart0 chạy:", Uart0.init_count)

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class SingletonDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1. Lấy instance nhiều lần -> luôn là cùng một đối tượng
        AppConfig c1 = AppConfig.getInstance();
        AppConfig c2 = AppConfig.getInstance();
        c1.set("wifi.ssid", "BKSTAR-Lab");
        System.out.println("c1 == c2 ? " + (c1 == c2));
        System.out.println("Đọc qua c2: wifi.ssid = " + c2.get("wifi.ssid"));

        // 2. Kiểm tra an toàn đa luồng: 50 luồng cùng gọi getInstance()
        Set<Integer> ids = ConcurrentHashMap.newKeySet();
        Thread[] threads = new Thread[50];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> ids.add(System.identityHashCode(LazyLogger.getInstance())));
            threads[i].start();
        }
        for (Thread t : threads) t.join();
        System.out.println("Số instance LazyLogger tạo ra bởi 50 luồng: " + ids.size());
        System.out.println("Số lần constructor LazyLogger chạy: " + LazyLogger.constructed);

        // 3. Enum Singleton – cách ngắn gọn và an toàn nhất trong Java
        Counter.INSTANCE.increase();
        Counter.INSTANCE.increase();
        System.out.println("Counter.INSTANCE.value = " + Counter.INSTANCE.value());
    }
}

/** Cách 1 – Bill Pugh (static holder): lazy + thread-safe, không cần synchronized. */
final class AppConfig {
    private final java.util.Map<String, String> props = new java.util.HashMap<>();

    private AppConfig() {                       // constructor private: bên ngoài không thể new
        System.out.println(">> AppConfig được khởi tạo (chỉ 1 lần)");
    }

    private static class Holder {               // lớp này chỉ được nạp khi gọi getInstance()
        private static final AppConfig INSTANCE = new AppConfig();
    }

    public static AppConfig getInstance() {
        return Holder.INSTANCE;
    }

    public void set(String key, String value) { props.put(key, value); }
    public String get(String key)             { return props.get(key); }
}

/** Cách 2 – Double-checked locking: lazy, thread-safe, chỉ khóa ở lần tạo đầu tiên. */
final class LazyLogger {
    static volatile int constructed = 0;
    private static volatile LazyLogger instance; // volatile để tránh lỗi reorder lệnh

    private LazyLogger() { constructed++; }

    public static LazyLogger getInstance() {
        if (instance == null) {                  // kiểm tra lần 1 – không khóa (nhanh)
            synchronized (LazyLogger.class) {
                if (instance == null) {          // kiểm tra lần 2 – trong vùng khóa
                    instance = new LazyLogger();
                }
            }
        }
        return instance;
    }
}

/** Cách 3 – Enum: JVM đảm bảo duy nhất, chống cả reflection và serialization. */
enum Counter {
    INSTANCE;
    private int value;
    public void increase() { value++; }
    public int value()     { return value; }
}

// Factory Method – C++17
#include <iostream>
#include <memory>
#include <string>
#include <typeinfo>

// ===== Product =====
class Notification {
public:
    virtual ~Notification() = default;           // destructor ảo: bắt buộc khi xoá qua con trỏ lớp cha
    virtual void send(const std::string& message) = 0;
};

// ===== Concrete Products =====
class EmailNotification : public Notification {
public:
    void send(const std::string& m) override { std::cout << "[EMAIL] " << m << "\n"; }
};

class SmsNotification : public Notification {
public:
    void send(const std::string& m) override {
        // SMS giới hạn độ dài (tính theo byte để đơn giản)
        std::cout << "[SMS]   " << (m.size() > 30 ? m.substr(0, 30) + "..." : m) << "\n";
    }
};

class ZaloNotification : public Notification {
public:
    void send(const std::string& m) override { std::cout << "[ZALO]  " << m << " 👍\n"; }
};

// ===== Creator =====
class NotificationService {
public:
    virtual ~NotificationService() = default;

    // Logic nghiệp vụ dùng sản phẩm mà KHÔNG biết lớp cụ thể của nó
    void notifyUser(const std::string& message) {
        std::unique_ptr<Notification> n = createNotification();
        std::cout << name() << " -> ";
        n->send(message);
    }

protected:
    // FACTORY METHOD – lớp con quyết định tạo đối tượng nào
    virtual std::unique_ptr<Notification> createNotification() = 0;
    virtual const char* name() const = 0;
};

// ===== Concrete Creators =====
class EmailService : public NotificationService {
protected:
    std::unique_ptr<Notification> createNotification() override { return std::make_unique<EmailNotification>(); }
    const char* name() const override { return "EmailService"; }
};

class SmsService : public NotificationService {
protected:
    std::unique_ptr<Notification> createNotification() override { return std::make_unique<SmsNotification>(); }
    const char* name() const override { return "SmsService"; }
};

class ZaloService : public NotificationService {
protected:
    std::unique_ptr<Notification> createNotification() override { return std::make_unique<ZaloNotification>(); }
    const char* name() const override { return "ZaloService"; }
};

int main() {
    EmailService email;
    SmsService sms;
    ZaloService zalo;
    NotificationService* services[] = { &email, &sms, &zalo };   // mảng tĩnh, không cấp phát
    for (NotificationService* s : services)
        s->notifyUser("Lop Design Pattern bat dau luc 19h toi nay!");
}

"""Factory Method – Python 3. Dùng abc.ABC để khai báo lớp/phương thức trừu tượng."""
from abc import ABC, abstractmethod


# ===== Product =====
class Notification(ABC):
    @abstractmethod
    def send(self, message: str) -> None: ...


class EmailNotification(Notification):
    def send(self, message): print(f"[EMAIL] {message}")


class SmsNotification(Notification):
    def send(self, message):
        text = message[:30] + "..." if len(message) > 30 else message
        print(f"[SMS]   {text}")


class ZaloNotification(Notification):
    def send(self, message): print(f"[ZALO]  {message} 👍")


# ===== Creator =====
class NotificationService(ABC):
    @abstractmethod
    def create_notification(self) -> Notification:
        """Factory Method – lớp con quyết định tạo đối tượng nào."""

    def notify_user(self, message: str) -> None:
        n = self.create_notification()
        print(f"{type(self).__name__} -> ", end="")
        n.send(message)


# ===== Concrete Creators =====
class EmailService(NotificationService):
    def create_notification(self): return EmailNotification()


class SmsService(NotificationService):
    def create_notification(self): return SmsNotification()


class ZaloService(NotificationService):
    def create_notification(self): return ZaloNotification()


if __name__ == "__main__":
    for service in (EmailService(), SmsService(), ZaloService()):
        service.notify_user("Lớp Design Pattern bắt đầu lúc 19h tối nay!")

    # Python: lớp là "first-class object" nên Simple Factory thường chỉ là một dict
    registry = {"email": EmailNotification, "sms": SmsNotification}
    registry["sms"]().send("Tạo đối tượng từ tên lớp lưu trong dict")

public class FactoryMethodDemo {
    public static void main(String[] args) {
        // Client chỉ làm việc với lớp trừu tượng NotificationService.
        // Muốn đổi kênh gửi -> đổi lớp con, không sửa logic gửi.
        NotificationService[] services = {
            new EmailService(),
            new SmsService(),
            new ZaloService()
        };
        for (NotificationService s : services) {
            s.notifyUser("Lớp Design Pattern bắt đầu lúc 19h tối nay!");
        }
    }
}

// ===== Product: giao diện chung cho mọi loại thông báo =====
interface Notification {
    void send(String message);
}

// ===== Concrete Products =====
class EmailNotification implements Notification {
    public void send(String message) { System.out.println("[EMAIL] " + message); }
}

class SmsNotification implements Notification {
    public void send(String message) {
        // SMS giới hạn độ dài -> xử lý riêng ở đây
        String text = message.length() > 30 ? message.substring(0, 30) + "..." : message;
        System.out.println("[SMS]   " + text);
    }
}

class ZaloNotification implements Notification {
    public void send(String message) { System.out.println("[ZALO]  " + message + " 👍"); }
}

// ===== Creator: chứa thuật toán chung + "factory method" trừu tượng =====
abstract class NotificationService {

    /** Factory Method – lớp con quyết định tạo đối tượng cụ thể nào. */
    protected abstract Notification createNotification();

    /** Logic nghiệp vụ dùng sản phẩm mà KHÔNG biết lớp cụ thể của nó. */
    public void notifyUser(String message) {
        Notification n = createNotification();
        System.out.print(getClass().getSimpleName() + " -> ");
        n.send(message);
    }
}

// ===== Concrete Creators =====
class EmailService extends NotificationService {
    protected Notification createNotification() { return new EmailNotification(); }
}

class SmsService extends NotificationService {
    protected Notification createNotification() { return new SmsNotification(); }
}

class ZaloService extends NotificationService {
    protected Notification createNotification() { return new ZaloNotification(); }
}

// Abstract Factory – C++17
// (Trong firmware, ý tưởng tương tự: một factory cho màn hình OLED, một factory cho LCD.)
// Ở đây: mỗi "họ" giao diện Light/Dark gồm Button + Checkbox cùng phong cách.
#include <iostream>
#include <memory>

// ===== Abstract Products =====
class Button   { public: virtual ~Button() = default;   virtual void paint() const = 0; };
class Checkbox { public: virtual ~Checkbox() = default; virtual void paint() const = 0; };

// ===== Họ Light =====
class LightButton : public Button {
public: void paint() const override { std::cout << "[ Nút nền trắng, chữ đen ]\n"; }
};
class LightCheckbox : public Checkbox {
public: void paint() const override { std::cout << "[x] Checkbox viền xám nhạt\n"; }
};

// ===== Họ Dark =====
class DarkButton : public Button {
public: void paint() const override { std::cout << "[ Nút nền đen, chữ trắng ]\n"; }
};
class DarkCheckbox : public Checkbox {
public: void paint() const override { std::cout << "[x] Checkbox viền trắng phát sáng\n"; }
};

// ===== Abstract Factory =====
class UIFactory {
public:
    virtual ~UIFactory() = default;
    virtual std::unique_ptr<Button>   createButton() const = 0;
    virtual std::unique_ptr<Checkbox> createCheckbox() const = 0;
};

// ===== Concrete Factories =====
class LightThemeFactory : public UIFactory {
public:
    std::unique_ptr<Button>   createButton() const override   { return std::make_unique<LightButton>(); }
    std::unique_ptr<Checkbox> createCheckbox() const override { return std::make_unique<LightCheckbox>(); }
};
class DarkThemeFactory : public UIFactory {
public:
    std::unique_ptr<Button>   createButton() const override   { return std::make_unique<DarkButton>(); }
    std::unique_ptr<Checkbox> createCheckbox() const override { return std::make_unique<DarkCheckbox>(); }
};

// Client – chỉ biết interface
void render(const UIFactory& factory) {
    auto button = factory.createButton();
    auto checkbox = factory.createCheckbox();
    button->paint();
    checkbox->paint();
}

int main() {
    // Thực tế: chọn factory theo chân cấu hình phần cứng hoặc macro lúc biên dịch
    LightThemeFactory light;
    DarkThemeFactory dark;
    render(light);
    std::cout << "-----\n";
    render(dark);
}

"""Abstract Factory – Python 3."""
from abc import ABC, abstractmethod


# ===== Abstract Products =====
class Button(ABC):
    @abstractmethod
    def paint(self): ...


class Checkbox(ABC):
    @abstractmethod
    def paint(self): ...


# ===== Họ Light =====
class LightButton(Button):
    def paint(self): print("[ Nút nền trắng, chữ đen ]")


class LightCheckbox(Checkbox):
    def paint(self): print("[x] Checkbox viền xám nhạt")


# ===== Họ Dark =====
class DarkButton(Button):
    def paint(self): print("[ Nút nền đen, chữ trắng ]")


class DarkCheckbox(Checkbox):
    def paint(self): print("[x] Checkbox viền trắng phát sáng")


# ===== Abstract Factory =====
class UIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button: ...

    @abstractmethod
    def create_checkbox(self) -> Checkbox: ...


class LightThemeFactory(UIFactory):
    def create_button(self): return LightButton()
    def create_checkbox(self): return LightCheckbox()


class DarkThemeFactory(UIFactory):
    def create_button(self): return DarkButton()
    def create_checkbox(self): return DarkCheckbox()


def render(factory: UIFactory) -> None:
    """Client – chỉ biết interface."""
    factory.create_button().paint()
    factory.create_checkbox().paint()


if __name__ == "__main__":
    theme = {"light": LightThemeFactory, "dark": DarkThemeFactory}
    render(theme["light"]())
    print("-----")
    render(theme["dark"]())

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        // Chọn "họ" sản phẩm một lần duy nhất ở đây (có thể đọc từ cấu hình)
        render(new LightThemeFactory());
        System.out.println("-----");
        render(new DarkThemeFactory());
    }

    /** Client: chỉ biết các interface, không biết lớp cụ thể nào. */
    static void render(UIFactory factory) {
        Button button = factory.createButton();
        Checkbox checkbox = factory.createCheckbox();
        button.paint();
        checkbox.paint();
    }
}

// ===== Abstract Products =====
interface Button   { void paint(); }
interface Checkbox { void paint(); }

// ===== Concrete Products – họ Light =====
class LightButton implements Button {
    public void paint() { System.out.println("[ Nút nền trắng, chữ đen ]"); }
}
class LightCheckbox implements Checkbox {
    public void paint() { System.out.println("[x] Checkbox viền xám nhạt"); }
}

// ===== Concrete Products – họ Dark =====
class DarkButton implements Button {
    public void paint() { System.out.println("[ Nút nền đen, chữ trắng ]"); }
}
class DarkCheckbox implements Checkbox {
    public void paint() { System.out.println("[x] Checkbox viền trắng phát sáng"); }
}

// ===== Abstract Factory: tạo ra cả một HỌ sản phẩm liên quan =====
interface UIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// ===== Concrete Factories: mỗi factory đảm bảo các sản phẩm "hợp tông" =====
class LightThemeFactory implements UIFactory {
    public Button createButton()     { return new LightButton(); }
    public Checkbox createCheckbox() { return new LightCheckbox(); }
}

class DarkThemeFactory implements UIFactory {
    public Button createButton()     { return new DarkButton(); }
    public Checkbox createCheckbox() { return new DarkCheckbox(); }
}

// Builder – C++17
#include <iostream>
#include <optional>
#include <string>
#include <vector>

class Robot {
public:
    class Builder;                                // khai báo trước lớp lồng

    void print() const {
        std::cout << "Robot " << name_ << " | mạch=" << board_ << " | bánh=" << wheels_
                  << " | pin=" << batteryMah_ << "mAh | BT=" << (bluetooth_ ? "có" : "không") << " | cảm biến=[";
        for (size_t i = 0; i < sensors_.size(); ++i) std::cout << (i ? ", " : "") << sensors_[i];
        std::cout << "]\n";
    }

private:
    Robot() = default;                            // chỉ Builder mới tạo được Robot
    std::string name_, board_;
    int wheels_ = 2, batteryMah_ = 1000;
    bool bluetooth_ = false;
    std::vector<std::string> sensors_;
};

class Robot::Builder {
public:
    Builder(std::string name, std::string board) {          // tham số bắt buộc
        r_.name_ = std::move(name);
        r_.board_ = std::move(board);
    }
    Builder& wheels(int n)                { r_.wheels_ = n; return *this; }
    Builder& battery(int mAh)             { r_.batteryMah_ = mAh; return *this; }
    Builder& bluetooth(bool on)           { r_.bluetooth_ = on; return *this; }
    Builder& addSensor(std::string s)     { r_.sensors_.push_back(std::move(s)); return *this; }

    // Firmware nhúng thường TẮT exceptions (-fno-exceptions) nên trả về std::optional
    // thay cho throw: rỗng nghĩa là cấu hình không hợp lệ.
    std::optional<Robot> build() const {
        if (r_.wheels_ != 2 && r_.wheels_ != 4) return std::nullopt;
        return r_;
    }
private:
    Robot r_;
};

// Director – đóng gói các "công thức" lắp ráp
class RobotDirector {
public:
    std::optional<Robot> makeLineFollower() const {
        return Robot::Builder("LINE", "Arduino Nano").addSensor("Dò line x5").battery(1200).build();
    }
    std::optional<Robot> makeSumoRobot() const {
        return Robot::Builder("SUMO", "STM32").wheels(4).addSensor("Hồng ngoại x4").battery(2200).build();
    }
};

int main() {
    auto custom = Robot::Builder("BK-01", "ESP32")
                      .wheels(4)
                      .addSensor("Siêu âm HC-SR04")
                      .addSensor("Dò line TCRT5000")
                      .battery(3000)
                      .bluetooth(true)
                      .build();
    if (custom) custom->print();

    RobotDirector director;
    director.makeLineFollower()->print();
    director.makeSumoRobot()->print();

    auto bad = Robot::Builder("LOI", "Arduino Uno").wheels(3).build();
    std::cout << "Robot 3 bánh hợp lệ? " << (bad ? "có" : "không – build() trả về rỗng") << "\n";
}

"""Builder – Python 3.
Python có tham số đặt tên + giá trị mặc định nên "telescoping constructor" ít xảy ra.
Builder vẫn hữu ích khi cần xây từng bước, kiểm tra ràng buộc, hoặc có Director dùng lại công thức."""
from dataclasses import dataclass, field


@dataclass(frozen=True)                  # frozen=True -> đối tượng bất biến
class Robot:
    name: str
    board: str
    wheels: int = 2
    battery_mah: int = 1000
    bluetooth: bool = False
    sensors: tuple = field(default_factory=tuple)

    def __str__(self):
        return (f"Robot {self.name:<6}| mạch={self.board:<12}| bánh={self.wheels} | "
                f"pin={self.battery_mah}mAh | BT={str(self.bluetooth):<5}| cảm biến={list(self.sensors)}")


class RobotBuilder:
    def __init__(self, name: str, board: str):
        self._name, self._board = name, board
        self._wheels, self._battery, self._bt = 2, 1000, False
        self._sensors = []

    def wheels(self, n):        self._wheels = n; return self       # return self -> gọi nối tiếp
    def battery(self, mah):     self._battery = mah; return self
    def bluetooth(self, on):    self._bt = on; return self
    def add_sensor(self, s):    self._sensors.append(s); return self

    def build(self) -> Robot:
        if self._wheels not in (2, 4):
            raise ValueError(f"Robot chỉ hỗ trợ 2 hoặc 4 bánh, nhận được {self._wheels}")
        return Robot(self._name, self._board, self._wheels, self._battery, self._bt, tuple(self._sensors))


class RobotDirector:
    def make_line_follower(self):
        return RobotBuilder("LINE", "Arduino Nano").add_sensor("Dò line x5").battery(1200).build()

    def make_sumo_robot(self):
        return RobotBuilder("SUMO", "STM32").wheels(4).add_sensor("Hồng ngoại x4").battery(2200).build()


if __name__ == "__main__":
    custom = (RobotBuilder("BK-01", "ESP32")
              .wheels(4)
              .add_sensor("Siêu âm HC-SR04")
              .add_sensor("Dò line TCRT5000")
              .battery(3000)
              .bluetooth(True)
              .build())
    print(custom)
    director = RobotDirector()
    print(director.make_line_follower())
    print(director.make_sumo_robot())
    try:
        RobotBuilder("LOI", "Arduino Uno").wheels(3).build()
    except ValueError as e:
        print("Lỗi:", e)

import java.util.ArrayList;
import java.util.List;

public class BuilderDemo {
    public static void main(String[] args) {
        // 1. Dùng Builder trực tiếp với "fluent API" – dễ đọc, không cần nhớ thứ tự tham số
        Robot custom = new Robot.Builder("BK-01", "ESP32")
                .wheels(4)
                .addSensor("Siêu âm HC-SR04")
                .addSensor("Dò line TCRT5000")
                .battery(3000)
                .bluetooth(true)
                .build();
        System.out.println(custom);

        // 2. Dùng Director để đóng gói các "công thức" lắp ráp hay dùng
        RobotDirector director = new RobotDirector();
        System.out.println(director.makeLineFollower());
        System.out.println(director.makeSumoRobot());

        // 3. Builder kiểm tra dữ liệu trước khi tạo đối tượng
        try {
            new Robot.Builder("LOI", "Arduino Uno").wheels(3).build();
        } catch (IllegalStateException e) {
            System.out.println("Lỗi: " + e.getMessage());
        }
    }
}

/** Product – bất biến (immutable): mọi field là final, không có setter. */
final class Robot {
    private final String name;          // bắt buộc
    private final String board;         // bắt buộc
    private final int wheels;           // tuỳ chọn
    private final int batteryMah;       // tuỳ chọn
    private final boolean bluetooth;    // tuỳ chọn
    private final List<String> sensors; // tuỳ chọn

    private Robot(Builder b) {          // chỉ Builder mới gọi được
        this.name = b.name;
        this.board = b.board;
        this.wheels = b.wheels;
        this.batteryMah = b.batteryMah;
        this.bluetooth = b.bluetooth;
        this.sensors = List.copyOf(b.sensors);
    }

    @Override
    public String toString() {
        return String.format("Robot %-6s| mạch=%-12s| bánh=%d | pin=%dmAh | BT=%-5s| cảm biến=%s",
                name, board, wheels, batteryMah, bluetooth, sensors);
    }

    /** Builder – static nested class. */
    public static class Builder {
        private final String name;
        private final String board;
        private int wheels = 2;
        private int batteryMah = 1000;
        private boolean bluetooth = false;
        private final List<String> sensors = new ArrayList<>();

        public Builder(String name, String board) {      // tham số bắt buộc đưa vào constructor
            this.name = name;
            this.board = board;
        }
        public Builder wheels(int n)          { this.wheels = n; return this; }
        public Builder battery(int mAh)       { this.batteryMah = mAh; return this; }
        public Builder bluetooth(boolean on)  { this.bluetooth = on; return this; }
        public Builder addSensor(String s)    { this.sensors.add(s); return this; }

        public Robot build() {
            if (wheels != 2 && wheels != 4)
                throw new IllegalStateException("Robot chỉ hỗ trợ 2 hoặc 4 bánh, nhận được " + wheels);
            return new Robot(this);
        }
    }
}

/** Director – biết TRÌNH TỰ các bước để tạo ra những cấu hình chuẩn. */
class RobotDirector {
    Robot makeLineFollower() {
        return new Robot.Builder("LINE", "Arduino Nano")
                .addSensor("Dò line x5")
                .battery(1200)
                .build();
    }
    Robot makeSumoRobot() {
        return new Robot.Builder("SUMO", "STM32")
                .wheels(4)
                .addSensor("Hồng ngoại x4")
                .battery(2200)
                .build();
    }
}

// Prototype – C++17
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>

// ===== Ví dụ 1: ExamPaper – copy constructor của C++ đã là deep copy cho std::vector =====
class ExamPaper {
public:
    explicit ExamPaper(std::string title) : title_(std::move(title)) {}
    ExamPaper clone() const { return *this; }      // gọi copy constructor mặc định
    void setCode(std::string c)    { code_ = std::move(c); }
    void addQuestion(std::string q){ questions_.push_back(std::move(q)); }
    const std::vector<std::string>* questionsPtr() const { return &questions_; }
    void print() const {
        std::cout << code_ << " (" << title_ << "): " << questions_.size() << " câu\n";
    }
private:
    std::string title_, code_ = "Đề gốc";
    std::vector<std::string> questions_;          // vector có copy constructor sao chép từng phần tử
};

// ===== Ví dụ 2: Shape – clone qua con trỏ lớp cha ("virtual constructor") =====
class Shape {
public:
    virtual ~Shape() = default;
    virtual std::unique_ptr<Shape> clone() const = 0;   // C++ không có virtual constructor -> dùng clone()
    void move(int dx, int dy) { x_ += dx; y_ += dy; }
    virtual void print() const = 0;
protected:
    int x_ = 0, y_ = 0;
    std::string color_;
};

class Circle : public Shape {
public:
    Circle(int r, std::string color) : radius_(r) { color_ = std::move(color); }
    std::unique_ptr<Shape> clone() const override { return std::make_unique<Circle>(*this); }
    void print() const override {
        std::cout << "Circle(r=" << radius_ << ", " << color_ << ", @" << x_ << "," << y_ << ")";
    }
private:
    int radius_;
};

class ShapeRegistry {
public:
    ShapeRegistry() {
        prototypes_["red-circle"] = std::make_unique<Circle>(10, "đỏ");
        prototypes_["big-blue-circle"] = std::make_unique<Circle>(40, "xanh");
    }
    std::unique_ptr<Shape> get(const std::string& key) const { return prototypes_.at(key)->clone(); }
private:
    std::map<std::string, std::unique_ptr<Shape>> prototypes_;
};

// ===== Cạm bẫy: con trỏ thô (raw pointer) -> copy mặc định là SHALLOW =====
struct SensorBuffer {
    int* data;                                     // trỏ tới mảng cấp phát động
    explicit SensorBuffer(int n) : data(new int[n]{}) {}
    // Không tự viết copy constructor => bản sao dùng CHUNG mảng data (nguy hiểm, double-free!)
};

int main() {
    ExamPaper tpl("Đề kiểm tra C++ – 45 phút");
    tpl.addQuestion("Singleton là gì?");
    tpl.addQuestion("Phân biệt Factory Method và Abstract Factory.");

    ExamPaper deA = tpl.clone();
    deA.setCode("Mã đề 101");
    deA.addQuestion("Viết Builder cho lớp Student.");
    tpl.print();
    deA.print();
    std::cout << "deA dùng chung vector với đề gốc? " << std::boolalpha
              << (deA.questionsPtr() == tpl.questionsPtr()) << "\n";

    ShapeRegistry registry;
    auto c1 = registry.get("red-circle");
    auto c2 = registry.get("red-circle");
    c2->move(50, 50);
    c1->print(); std::cout << "  |  "; c2->print();
    std::cout << "  |  cùng đối tượng? " << (c1.get() == c2.get()) << "\n";

    SensorBuffer a(4);
    SensorBuffer b = a;                            // shallow copy
    b.data[0] = 99;
    std::cout << "Shallow copy: sửa b.data[0] làm a.data[0] = " << a.data[0] << "\n";
    delete[] a.data;                               // chỉ xoá 1 lần vì dùng chung
}

"""Prototype – Python 3. Module copy có sẵn: copy.copy (shallow) và copy.deepcopy (deep)."""
import copy


class ExamPaper:
    def __init__(self, title):
        self.title = title
        self.code = "Đề gốc"
        self.questions = []

    def clone(self):
        return copy.deepcopy(self)          # sao chép sâu: list questions cũng được nhân bản

    def __str__(self):
        return f"{self.code} ({self.title}): {len(self.questions)} câu"


class Circle:
    def __init__(self, radius, color):
        self.radius, self.color, self.x, self.y = radius, color, 0, 0

    def clone(self):
        return copy.copy(self)              # chỉ có field kiểu bất biến -> shallow là đủ

    def move(self, dx, dy):
        self.x += dx; self.y += dy

    def __str__(self):
        return f"Circle(r={self.radius}, {self.color}, @{self.x},{self.y})"


class ShapeRegistry:
    def __init__(self):
        self._prototypes = {"red-circle": Circle(10, "đỏ"), "big-blue-circle": Circle(40, "xanh")}

    def get(self, key):
        return self._prototypes[key].clone()


if __name__ == "__main__":
    template = ExamPaper("Đề kiểm tra Python – 45 phút")
    template.questions += ["Singleton là gì?", "Phân biệt Factory Method và Abstract Factory."]

    de_a = template.clone()
    de_a.code = "Mã đề 101"
    de_a.questions.append("Viết Builder cho lớp Student.")
    print(template)
    print(de_a)
    print("Dùng chung list câu hỏi?", de_a.questions is template.questions)

    # Cạm bẫy shallow copy
    de_b = copy.copy(template)
    de_b.questions.append("Câu hỏi thêm vào bản shallow copy")
    print("Sau khi sửa bản shallow, đề gốc có:", len(template.questions), "câu  <- bị ảnh hưởng!")

    reg = ShapeRegistry()
    c1, c2 = reg.get("red-circle"), reg.get("red-circle")
    c2.move(50, 50)
    print(c1, " | ", c2, " | cùng đối tượng?", c1 is c2)

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PrototypeDemo {
    public static void main(String[] args) {
        // 1. Tạo "bản mẫu" một lần (giả sử việc tạo rất tốn kém: đọc file, query DB...)
        ExamPaper template = new ExamPaper("Đề kiểm tra Java – 45 phút");
        template.addQuestion("Singleton là gì?");
        template.addQuestion("Phân biệt Factory Method và Abstract Factory.");

        // 2. Clone ra các đề con rồi chỉnh riêng từng đề
        ExamPaper deA = template.clone();
        deA.setCode("Mã đề 101");
        deA.addQuestion("Viết Builder cho lớp Student.");

        ExamPaper deB = template.clone();
        deB.setCode("Mã đề 102");
        deB.addQuestion("Vẽ UML của Prototype.");

        System.out.println(template);
        System.out.println(deA);
        System.out.println(deB);
        System.out.println("deA.questions == template.questions ? " + deA.sameQuestionsAs(template));

        // 3. Prototype Registry: lưu sẵn các bản mẫu, cần thì clone theo tên
        ShapeRegistry registry = new ShapeRegistry();
        Shape c1 = registry.get("red-circle");
        Shape c2 = registry.get("red-circle");
        c2.move(50, 50);
        System.out.println(c1 + "  |  " + c2 + "  |  cùng đối tượng? " + (c1 == c2));
    }
}

/** Prototype interface của Java chính là Cloneable + clone(). Ở đây tự định nghĩa cho rõ. */
interface Prototype<T> { T clone(); }

class ExamPaper implements Prototype<ExamPaper> {
    private final String title;
    private String code = "Đề gốc";
    private List<String> questions = new ArrayList<>();

    ExamPaper(String title) { this.title = title; }

    /** Copy constructor dùng cho clone – sao chép SÂU (deep copy) danh sách câu hỏi. */
    private ExamPaper(ExamPaper src) {
        this.title = src.title;
        this.code = src.code;
        this.questions = new ArrayList<>(src.questions); // nếu gán thẳng src.questions => shallow copy, các đề sẽ dùng chung list!
    }

    @Override public ExamPaper clone() { return new ExamPaper(this); }

    void setCode(String code)    { this.code = code; }
    void addQuestion(String q)   { questions.add(q); }
    boolean sameQuestionsAs(ExamPaper o) { return this.questions == o.questions; }

    @Override public String toString() {
        return code + " (" + title + "): " + questions.size() + " câu " + questions;
    }
}

abstract class Shape implements Prototype<Shape> {
    protected int x, y;
    protected String color;
    void move(int dx, int dy) { x += dx; y += dy; }
    @Override public abstract Shape clone();   // ghi đè Object.clone() (protected) thành public
}

class Circle extends Shape {
    int radius;
    Circle(int radius, String color) { this.radius = radius; this.color = color; }
    private Circle(Circle s) { this.x = s.x; this.y = s.y; this.color = s.color; this.radius = s.radius; }
    @Override public Circle clone() { return new Circle(this); }
    @Override public String toString() { return "Circle(r=" + radius + ", " + color + ", @" + x + "," + y + ")"; }
}

class ShapeRegistry {
    private final Map<String, Shape> prototypes = new HashMap<>();
    ShapeRegistry() {
        prototypes.put("red-circle", new Circle(10, "đỏ"));
        prototypes.put("big-blue-circle", new Circle(40, "xanh"));
    }
    Shape get(String key) { return prototypes.get(key).clone(); } // luôn trả về BẢN SAO
}

// Object Pool – C++17. Rất phổ biến trong firmware: KHÔNG malloc/new lúc chạy,
// mọi đối tượng nằm sẵn trong một mảng tĩnh có kích thước biết trước khi biên dịch.
#include <array>
#include <cstdio>
#include <iostream>

class DbConnection {                     // trên MCU có thể là: gói tin, buffer DMA, timer phần mềm...
public:
    static inline int created = 0;
    void open()  { id_ = ++created; std::cout << "  (khởi tạo kết nối #" << id_ << " – tốn ~200ms)\n"; }
    void query(const char* sql) { ++useCount_; std::cout << "  #" << id_ << " chạy: " << sql << "\n"; }
    void reset() { /* xoá trạng thái dở dang */ }
    void print() const { std::cout << "Conn#" << id_ << "(đã dùng " << useCount_ << " lần)"; }
private:
    int id_ = 0, useCount_ = 0;
};

template <typename T, size_t N>
class ObjectPool {
public:
    // Trả về nullptr khi pool đầy – firmware không ném exception
    T* acquire() {
        for (size_t i = 0; i < N; ++i) {
            if (!inUse_[i]) {
                if (!initialized_[i]) { items_[i].open(); initialized_[i] = true; }  // khởi tạo lười, 1 lần
                inUse_[i] = true;
                return &items_[i];
            }
        }
        return nullptr;
    }
    void release(T* obj) {
        size_t i = obj - items_.data();            // tính chỉ số từ địa chỉ
        if (i < N && inUse_[i]) { obj->reset(); inUse_[i] = false; }
    }
    void printStatus() const {
        size_t used = 0;
        for (bool b : inUse_) used += b;
        std::cout << "  [Pool] đang dùng=" << used << ", rảnh=" << N - used << ", tối đa=" << N << "\n";
    }
private:
    std::array<T, N> items_{};                     // bộ nhớ cấp phát TĨNH, biết trước lúc biên dịch
    std::array<bool, N> inUse_{};
    std::array<bool, N> initialized_{};
};

int main() {
    static ObjectPool<DbConnection, 2> pool;       // static: nằm trong .bss, không ở stack/heap

    DbConnection* a = pool.acquire();
    DbConnection* b = pool.acquire();
    a->query("SELECT * FROM students");
    b->query("SELECT * FROM courses");
    pool.printStatus();

    DbConnection* c = pool.acquire();
    std::cout << "Lấy thêm khi pool đầy -> " << (c ? "có" : "nullptr") << "\n";

    pool.release(a);
    pool.printStatus();

    DbConnection* d = pool.acquire();
    d->query("UPDATE scores SET point = 10");
    std::cout << "d có phải là a được tái sử dụng? " << std::boolalpha << (d == a) << "\n";
    pool.printStatus();
    std::cout << "Tổng số kết nối thực sự được tạo: " << DbConnection::created << "\n";
    std::cout << "Kích thước pool trong RAM: " << sizeof(pool) << " byte (cố định)\n";
}

"""Object Pool – Python 3. Dùng contextmanager để "mượn – tự động trả" bằng câu lệnh with."""
from contextlib import contextmanager


class DbConnection:
    created = 0

    def __init__(self):
        DbConnection.created += 1
        self.id = DbConnection.created
        self.use_count = 0
        print(f"  (tạo mới kết nối #{self.id} – tốn ~200ms)")

    def query(self, sql):
        self.use_count += 1
        print(f"  #{self.id} chạy: {sql}")

    def reset(self):
        pass                                # xoá transaction dở dang...


class ConnectionPool:
    def __init__(self, max_size):
        self.max_size = max_size
        self._available = []
        self._in_use = set()

    def acquire(self):
        if self._available:
            conn = self._available.pop()
        elif len(self._in_use) < self.max_size:
            conn = DbConnection()
        else:
            return None
        self._in_use.add(conn)
        return conn

    def release(self, conn):
        if conn in self._in_use:
            self._in_use.remove(conn)
            conn.reset()
            self._available.append(conn)

    @contextmanager
    def connection(self):
        conn = self.acquire()
        try:
            yield conn
        finally:
            if conn: self.release(conn)     # luôn trả lại, kể cả khi có lỗi

    def status(self):
        print(f"  [Pool] đang dùng={len(self._in_use)}, rảnh={len(self._available)}, tối đa={self.max_size}")


if __name__ == "__main__":
    pool = ConnectionPool(2)
    a, b = pool.acquire(), pool.acquire()
    a.query("SELECT * FROM students")
    b.query("SELECT * FROM courses")
    pool.status()
    print("Lấy thêm khi pool đầy ->", pool.acquire())
    pool.release(a)
    pool.status()

    with pool.connection() as d:            # mượn bằng with, tự trả khi ra khỏi khối
        d.query("UPDATE scores SET point = 10")
        print("d có phải là a được tái sử dụng?", d is a)
        pool.status()
    pool.status()
    print("Tổng số kết nối thực sự được tạo:", DbConnection.created)

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.Set;

public class ObjectPoolDemo {
    public static void main(String[] args) {
        ConnectionPool pool = new ConnectionPool(2); // tối đa 2 kết nối

        DbConnection a = pool.acquire();
        DbConnection b = pool.acquire();
        a.query("SELECT * FROM students");
        b.query("SELECT * FROM courses");
        pool.printStatus();

        DbConnection c = pool.acquire();             // pool đã cạn
        System.out.println("Lấy thêm khi pool đầy -> " + c);

        pool.release(a);                             // trả lại -> có thể tái sử dụng
        pool.printStatus();

        DbConnection d = pool.acquire();
        d.query("UPDATE scores SET point = 10");
        System.out.println("d có phải là kết nối a được tái sử dụng? " + (d == a));
        pool.printStatus();
        System.out.println("Tổng số kết nối thực sự được tạo: " + DbConnection.created);
    }
}

/** Đối tượng "đắt" – tạo mới tốn thời gian (mở socket, bắt tay, xác thực...). */
class DbConnection {
    static int created = 0;
    private final int id;
    private int useCount = 0;

    DbConnection() {
        id = ++created;
        System.out.println("  (tạo mới kết nối #" + id + " – tốn ~200ms)");
    }
    void query(String sql) { useCount++; System.out.println("  #" + id + " chạy: " + sql); }
    void reset()           { /* xoá transaction dở dang, đặt lại trạng thái */ }
    @Override public String toString() { return "Conn#" + id + "(đã dùng " + useCount + " lần)"; }
}

/** Object Pool – quản lý tập đối tượng có thể tái sử dụng. */
class ConnectionPool {
    private final int maxSize;
    private final Deque<DbConnection> available = new ArrayDeque<>();
    private final Set<DbConnection> inUse = new HashSet<>();

    ConnectionPool(int maxSize) { this.maxSize = maxSize; }

    public synchronized DbConnection acquire() {
        DbConnection conn;
        if (!available.isEmpty()) {
            conn = available.pop();                  // ưu tiên tái sử dụng
        } else if (inUse.size() < maxSize) {
            conn = new DbConnection();               // còn hạn mức -> tạo mới
        } else {
            return null;                             // hết -> trả null (thực tế: chờ hoặc ném lỗi)
        }
        inUse.add(conn);
        return conn;
    }

    public synchronized void release(DbConnection conn) {
        if (inUse.remove(conn)) {
            conn.reset();                            // làm sạch trước khi cho mượn lại
            available.push(conn);
        }
    }

    void printStatus() {
        System.out.println("  [Pool] đang dùng=" + inUse.size() + ", rảnh=" + available.size() + ", tối đa=" + maxSize);
    }
}

// Adapter – C++17. Tình huống nhúng điển hình: driver cảm biến từ thư viện khác
// có API không khớp với lớp trừu tượng (HAL) mà firmware của ta đang dùng.
#include <cstdio>
#include <string>

// ===== Target – interface mà firmware mong đợi =====
class TemperatureSensor {
public:
    virtual ~TemperatureSensor() = default;
    virtual std::string name() const = 0;
    virtual float readCelsius() = 0;
};

// Client
class Dashboard {
public:
    void show(TemperatureSensor& s) {
        float c = s.readCelsius();
        std::printf("%5.1f°C %s  <- %s\n", c, c > 30 ? "🔥 Nóng" : "🙂 Ổn  ", s.name().c_str());
    }
};

// Lớp đã tương thích sẵn
class Dht11Sensor : public TemperatureSensor {
public:
    std::string name() const override { return "DHT11 (nội địa)"; }
    float readCelsius() override { return 28.5f; }
};

// ===== Adaptee – thư viện bên thứ ba, KHÔNG được sửa =====
class UsFahrenheitSensor {
public:
    explicit UsFahrenheitSensor(const char* serial) : serial_(serial) {}
    const char* getSerialNumber() const { return serial_; }
    float getTempF() const { return 95.0f; }          // 95°F = 35°C
private:
    const char* serial_;
};

// ===== Cách 1 – Object Adapter (composition): giữ THAM CHIẾU tới adaptee =====
class FahrenheitSensorAdapter : public TemperatureSensor {
public:
    explicit FahrenheitSensorAdapter(UsFahrenheitSensor& adaptee) : adaptee_(adaptee) {}
    std::string name() const override { return std::string("Adapter[") + adaptee_.getSerialNumber() + "]"; }
    float readCelsius() override { return (adaptee_.getTempF() - 32.0f) * 5.0f / 9.0f; }
private:
    UsFahrenheitSensor& adaptee_;
};

// ===== Cách 2 – Class Adapter: đa kế thừa (C++ hỗ trợ) =====
// public kế thừa Target, private kế thừa Adaptee (chỉ dùng cài đặt, không lộ API cũ ra ngoài)
class FahrenheitClassAdapter : public TemperatureSensor, private UsFahrenheitSensor {
public:
    explicit FahrenheitClassAdapter(const char* serial) : UsFahrenheitSensor(serial) {}
    std::string name() const override { return std::string("ClassAdapter[") + getSerialNumber() + "]"; }
    float readCelsius() override { return (getTempF() - 32.0f) * 5.0f / 9.0f; }
};

int main() {
    Dht11Sensor dht;
    UsFahrenheitSensor usSensor("US-77");
    FahrenheitSensorAdapter adapter(usSensor);
    FahrenheitClassAdapter classAdapter("US-99");

    TemperatureSensor* sensors[] = { &dht, &adapter, &classAdapter };
    Dashboard dashboard;
    for (TemperatureSensor* s : sensors) dashboard.show(*s);
}

"""Adapter – Python 3."""
from abc import ABC, abstractmethod


class TemperatureSensor(ABC):                       # Target
    @abstractmethod
    def name(self) -> str: ...

    @abstractmethod
    def read_celsius(self) -> float: ...


class Dashboard:                                    # Client
    def show(self, s: TemperatureSensor):
        c = s.read_celsius()
        print(f"{c:5.1f}°C {'🔥 Nóng' if c > 30 else '🙂 Ổn  '}  <- {s.name()}")


class Dht11Sensor(TemperatureSensor):
    def name(self): return "DHT11 (nội địa)"
    def read_celsius(self): return 28.5


class UsFahrenheitSensor:                           # Adaptee – thư viện bên thứ ba
    def __init__(self, serial): self._serial = serial
    def get_serial_number(self): return self._serial
    def get_temp_f(self): return 95.0


class FahrenheitSensorAdapter(TemperatureSensor):   # Object Adapter
    def __init__(self, adaptee: UsFahrenheitSensor):
        self._adaptee = adaptee

    def name(self): return f"Adapter[{self._adaptee.get_serial_number()}]"
    def read_celsius(self): return (self._adaptee.get_temp_f() - 32) * 5 / 9


class FahrenheitClassAdapter(TemperatureSensor, UsFahrenheitSensor):   # Class Adapter (đa kế thừa)
    def name(self): return f"ClassAdapter[{self.get_serial_number()}]"
    def read_celsius(self): return (self.get_temp_f() - 32) * 5 / 9


if __name__ == "__main__":
    sensors = [Dht11Sensor(),
               FahrenheitSensorAdapter(UsFahrenheitSensor("US-77")),
               FahrenheitClassAdapter("US-99")]
    dashboard = Dashboard()
    for s in sensors:
        dashboard.show(s)

import java.util.List;

public class AdapterDemo {
    public static void main(String[] args) {
        // Hệ thống của ta chỉ hiểu TemperatureSensor (độ C).
        // Cảm biến Mỹ mua về lại trả về độ F và có API khác hẳn -> dùng Adapter.
        List<TemperatureSensor> sensors = List.of(
                new Dht11Sensor(),
                new FahrenheitSensorAdapter(new UsFahrenheitSensor("US-77")),        // Object Adapter
                new FahrenheitClassAdapter("US-99")                                  // Class Adapter
        );

        Dashboard dashboard = new Dashboard();
        for (TemperatureSensor s : sensors) dashboard.show(s);
    }
}

/** Target – giao diện mà client mong đợi. */
interface TemperatureSensor {
    String name();
    double readCelsius();
}

/** Client – chỉ làm việc với Target. */
class Dashboard {
    void show(TemperatureSensor s) {
        double c = s.readCelsius();
        System.out.printf("%-28s %.1f°C %s%n", s.name(), c, c > 30 ? "🔥 Nóng" : "🙂 Ổn");
    }
}

/** Lớp có sẵn đã tương thích. */
class Dht11Sensor implements TemperatureSensor {
    public String name()         { return "DHT11 (nội địa)"; }
    public double readCelsius()  { return 28.5; }
}

/** Adaptee – thư viện bên thứ ba, KHÔNG được sửa mã nguồn. */
class UsFahrenheitSensor {
    private final String serial;
    UsFahrenheitSensor(String serial) { this.serial = serial; }
    public String getSerialNumber()   { return serial; }
    public double getTempF()          { return 95.0; }   // 95°F = 35°C
}

/** Cách 1 – Object Adapter: CHỨA adaptee bên trong (composition) – được khuyên dùng. */
class FahrenheitSensorAdapter implements TemperatureSensor {
    private final UsFahrenheitSensor adaptee;
    FahrenheitSensorAdapter(UsFahrenheitSensor adaptee) { this.adaptee = adaptee; }

    public String name()        { return "Adapter[" + adaptee.getSerialNumber() + "]"; }
    public double readCelsius() { return (adaptee.getTempF() - 32) * 5 / 9; } // chuyển đổi dữ liệu
}

/** Cách 2 – Class Adapter: KẾ THỪA adaptee và implement target. */
class FahrenheitClassAdapter extends UsFahrenheitSensor implements TemperatureSensor {
    FahrenheitClassAdapter(String serial) { super(serial); }
    public String name()        { return "ClassAdapter[" + getSerialNumber() + "]"; }
    public double readCelsius() { return (getTempF() - 32) * 5 / 9; }
}

// Bridge – C++17
#include <algorithm>
#include <iostream>
#include <string>

// ===== Implementor =====
class Device {
public:
    virtual ~Device() = default;
    virtual bool isEnabled() const = 0;
    virtual void enable() = 0;
    virtual void disable() = 0;
    virtual int getVolume() const = 0;
    virtual void setVolume(int percent) = 0;
    virtual std::string name() const = 0;
    void printStatus() const {
        std::cout << "  " << name() << ": " << (isEnabled() ? "BẬT" : "TẮT") << ", âm lượng " << getVolume() << "%\n";
    }
};

// Gom code chung của các thiết bị
class BaseDevice : public Device {
public:
    bool isEnabled() const override { return on_; }
    void enable() override  { on_ = true; }
    void disable() override { on_ = false; }
    int getVolume() const override { return volume_; }
    void setVolume(int p) override { volume_ = std::clamp(p, 0, 100); }
private:
    bool on_ = false;
    int volume_ = 30;
};

// ===== Concrete Implementors =====
class Tv : public BaseDevice    { public: std::string name() const override { return "Tv"; } };
class Radio : public BaseDevice { public: std::string name() const override { return "Radio"; } };

// ===== Abstraction – giữ tham chiếu tới Implementor: đó chính là "cây cầu" =====
class RemoteControl {
public:
    explicit RemoteControl(Device& d) : device_(d) {}
    virtual ~RemoteControl() = default;
    void togglePower() {
        if (device_.isEnabled()) device_.disable(); else device_.enable();
        std::cout << "Nút nguồn -> " << (device_.isEnabled() ? "bật" : "tắt") << "\n";
    }
    void volumeUp()   { device_.setVolume(device_.getVolume() + 10); std::cout << "Tăng âm lượng\n"; }
    void volumeDown() { device_.setVolume(device_.getVolume() - 10); std::cout << "Giảm âm lượng\n"; }
protected:
    Device& device_;
};

// ===== Refined Abstraction =====
class AdvancedRemote : public RemoteControl {
public:
    using RemoteControl::RemoteControl;           // kế thừa constructor
    void mute() { device_.setVolume(0); std::cout << "Tắt tiếng (mute)\n"; }
};

int main() {
    Tv tv;
    RemoteControl basic(tv);
    basic.togglePower();
    basic.volumeUp();
    tv.printStatus();

    std::cout << "-----\n";
    Radio radio;
    AdvancedRemote advanced(radio);
    advanced.togglePower();
    advanced.volumeUp();
    advanced.mute();
    radio.printStatus();
}

"""Bridge – Python 3."""
from abc import ABC


class Device(ABC):                                  # Implementor (+ code chung)
    def __init__(self):
        self._on = False
        self._volume = 30

    def is_enabled(self): return self._on
    def enable(self): self._on = True
    def disable(self): self._on = False
    def get_volume(self): return self._volume
    def set_volume(self, p): self._volume = max(0, min(100, p))

    def print_status(self):
        print(f"  {type(self).__name__}: {'BẬT' if self._on else 'TẮT'}, âm lượng {self._volume}%")


class Tv(Device): pass
class Radio(Device): pass


class RemoteControl:                                # Abstraction
    def __init__(self, device: Device):
        self.device = device                        # "cây cầu"

    def toggle_power(self):
        self.device.disable() if self.device.is_enabled() else self.device.enable()
        print("Nút nguồn ->", "bật" if self.device.is_enabled() else "tắt")

    def volume_up(self):
        self.device.set_volume(self.device.get_volume() + 10)
        print("Tăng âm lượng")


class AdvancedRemote(RemoteControl):                # Refined Abstraction
    def mute(self):
        self.device.set_volume(0)
        print("Tắt tiếng (mute)")


if __name__ == "__main__":
    tv = Tv()
    basic = RemoteControl(tv)
    basic.toggle_power()
    basic.volume_up()
    tv.print_status()
    print("-----")
    radio = Radio()
    adv = AdvancedRemote(radio)
    adv.toggle_power()
    adv.volume_up()
    adv.mute()
    radio.print_status()

public class BridgeDemo {
    public static void main(String[] args) {
        // 2 loại điều khiển × 2 loại thiết bị = 4 tổ hợp, nhưng chỉ cần 2 + 2 = 4 lớp.
        // Nếu dùng kế thừa thuần: BasicRemoteTv, BasicRemoteRadio, AdvancedRemoteTv, ... (bùng nổ lớp)
        Device tv = new Tv();
        RemoteControl basic = new RemoteControl(tv);
        basic.togglePower();
        basic.volumeUp();
        tv.printStatus();

        System.out.println("-----");
        Device radio = new Radio();
        AdvancedRemote advanced = new AdvancedRemote(radio);
        advanced.togglePower();
        advanced.volumeUp();
        advanced.mute();
        radio.printStatus();
    }
}

// ===== Implementor: phía "thực thi" =====
interface Device {
    boolean isEnabled();
    void enable();
    void disable();
    int getVolume();
    void setVolume(int percent);
    void printStatus();
}

// ===== Concrete Implementors =====
abstract class BaseDevice implements Device {
    private boolean on = false;
    private int volume = 30;
    public boolean isEnabled()       { return on; }
    public void enable()             { on = true; }
    public void disable()            { on = false; }
    public int getVolume()           { return volume; }
    public void setVolume(int p)     { volume = Math.max(0, Math.min(100, p)); }
    public void printStatus() {
        System.out.println("  " + getClass().getSimpleName() + ": " + (on ? "BẬT" : "TẮT") + ", âm lượng " + volume + "%");
    }
}
class Tv extends BaseDevice { }
class Radio extends BaseDevice { }

// ===== Abstraction: phía "điều khiển", giữ tham chiếu tới Implementor (cây cầu) =====
class RemoteControl {
    protected final Device device;
    RemoteControl(Device device) { this.device = device; }

    void togglePower() {
        if (device.isEnabled()) device.disable(); else device.enable();
        System.out.println("Nút nguồn -> " + (device.isEnabled() ? "bật" : "tắt"));
    }
    void volumeUp()   { device.setVolume(device.getVolume() + 10); System.out.println("Tăng âm lượng"); }
    void volumeDown() { device.setVolume(device.getVolume() - 10); System.out.println("Giảm âm lượng"); }
}

// ===== Refined Abstraction: mở rộng phía điều khiển mà không đụng tới thiết bị =====
class AdvancedRemote extends RemoteControl {
    AdvancedRemote(Device device) { super(device); }
    void mute() { device.setVolume(0); System.out.println("Tắt tiếng (mute)"); }
}

// Composite – C++17
#include <iostream>
#include <memory>
#include <string>
#include <vector>

// ===== Component =====
class FileSystemItem {
public:
    virtual ~FileSystemItem() = default;
    virtual std::string getName() const = 0;
    virtual int getSize() const = 0;                       // KB
    virtual void print(const std::string& indent) const = 0;
};

// ===== Leaf =====
class FileItem : public FileSystemItem {
public:
    FileItem(std::string name, int size) : name_(std::move(name)), size_(size) {}
    std::string getName() const override { return name_; }
    int getSize() const override { return size_; }
    void print(const std::string& indent) const override {
        std::cout << indent << "📄 " << name_ << " (" << size_ << " KB)\n";
    }
private:
    std::string name_;
    int size_;
};

// ===== Composite – SỞ HỮU các con qua unique_ptr (huỷ cha sẽ tự huỷ cả cây) =====
class Folder : public FileSystemItem {
public:
    explicit Folder(std::string name) : name_(std::move(name)) {}

    // Trả về con trỏ thô (không sở hữu) để tiện thêm tiếp vào thư mục con
    template <typename T, typename... Args>
    T* add(Args&&... args) {
        auto child = std::make_unique<T>(std::forward<Args>(args)...);
        T* raw = child.get();
        children_.push_back(std::move(child));
        return raw;
    }

    std::string getName() const override { return name_; }

    int getSize() const override {                         // đệ quy
        int total = 0;
        for (const auto& c : children_) total += c->getSize();
        return total;
    }

    void print(const std::string& indent) const override {
        std::cout << indent << "📁 " << name_ << "/ (" << getSize() << " KB)\n";
        for (const auto& c : children_) c->print(indent + "   ");
    }
private:
    std::string name_;
    std::vector<std::unique_ptr<FileSystemItem>> children_;
};

int main() {
    Folder root("du-an-robot");
    Folder* src = root.add<Folder>("src");
    src->add<FileItem>("main.cpp", 12);
    src->add<FileItem>("motor.cpp", 8);
    Folder* docs = root.add<Folder>("docs");
    docs->add<FileItem>("bao-cao.pdf", 2048);
    Folder* images = docs->add<Folder>("images");
    images->add<FileItem>("so-do-mach.png", 512);
    root.add<FileItem>("README.md", 3);

    root.print("");
    std::cout << "Tổng dung lượng dự án: " << root.getSize() << " KB\n";
    std::cout << "Dung lượng thư mục docs: " << docs->getSize() << " KB\n";
}

"""Composite – Python 3."""
from abc import ABC, abstractmethod


class FileSystemItem(ABC):                          # Component
    def __init__(self, name): self.name = name

    @abstractmethod
    def get_size(self) -> int: ...

    @abstractmethod
    def print(self, indent=""): ...


class FileItem(FileSystemItem):                     # Leaf
    def __init__(self, name, size):
        super().__init__(name)
        self.size = size

    def get_size(self): return self.size
    def print(self, indent=""): print(f"{indent}📄 {self.name} ({self.size} KB)")


class Folder(FileSystemItem):                       # Composite
    def __init__(self, name):
        super().__init__(name)
        self.children: list[FileSystemItem] = []

    def add(self, item):
        self.children.append(item)
        return item                                 # trả về item để tiện thêm tiếp

    def get_size(self):
        return sum(c.get_size() for c in self.children)   # đệ quy

    def print(self, indent=""):
        print(f"{indent}📁 {self.name}/ ({self.get_size()} KB)")
        for c in self.children:
            c.print(indent + "   ")


if __name__ == "__main__":
    root = Folder("du-an-robot")
    src = root.add(Folder("src"))
    src.add(FileItem("main.cpp", 12))
    src.add(FileItem("motor.cpp", 8))
    docs = root.add(Folder("docs"))
    docs.add(FileItem("bao-cao.pdf", 2048))
    docs.add(Folder("images")).add(FileItem("so-do-mach.png", 512))
    root.add(FileItem("README.md", 3))

    root.print()
    print("Tổng dung lượng dự án:", root.get_size(), "KB")
    print("Dung lượng thư mục docs:", docs.get_size(), "KB")

import java.util.ArrayList;
import java.util.List;

public class CompositeDemo {
    public static void main(String[] args) {
        Folder root = new Folder("du-an-robot");
        Folder src = new Folder("src");
        src.add(new FileItem("main.cpp", 12));
        src.add(new FileItem("motor.cpp", 8));
        Folder docs = new Folder("docs");
        docs.add(new FileItem("bao-cao.pdf", 2048));
        Folder images = new Folder("images");
        images.add(new FileItem("so-do-mach.png", 512));
        docs.add(images);

        root.add(src);
        root.add(docs);
        root.add(new FileItem("README.md", 3));

        // Client gọi CÙNG một phương thức cho file đơn lẻ lẫn cả cây thư mục
        root.print("");
        System.out.println("Tổng dung lượng dự án: " + root.getSize() + " KB");
        System.out.println("Dung lượng thư mục docs: " + docs.getSize() + " KB");
    }
}

/** Component – giao diện chung cho lá (Leaf) và nhánh (Composite). */
interface FileSystemItem {
    String getName();
    int getSize();                 // KB
    void print(String indent);
}

/** Leaf – phần tử không chứa phần tử con. */
class FileItem implements FileSystemItem {
    private final String name;
    private final int size;
    FileItem(String name, int size) { this.name = name; this.size = size; }
    public String getName() { return name; }
    public int getSize()    { return size; }
    public void print(String indent) { System.out.println(indent + "📄 " + name + " (" + size + " KB)"); }
}

/** Composite – chứa danh sách Component con (có thể là Leaf hoặc Composite khác). */
class Folder implements FileSystemItem {
    private final String name;
    private final List<FileSystemItem> children = new ArrayList<>();
    Folder(String name) { this.name = name; }

    void add(FileSystemItem item)    { children.add(item); }
    void remove(FileSystemItem item) { children.remove(item); }

    public String getName() { return name; }

    /** Đệ quy: kích thước thư mục = tổng kích thước các con. */
    public int getSize() {
        int total = 0;
        for (FileSystemItem c : children) total += c.getSize();
        return total;
    }

    public void print(String indent) {
        System.out.println(indent + "📁 " + name + "/ (" + getSize() + " KB)");
        for (FileSystemItem c : children) c.print(indent + "   ");
    }
}

// Decorator – C++17
#include <cstdio>
#include <memory>
#include <string>

// ===== Component =====
class Drink {
public:
    virtual ~Drink() = default;
    virtual std::string getDescription() const = 0;
    virtual int cost() const = 0;
};

// ===== Concrete Components =====
class MilkTea : public Drink {
public:
    std::string getDescription() const override { return "Trà sữa"; }
    int cost() const override { return 25000; }
};
class GreenTea : public Drink {
public:
    std::string getDescription() const override { return "Trà xanh"; }
    int cost() const override { return 20000; }
};

// ===== Base Decorator: LÀ một Drink và CÓ một Drink =====
class ToppingDecorator : public Drink {
public:
    explicit ToppingDecorator(std::unique_ptr<Drink> inner) : inner_(std::move(inner)) {}
    std::string getDescription() const override { return inner_->getDescription(); }
    int cost() const override { return inner_->cost(); }
protected:
    std::unique_ptr<Drink> inner_;                   // decorator sở hữu đối tượng được bọc
};

// ===== Concrete Decorators =====
class Pearl : public ToppingDecorator {
public:
    using ToppingDecorator::ToppingDecorator;
    std::string getDescription() const override { return inner_->getDescription() + " + trân châu"; }
    int cost() const override { return inner_->cost() + 5000; }
};
class CheeseFoam : public ToppingDecorator {
public:
    using ToppingDecorator::ToppingDecorator;
    std::string getDescription() const override { return inner_->getDescription() + " + kem cheese"; }
    int cost() const override { return inner_->cost() + 10000; }
};
class Pudding : public ToppingDecorator {
public:
    using ToppingDecorator::ToppingDecorator;
    std::string getDescription() const override { return inner_->getDescription() + " + pudding"; }
    int cost() const override { return inner_->cost() + 7000; }
};

void print(const Drink& d) { std::printf("%7d đ  %s\n", d.cost(), d.getDescription().c_str()); }

int main() {
    using std::make_unique;
    auto order1 = make_unique<MilkTea>();
    print(*order1);

    std::unique_ptr<Drink> order2 = make_unique<Pearl>(make_unique<CheeseFoam>(make_unique<MilkTea>()));
    print(*order2);

    std::unique_ptr<Drink> order3 =
        make_unique<Pearl>(make_unique<Pearl>(make_unique<Pudding>(make_unique<GreenTea>())));
    print(*order3);
}

"""Decorator (mẫu thiết kế) – Python 3.
Lưu ý: cú pháp @decorator của Python là một khái niệm LIÊN QUAN nhưng khác:
nó bọc HÀM lúc định nghĩa; còn mẫu Decorator bọc ĐỐI TƯỢNG lúc chạy. Cuối file có ví dụ cả hai."""
from abc import ABC, abstractmethod
import functools


class Drink(ABC):                                   # Component
    @abstractmethod
    def get_description(self) -> str: ...

    @abstractmethod
    def cost(self) -> int: ...


class MilkTea(Drink):
    def get_description(self): return "Trà sữa"
    def cost(self): return 25_000


class GreenTea(Drink):
    def get_description(self): return "Trà xanh"
    def cost(self): return 20_000


class ToppingDecorator(Drink):                      # Base Decorator
    def __init__(self, inner: Drink): self.inner = inner
    def get_description(self): return self.inner.get_description()
    def cost(self): return self.inner.cost()


class Pearl(ToppingDecorator):
    def get_description(self): return self.inner.get_description() + " + trân châu"
    def cost(self): return self.inner.cost() + 5_000


class CheeseFoam(ToppingDecorator):
    def get_description(self): return self.inner.get_description() + " + kem cheese"
    def cost(self): return self.inner.cost() + 10_000


class Pudding(ToppingDecorator):
    def get_description(self): return self.inner.get_description() + " + pudding"
    def cost(self): return self.inner.cost() + 7_000


# ----- Cú pháp @decorator của Python: bọc một HÀM -----
def log_call(func):
    @functools.wraps(func)
    def wrapper(*args):
        result = func(*args)
        print(f"   (log) {func.__name__}{args} = {result}")
        return result
    return wrapper


@log_call
def read_sensor(pin):
    return 512                                      # giả lập analogRead


if __name__ == "__main__":
    for d in (MilkTea(),
              Pearl(CheeseFoam(MilkTea())),
              Pearl(Pearl(Pudding(GreenTea())))):
        print(f"{d.cost():>7,} đ  {d.get_description()}")
    read_sensor(34)

public class DecoratorDemo {
    public static void main(String[] args) {
        // Gọi một ly trà sữa cơ bản
        Drink order1 = new MilkTea();
        print(order1);

        // "Bọc" thêm topping – mỗi lớp bọc thêm hành vi + giá tiền
        Drink order2 = new Pearl(new CheeseFoam(new MilkTea()));
        print(order2);

        // Bọc nhiều lần cùng một loại topping cũng được
        Drink order3 = new Pearl(new Pearl(new Pudding(new GreenTea())));
        print(order3);
    }

    static void print(Drink d) {
        System.out.printf("%-55s %,7d đ%n", d.getDescription(), d.cost());
    }
}

/** Component */
interface Drink {
    String getDescription();
    int cost();
}

/** Concrete Components – đồ uống gốc */
class MilkTea implements Drink {
    public String getDescription() { return "Trà sữa"; }
    public int cost()              { return 25_000; }
}
class GreenTea implements Drink {
    public String getDescription() { return "Trà xanh"; }
    public int cost()              { return 20_000; }
}

/** Base Decorator – cùng kiểu Drink VÀ chứa một Drink bên trong */
abstract class ToppingDecorator implements Drink {
    protected final Drink inner;
    ToppingDecorator(Drink inner) { this.inner = inner; }
    public String getDescription() { return inner.getDescription(); }
    public int cost()              { return inner.cost(); }
}

/** Concrete Decorators – thêm hành vi TRƯỚC/SAU khi uỷ quyền cho inner */
class Pearl extends ToppingDecorator {
    Pearl(Drink inner) { super(inner); }
    public String getDescription() { return inner.getDescription() + " + trân châu"; }
    public int cost()              { return inner.cost() + 5_000; }
}
class CheeseFoam extends ToppingDecorator {
    CheeseFoam(Drink inner) { super(inner); }
    public String getDescription() { return inner.getDescription() + " + kem cheese"; }
    public int cost()              { return inner.cost() + 10_000; }
}
class Pudding extends ToppingDecorator {
    Pudding(Drink inner) { super(inner); }
    public String getDescription() { return inner.getDescription() + " + pudding"; }
    public int cost()              { return inner.cost() + 7_000; }
}