উদাহরণ ভিত্তিক বাস্তবায়ন

ডিজাইন প্যাটার্ন (Design Patterns) হল সফটওয়্যার ডিজাইন সমস্যা সমাধানে পরীক্ষিত এবং প্রমাণিত সমাধান। এগুলি পুনঃব্যবহারযোগ্য কোডের জন্য গাইডলাইন প্রদান করে এবং প্রোগ্রামিংয়ের কাঠামোকে সহজ করে। এখানে আমরা Creational, Structural, এবং Behavioral ডিজাইন প্যাটার্নের বাস্তবায়ন উদাহরণ দেখব, যা জাভাতে ব্যবহৃত হয়।

1. Singleton Pattern (Creational)

Singleton Pattern এমন একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা নিশ্চিত করে যে একটি ক্লাসের একটি মাত্র ইনস্ট্যান্স তৈরি হবে এবং সেই ইনস্ট্যান্সটি বিশ্বের যে কোনো জায়গা থেকে অ্যাক্সেস করা যাবে।

উদাহরণ: Singleton Pattern

public class Singleton {
    // Private static instance
    private static Singleton instance;

    // Private constructor to prevent instantiation
    private Singleton() {}

    // Public method to get the instance of Singleton
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // Sample method to demonstrate functionality
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }

    public static void main(String[] args) {
        // Get the Singleton instance and call its method
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();
    }
}

আউটপুট:

Hello from Singleton!

এখানে, Singleton ক্লাসের একটি ইনস্ট্যান্স শুধুমাত্র একটি বার তৈরি হবে এবং তারপর সব জায়গা থেকে একসাথে অ্যাক্সেস করা যাবে।

2. Factory Method Pattern (Creational)

Factory Method Pattern হল একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা অবজেক্ট তৈরির দায়িত্ব সাবক্লাসের উপর ছেড়ে দেয়। এটি এক বা একাধিক কনক্রিট ক্লাস থেকে অবজেক্ট তৈরি করতে ব্যবহৃত হয়, যেটি ক্লাসের জন্য ডাইনামিক অবজেক্ট তৈরি করতে সহায়ক।

উদাহরণ: Factory Method Pattern

// Product interface
interface Animal {
    void speak();
}

// Concrete product 1
class Dog implements Animal {
    public void speak() {
        System.out.println("Woof!");
    }
}

// Concrete product 2
class Cat implements Animal {
    public void speak() {
        System.out.println("Meow!");
    }
}

// Creator class
abstract class AnimalFactory {
    public abstract Animal createAnimal();
}

// Concrete creator 1
class DogFactory extends AnimalFactory {
    public Animal createAnimal() {
        return new Dog();
    }
}

// Concrete creator 2
class CatFactory extends AnimalFactory {
    public Animal createAnimal() {
        return new Cat();
    }
}

public class FactoryMethodExample {
    public static void main(String[] args) {
        // Create Dog
        AnimalFactory dogFactory = new DogFactory();
        Animal dog = dogFactory.createAnimal();
        dog.speak();  // Output: Woof!

        // Create Cat
        AnimalFactory catFactory = new CatFactory();
        Animal cat = catFactory.createAnimal();
        cat.speak();  // Output: Meow!
    }
}

আউটপুট:

Woof!
Meow!

এখানে, AnimalFactory ক্লাসটি অবজেক্ট তৈরি করার জন্য একটি ফ্যাক্টরি পদ্ধতি সরবরাহ করে, এবং DogFactory এবং CatFactory এটির কনক্রিট ইমপ্লিমেন্টেশন। এটি অবজেক্ট তৈরির পদ্ধতিতে নমনীয়তা প্রদান করে।

3. Adapter Pattern (Structural)

Adapter Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা একে অপরের সাথে কাজ করতে অক্ষম বিভিন্ন ইন্টারফেসগুলিকে একত্রিত করে। এটি বিদ্যমান কোডের পরিবর্তন ছাড়াই একটি নতুন ইন্টারফেস ব্যবহার করার সুযোগ দেয়।

উদাহরণ: Adapter Pattern

// Old Interface
interface OldSystem {
    void oldMethod();
}

// Old System Implementation
class OldSystemImpl implements OldSystem {
    public void oldMethod() {
        System.out.println("Old system method.");
    }
}

// New Interface
interface NewSystem {
    void newMethod();
}

// Adapter Class to adapt OldSystem to NewSystem
class Adapter implements NewSystem {
    private OldSystem oldSystem;

    public Adapter(OldSystem oldSystem) {
        this.oldSystem = oldSystem;
    }

    public void newMethod() {
        oldSystem.oldMethod();
    }
}

public class AdapterPatternExample {
    public static void main(String[] args) {
        OldSystem oldSystem = new OldSystemImpl();
        NewSystem newSystem = new Adapter(oldSystem);
        newSystem.newMethod();  // Output: Old system method.
    }
}

আউটপুট:

Old system method.

এখানে, Adapter ক্লাসটি OldSystem এবং NewSystem এর মধ্যে প্যাচ হিসেবে কাজ করে, যা পুরানো সিস্টেমের ফাংশনালিটি নতুন সিস্টেমে অ্যাডপ্ট করে।

4. Strategy Pattern (Behavioral)

Strategy Pattern একটি বিহেভিওরাল ডিজাইন প্যাটার্ন যা একাধিক এলগোরিদম সংজ্ঞায়িত করে এবং একটি কনটেক্সটে এলগোরিদমটির ব্যবহার সিলেক্ট করার সুযোগ দেয়। এটি এলগোরিদমের পরিবর্তনশীল আচরণ তৈরি করতে ব্যবহৃত হয়।

উদাহরণ: Strategy Pattern

// Strategy interface
interface PaymentStrategy {
    void pay(int amount);
}

// Concrete Strategy 1
class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

// Concrete Strategy 2
class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

// Context Class
class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public ShoppingCart(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

public class StrategyPatternExample {
    public static void main(String[] args) {
        // Use CreditCardPayment strategy
        PaymentStrategy creditCardPayment = new CreditCardPayment();
        ShoppingCart cart1 = new ShoppingCart(creditCardPayment);
        cart1.checkout(100);  // Output: Paid 100 using Credit Card.

        // Use PayPalPayment strategy
        PaymentStrategy payPalPayment = new PayPalPayment();
        ShoppingCart cart2 = new ShoppingCart(payPalPayment);
        cart2.checkout(200);  // Output: Paid 200 using PayPal.
    }
}

আউটপুট:

Paid 100 using Credit Card.
Paid 200 using PayPal.

এখানে, ShoppingCart কন্টেক্সটে বিভিন্ন পেমেন্ট স্ট্র্যাটেজি প্রয়োগ করা হয়েছে, যেমন CreditCardPayment এবং PayPalPayment।

5. Observer Pattern (Behavioral)

Observer Pattern একটি বিহেভিওরাল ডিজাইন প্যাটার্ন যা অবজেক্টের মধ্যে একে অপরের মধ্যে নির্ভরতা তৈরি করে, যাতে এক অবজেক্টে পরিবর্তন ঘটলে অন্য অবজেক্টগুলি সঠিকভাবে আপডেট হয়। এটি সাধারণত ইভেন্ট হ্যান্ডলিং বা পাবলিশ-সাবস্ক্রাইব মডেল ব্যবহৃত হয়।

উদাহরণ: Observer Pattern

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

// Subject class
class WeatherStation {
    private List<Observer> observers = new ArrayList<>();
    private int temperature;

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void setTemperature(int temperature) {
        this.temperature = temperature;
        notifyObservers();
    }

    public int getTemperature() {
        return temperature;
    }

    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

// Observer interface
interface Observer {
    void update();
}

// Concrete Observer 1
class PhoneDisplay implements Observer {
    private WeatherStation weatherStation;

    public PhoneDisplay(WeatherStation weatherStation) {
        this.weatherStation = weatherStation;
        this.weatherStation.addObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Phone Display: Temperature is " + weatherStation.getTemperature() + "°C");
    }
}

// Concrete Observer 2
class EmailNotification implements Observer {
    private WeatherStation weatherStation;

    public EmailNotification(WeatherStation weatherStation) {
        this.weatherStation = weatherStation;
        this.weatherStation.addObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Email Notification: Temperature is " + weatherStation.getTemperature() + "°C");
    }
}

public class ObserverPatternExample {
    public static void main(String[] args) {
        WeatherStation weatherStation = new WeatherStation();
        
        PhoneDisplay phoneDisplay = new PhoneDisplay(weatherStation);
        EmailNotification emailNotification = new EmailNotification(weatherStation);
        
        weatherStation.setTemperature(25);  // Output: Phone Display: Temperature is 25°C, Email Notification: Temperature is 25°C
        weatherStation.setTemperature(30);  // Output: Phone Display: Temperature is 30°C, Email Notification: Temperature is 30°C
    }
}

আউটপুট:

Phone Display: Temperature is 25°C
Email Notification: Temperature is 25°C
Phone Display: Temperature is 30°C
Email Notification: Temperature is 30°C

এখানে, WeatherStation অবজেক্টের তাপমাত্রা পরিবর্তন হলে PhoneDisplay এবং EmailNotification অবজেক্টগুলি তা আপডেট করতে সক্ষম হয়েছে।

সারাংশ

Design Patterns বিভিন্ন সফটওয়্যার ডিজাইন সমস্যা সমাধানে কার্যকরী এবং পুনঃব্যবহারযোগ্য সমাধান প্রদান করে। এখানে Creational, Structural, এবং Behavioral ডিজাইন প্যাটার্নের কয়েকটি বাস্তবায়ন উদাহরণ আলোচনা করা হয়েছে, যেমন Singleton, Factory Method, Adapter, Strategy, এবং Observer প্যাটার্ন। এই ডিজাইন প্যাটার্নগুলো আপনাকে আরও নমনীয়, রক্ষণাবেক্ষণযোগ্য এবং স্কেলেবল সফটওয়্যার তৈরি করতে সাহায্য করে।