Creational Design Patterns

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

ডিজাইন প্যাটার্ন প্রধানত তিনটি ক্যাটাগরিতে বিভক্ত:

1. Creational Patterns: যে প্যাটার্নগুলি অবজেক্ট তৈরির প্রক্রিয়াকে সহজ এবং নমনীয় করে।
2. Structural Patterns: যে প্যাটার্নগুলি অবজেক্টের কাঠামো বা সংযুক্তি প্রক্রিয়া সহজ করে।
3. Behavioral Patterns: যে প্যাটার্নগুলি অবজেক্টের আচরণ বা যোগাযোগের ধরণ পরিচালনা করে।

এখানে Creational Design Patterns নিয়ে আলোচনা করা হবে। এই প্যাটার্নগুলি অবজেক্ট তৈরির প্রক্রিয়াকে নিয়ন্ত্রণ করে এবং সিস্টেমের বিভিন্ন উপাদানগুলির মধ্যে অবজেক্ট ক্রিয়েশন বা ইনস্ট্যান্সিয়েশন সম্পর্কিত সমস্যা সমাধান করে।

Creational Design Patterns এর উদাহরণ:

1. Singleton Pattern
2. Factory Method Pattern
3. Abstract Factory Pattern
4. Builder Pattern
5. Prototype Pattern

1. Singleton Pattern

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

ব্যবহার:

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

উদাহরণ: Singleton Pattern

public class Singleton {
    // Create a static instance of the class
    private static Singleton instance;

    // Private constructor prevents instantiation from other classes
    private Singleton() {}

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

    // Method for demonstration
    public void showMessage() {
        System.out.println("Hello, this is a Singleton pattern!");
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();
    }
}

আউটপুট:

Hello, this is a Singleton pattern!

এখানে, Singleton ক্লাসে একটি স্ট্যাটিক ইনস্ট্যান্স রয়েছে যা প্রথমবার ইনস্ট্যান্স হওয়া পর্যন্ত তৈরি হবে এবং পরবর্তী সময় একই ইনস্ট্যান্স ব্যবহার হবে।

2. Factory Method Pattern

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

উদাহরণ: Factory Method Pattern

abstract class Animal {
    public abstract void makeSound();
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }
}

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

class DogFactory extends AnimalFactory {
    public Animal createAnimal() {
        return new Dog();
    }
}

class CatFactory extends AnimalFactory {
    public Animal createAnimal() {
        return new Cat();
    }
}

public class FactoryMethodExample {
    public static void main(String[] args) {
        AnimalFactory dogFactory = new DogFactory();
        Animal dog = dogFactory.createAnimal();
        dog.makeSound();  // Output: Woof!
        
        AnimalFactory catFactory = new CatFactory();
        Animal cat = catFactory.createAnimal();
        cat.makeSound();  // Output: Meow!
    }
}

আউটপুট:

Woof!
Meow!

এখানে, DogFactory এবং CatFactory AnimalFactory এর উপ- ক্লাস এবং createAnimal() মেথডের মাধ্যমে তারা পৃথক Animal অবজেক্ট তৈরি করে।

3. Abstract Factory Pattern

Abstract Factory Pattern হল এমন একটি ডিজাইন প্যাটার্ন যা সম্পর্কিত অবজেক্ট তৈরি করার জন্য একাধিক ফ্যাক্টরি মেথডের ব্যবহার করে। এটি ফ্যাক্টরি অবজেক্টের একটি সমষ্টি তৈরি করে এবং ক্লায়েন্ট কোডকে নির্দিষ্ট কনক্রিট ক্লাসের উপর নির্ভর না করে বিভিন্ন উপাদান তৈরি করার সুযোগ দেয়।

উদাহরণ: Abstract Factory Pattern

// Abstract products
interface Chair {
    void sitOn();
}

interface Table {
    void placeOn();
}

// Concrete products
class VictorianChair implements Chair {
    public void sitOn() {
        System.out.println("Sitting on a Victorian Chair");
    }
}

class ModernChair implements Chair {
    public void sitOn() {
        System.out.println("Sitting on a Modern Chair");
    }
}

class VictorianTable implements Table {
    public void placeOn() {
        System.out.println("Placing things on a Victorian Table");
    }
}

class ModernTable implements Table {
    public void placeOn() {
        System.out.println("Placing things on a Modern Table");
    }
}

// Abstract Factory
interface FurnitureFactory {
    Chair createChair();
    Table createTable();
}

// Concrete Factories
class VictorianFurnitureFactory implements FurnitureFactory {
    public Chair createChair() {
        return new VictorianChair();
    }
    
    public Table createTable() {
        return new VictorianTable();
    }
}

class ModernFurnitureFactory implements FurnitureFactory {
    public Chair createChair() {
        return new ModernChair();
    }
    
    public Table createTable() {
        return new ModernTable();
    }
}

public class AbstractFactoryExample {
    public static void main(String[] args) {
        FurnitureFactory factory = new VictorianFurnitureFactory();
        Chair chair = factory.createChair();
        Table table = factory.createTable();
        
        chair.sitOn();
        table.placeOn();
    }
}

আউটপুট:

Sitting on a Victorian Chair
Placing things on a Victorian Table

এখানে, VictorianFurnitureFactory এবং ModernFurnitureFactory দুটি আলাদা ফ্যাক্টরি যা সম্পর্কিত ফার্নিচার (চেয়ার এবং টেবিল) তৈরি করে।

4. Builder Pattern

Builder Pattern হল একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা জটিল অবজেক্ট নির্মাণ প্রক্রিয়া বিভক্ত করে এবং ধাপে ধাপে অবজেক্ট তৈরি করতে সহায়তা করে। এটি বিশেষত তখন ব্যবহৃত হয় যখন একাধিক বিকল্প বা স্টেপে ইনপুট থাকতে পারে।

উদাহরণ: Builder Pattern

class Car {
    private String make;
    private String model;
    private int year;

    public void setMake(String make) {
        this.make = make;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public void setYear(int year) {
        this.year = year;
    }

    @Override
    public String toString() {
        return "Car [make=" + make + ", model=" + model + ", year=" + year + "]";
    }
}

class CarBuilder {
    private Car car;

    public CarBuilder() {
        this.car = new Car();
    }

    public CarBuilder buildMake(String make) {
        car.setMake(make);
        return this;
    }

    public CarBuilder buildModel(String model) {
        car.setModel(model);
        return this;
    }

    public CarBuilder buildYear(int year) {
        car.setYear(year);
        return this;
    }

    public Car build() {
        return car;
    }
}

public class BuilderPatternExample {
    public static void main(String[] args) {
        Car car = new CarBuilder().buildMake("Tesla").buildModel("Model 3").buildYear(2021).build();
        System.out.println(car);
    }
}

আউটপুট:

Car [make=Tesla, model=Model 3, year=2021]

এখানে, CarBuilder ক্লাসের মাধ্যমে আমরা ধাপে ধাপে একটি Car অবজেক্ট তৈরি করছি।

5. Prototype Pattern

Prototype Pattern একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা অবজেক্টের একটি ক্লোন তৈরি করে, যাতে সম্পূর্ণ নতুন অবজেক্ট তৈরি না করে পূর্বের অবজেক্টের কপি ব্যবহার করা যায়। এটি যখন একই ধরনের অবজেক্ট অনেকবার তৈরি করা প্রয়োজন তখন উপকারী।

উদাহরণ: Prototype Pattern

abstract class Prototype {
    public abstract Prototype clone();
}

class ConcretePrototype extends Prototype {
    private String data;

    public ConcretePrototype(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

    @Override
    public Prototype clone() {
        return new ConcretePrototype(this.data);
    }
}

public class PrototypePatternExample {
    public static void main(String[] args) {
        ConcretePrototype prototype = new ConcretePrototype("Prototype data");
        ConcretePrototype clonedPrototype = (ConcretePrototype) prototype.clone();
        
        System.out.println("Original: " + prototype.getData());
        System.out.println("Cloned: " + clonedPrototype.getData());
    }
}

আউটপুট:

Original: Prototype data
Cloned: Prototype data

এখানে, ConcretePrototype ক্লাসটি clone() মেথড ব্যবহার করে অবজেক্টের কপি তৈরি করেছে।

সারাংশ

Creational Design Patterns গুলি মূলত অবজেক্ট তৈরি করার পদ্ধতিকে নিয়ন্ত্রণ করতে ব্যবহৃত হয়। এই প্যাটার্নগুলির মধ্যে Singleton, Factory Method, Abstract Factory, Builder, এবং Prototype প্যাটার্ন অন্তর্ভুক্ত রয়েছে। এগুলি বিভিন্ন পরিস্থিতিতে কার্যকরভাবে ব্যব

হৃত হয়, যেমন একক ইনস্ট্যান্স নিয়ন্ত্রণ, অবজেক্ট তৈরি প্রক্রিয়ার নমনীয়তা, জটিল অবজেক্ট নির্মাণ এবং অবজেক্টের ক্লোন তৈরি করা।

Singleton Pattern হল একটি Creational Design Pattern যা নিশ্চিত করে যে একটি ক্লাসের শুধুমাত্র একটিমাত্র ইনস্ট্যান্স (instance) তৈরি হয় এবং সেই ইনস্ট্যান্সটি পুরো সফটওয়্যার সিস্টেমে পুনরায় ব্যবহার করা যায়। এর মূল উদ্দেশ্য হলো ক্লাসের একটিমাত্র অবজেক্ট তৈরি করা এবং সেই অবজেক্টটি ব্যবহারের জন্য গ্লোবাল অ্যাক্সেস পেতে সিস্টেমের মধ্যে ছড়িয়ে দেয়া।

Singleton Pattern এর প্রয়োগ ক্ষেত্র:

• যখন একসাথে কাজ করা বিভিন্ন কম্পোনেন্টের জন্য শুধুমাত্র একটি অবজেক্টের প্রয়োজন হয়।
• যেমন: লগিং, কনফিগারেশন সেটিংস, ডাটাবেস কানেকশন পুল, থ্রেড পুল, বা কোনো অন্যান্য গ্লোবাল রিসোর্স।

1. Singleton Pattern এর বৈশিষ্ট্য

• Single Instance: সিঙ্গেলটন প্যাটার্ন নিশ্চিত করে যে ক্লাসটির শুধু একটি ইনস্ট্যান্স থাকবে।
• Global Access: এই একক ইনস্ট্যান্সটি পুরো অ্যাপ্লিকেশনের মধ্যে গ্লোবালি অ্যাক্সেস করা যাবে।
• Lazy Initialization: ইনস্ট্যান্সটি কেবল তখনই তৈরি হবে, যখন সেটি প্রয়োজন হবে (এটা অপ্টিমাইজেশন হিসেবে কাজ করতে পারে)।

2. Singleton Pattern বাস্তবায়ন

2.1 Eager Initialization (প্রাথমিক ইনস্ট্যান্স তৈরি)

এই পদ্ধতিতে ইনস্ট্যান্স ক্লাস লোড হওয়ার সময়ই তৈরি হয়। এই পদ্ধতি সহজ, কিন্তু যদি ক্লাসটি কখনোই ব্যবহৃত না হয়, তাহলে এটি কিছুটা অপ্রয়োজনীয় মেমরি ব্যবহার করবে।

উদাহরণ:

public class Singleton {
    // ক্লাস লোডের সময় ইনস্ট্যান্স তৈরি
    private static final Singleton instance = new Singleton();

    // কনস্ট্রাক্টর প্রাইভেট, বাইরের ক্লাস থেকে ইনস্ট্যান্স তৈরি করা যাবে না
    private Singleton() {}

    // গেটার মেথড - ইনস্ট্যান্সটি রিটার্ন করবে
    public static Singleton getInstance() {
        return instance;
    }

    // অন্যান্য মেথড
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}

class Main {
    public static void main(String[] args) {
        // একমাত্র ইনস্ট্যান্স অ্যাক্সেস করা
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();  // আউটপুট: Hello from Singleton!
    }
}

ব্যাখ্যা:

• এখানে Singleton ক্লাসটি instance নামে একটি স্ট্যাটিক ভ্যারিয়েবল ধারণ করে, যা ক্লাস লোড হওয়ার সাথে সাথে তৈরি হয়।
• getInstance() মেথডটি সেই ইনস্ট্যান্স রিটার্ন করে এবং showMessage() একটি সাধারণ মেথড যা ইনস্ট্যান্সের মাধ্যমে কল করা হয়।

2.2 Lazy Initialization (আলসা ইনস্ট্যান্স তৈরি)

এটি একটি উন্নত পদ্ধতি যেখানে ইনস্ট্যান্সটি কেবল তখনই তৈরি হয় যখন প্রথমবার getInstance() মেথডটি কল করা হয়। এই পদ্ধতিতে ডিফল্টভাবে ইনস্ট্যান্স তৈরি করা হয় না, বরং ক্লাস ব্যবহৃত হওয়ার সময় তা তৈরি হয়, যার ফলে মেমরি অপটিমাইজেশন হয়।

উদাহরণ:

public class Singleton {
    // সিঙ্গেলটন ইনস্ট্যান্স তৈরি করতে private static ভ্যারিয়েবল
    private static Singleton instance;

    // কনস্ট্রাক্টর প্রাইভেট, বাইরের ক্লাস থেকে ইনস্ট্যান্স তৈরি করা যাবে না
    private Singleton() {}

    // গেটার মেথড - ইনস্ট্যান্স তৈরি করবে যদি এটি আগে তৈরি না হয়ে থাকে
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();  // প্রথমবার ইনস্ট্যান্স তৈরি
        }
        return instance;
    }

    // অন্যান্য মেথড
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}

class Main {
    public static void main(String[] args) {
        // একমাত্র ইনস্ট্যান্স অ্যাক্সেস করা
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();  // আউটপুট: Hello from Singleton!
    }
}

ব্যাখ্যা:

• Lazy Initialization ব্যবহার করা হয়েছে, যেখানে ইনস্ট্যান্স কেবল তখনই তৈরি হয়, যখন প্রথমবার getInstance() মেথডটি কল করা হয়। এর ফলে মেমরি অপটিমাইজেশন করা যায়।

2.3 Thread-Safe Singleton (Thread-Safe সিঙ্গেলটন)

যখন মাল্টিথ্রেডেড পরিবেশে সিঙ্গেলটন ব্যবহার করা হয়, তখন সিঙ্গেলটন ক্লাসের ইনস্ট্যান্স তৈরির সময় Thread Safety নিশ্চিত করা জরুরি। একাধিক থ্রেড যদি একই সময়ে ইনস্ট্যান্স তৈরি করার চেষ্টা করে, তাহলে এটি একটি Concurrency Issue সৃষ্টি করতে পারে।

এটি সমাধান করার জন্য Double-Checked Locking প্যাটার্ন ব্যবহার করা হয়, যেখানে প্রথমে null চেক করা হয় এবং পরে সিঙ্ক্রোনাইজেশন করা হয়।

উদাহরণ:

public class Singleton {
    // ইনস্ট্যান্স স্ট্যাটিকভাবে তৈরি হবে না যতক্ষণ না প্রয়োজন
    private static volatile Singleton instance;

    // কনস্ট্রাক্টর প্রাইভেট
    private Singleton() {}

    // Thread-Safe getInstance() মেথড
    public static Singleton getInstance() {
        if (instance == null) { // প্রথম চেক
            synchronized (Singleton.class) { // সিঙ্ক্রোনাইজড ব্লক
                if (instance == null) { // দ্বিতীয় চেক
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // অন্যান্য মেথড
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}

class Main {
    public static void main(String[] args) {
        // একমাত্র ইনস্ট্যান্স অ্যাক্সেস করা
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();  // আউটপুট: Hello from Singleton!
    }
}

ব্যাখ্যা:

• এখানে, Double-Checked Locking ব্যবহার করা হয়েছে, যেখানে প্রথমে instance == null চেক করা হয় এবং পরবর্তীতে সিঙ্ক্রোনাইজড ব্লক ব্যবহার করা হয় যাতে একাধিক থ্রেড একসাথে ইনস্ট্যান্স তৈরি করতে না পারে।

3. Advantages of Singleton Pattern

1. Controlled Access: সিঙ্গেলটন প্যাটার্ন নিশ্চিত করে যে একটি ক্লাসের শুধুমাত্র একটি ইনস্ট্যান্স তৈরি হবে এবং সেই ইনস্ট্যান্সটি পুরো সিস্টেমে একযোগভাবে ব্যবহৃত হবে।
2. Global Access Point: সিঙ্গেলটন ক্লাসের ইনস্ট্যান্সটি গ্লোবালি অ্যাক্সেস করা যায়।
3. Lazy Initialization: শুধুমাত্র যখন প্রয়োজন হবে তখনই ইনস্ট্যান্স তৈরি করা হয়, যা মেমরি অপটিমাইজেশন করতে সাহায্য করে।
4. Thread Safety: সঠিকভাবে সিঙ্ক্রোনাইজড করা হলে, এটি মাল্টিথ্রেডেড অ্যাপ্লিকেশনের জন্য সঠিকভাবে কাজ করবে।

4. Disadvantages of Singleton Pattern

1. Global State: সিঙ্গেলটন ক্লাসের ইনস্ট্যান্স গ্লোবাল অ্যাক্সেস পয়েন্ট হিসেবে কাজ করার কারণে এটি গ্লোবাল স্টেট তৈরি করতে পারে, যা প্রোগ্রামের টেস্টিং এবং মেন্টেনেন্সকে জটিল করতে পারে।
2. Difficulty in Unit Testing: সিঙ্গেলটন প্যাটার্ন প্রোগ্রামিং টেস্টিংয়ে সমস্যা সৃষ্টি করতে পারে, কারণ এটি সিঙ্গেল ইনস্ট্যান্স সরবরাহ করে, যা পরীক্ষার সময় পরিবর্তন করা কঠিন হতে পারে।
3. Overuse: সিঙ্গেলটন প্যাটার্নের অতিরিক্ত ব্যবহার, বিশেষত যেখানে একাধিক ইনস্ট্যান্সের প্রয়োজন, অ্যাপ্লিকেশনের ডিজাইনকে জটিল করে তোলে।

Singleton Pattern হল একটি সাধারণ কিন্তু অত্যন্ত কার্যকরী ডিজাইন প্যাটার্ন যা নিশ্চিত করে যে একটি ক্লাসের একমাত্র ইনস্ট্যান্স থাকবে এবং সেটি পুরো সিস্টেমে শেয়ার করা যাবে। এটি ডেটাবেস কানেকশন পুল, লগিং, কনফিগারেশন সেটিংস এবং অনেক ধরনের গ্লোবাল রিসোর্স পরিচালনায় ব্যবহার করা হয়। Java তে সিঙ্গেলটন প্যাটার্ন বাস্তবায়ন করতে হলে Thread Safety, Lazy Initialization এবং Eager Initialization সম্পর্কে ভালোভাবে বুঝতে হবে।

Factory Method Pattern কী?

Factory Method Pattern হল একটি ক্রিয়েটিভ ডিজাইন প্যাটার্ন, যা Creational Design Pattern শ্রেণিভুক্ত। এই প্যাটার্নটি অবজেক্ট তৈরির জন্য একটি ইন্টারফেস সরবরাহ করে, কিন্তু সাবক্লাসকে নির্ধারণ করতে দেয় কোন ক্লাসের ইনস্ট্যান্স তৈরি করা হবে। এটি মূলত সাবক্লাসকে অবজেক্ট তৈরির প্রক্রিয়ায় নিয়ন্ত্রণ দেয়।

Factory Method Pattern-এর উদ্দেশ্য হল অবজেক্ট নির্মাণের সময়টা ক্লায়েন্ট কোড থেকে আড়াল করা, যাতে অবজেক্ট তৈরির প্রক্রিয়া পরিবর্তন বা সম্প্রসারণ করা যায়, কিন্তু ক্লায়েন্ট কোডে কোনো প্রভাব না ফেলে।

Factory Method Pattern এর উপাদান:

1. Product: এটি ইন্টারফেস বা অ্যাবস্ট্রাক্ট ক্লাস যা সৃষ্ট অবজেক্টের সাধারণ বৈশিষ্ট্য প্রকাশ করে।
2. ConcreteProduct: এটি Product ইন্টারফেস বা ক্লাসের কনক্রিট বাস্তবায়ন।
3. Creator: এটি একটি ক্লাস যা ফ্যাক্টরি মেথড ডিফাইন করে এবং সৃষ্ট অবজেক্টের জন্য ইন্টারফেস প্রদান করে।
4. ConcreteCreator: এটি Creator ক্লাসের কনক্রিট বাস্তবায়ন যা ফ্যাক্টরি মেথডে অবজেক্ট তৈরি করে।

Factory Method Pattern এর সুবিধা:

1. Object creation hiding: অবজেক্ট তৈরি করার প্রক্রিয়া ক্লায়েন্ট কোড থেকে আড়াল করা হয়।
2. Extensibility: নতুন ধরনের অবজেক্ট তৈরি করতে সাবক্লাস ব্যবহার করা যায়, তবে ক্লায়েন্ট কোডে কোনো পরিবর্তন না করেই।
3. Loose coupling: ক্লায়েন্ট এবং অবজেক্টের মধ্যে কম নির্ভরশীলতা থাকে, যা কোডের রক্ষণাবেক্ষণ সহজ করে।

Factory Method Pattern উদাহরণ

ধরা যাক, একটি সফটওয়্যার সিস্টেমে বিভিন্ন ধরনের ডকুমেন্ট (যেমন PDFDocument, WordDocument) তৈরি করতে হবে। এখানে একটি সাধারণ Document ইন্টারফেস থাকবে, এবং প্রতিটি ডকুমেন্টের নিজস্ব কনক্রিট ক্লাস থাকবে। এছাড়া, DocumentCreator ইন্টারফেসের মাধ্যমে এই ডকুমেন্ট তৈরি করা হবে।

Step 1: Product Interface (Document)

// Product Interface
public interface Document {
    void create();
}

Step 2: ConcreteProduct (PDFDocument এবং WordDocument)

// ConcreteProduct: PDFDocument
public class PDFDocument implements Document {
    @Override
    public void create() {
        System.out.println("Creating a PDF document");
    }
}

// ConcreteProduct: WordDocument
public class WordDocument implements Document {
    @Override
    public void create() {
        System.out.println("Creating a Word document");
    }
}

Step 3: Creator Interface (DocumentCreator)

// Creator Interface
public interface DocumentCreator {
    Document createDocument();
}

Step 4: ConcreteCreator (PDFDocumentCreator এবং WordDocumentCreator)

// ConcreteCreator: PDFDocumentCreator
public class PDFDocumentCreator implements DocumentCreator {
    @Override
    public Document createDocument() {
        return new PDFDocument();
    }
}

// ConcreteCreator: WordDocumentCreator
public class WordDocumentCreator implements DocumentCreator {
    @Override
    public Document createDocument() {
        return new WordDocument();
    }
}

Step 5: Client Code

public class FactoryMethodPatternExample {
    public static void main(String[] args) {
        DocumentCreator pdfCreator = new PDFDocumentCreator();
        Document pdf = pdfCreator.createDocument();
        pdf.create(); // Output: Creating a PDF document

        DocumentCreator wordCreator = new WordDocumentCreator();
        Document word = wordCreator.createDocument();
        word.create(); // Output: Creating a Word document
    }
}

ব্যাখ্যা:

• Document ইন্টারফেসটি সমস্ত ডকুমেন্টের জন্য একটি সাধারণ কনট্র্যাক্ট প্রদান করে।
• PDFDocument এবং WordDocument হলো কনক্রিট ক্লাস যা Document ইন্টারফেসের বাস্তবায়ন।
• DocumentCreator ইন্টারফেসটি createDocument() মেথড প্রদান করে, যেটি Document অবজেক্ট তৈরি করার জন্য ব্যবহৃত হয়।
• PDFDocumentCreator এবং WordDocumentCreator হল কনক্রিট ক্লাস যা যথাক্রমে PDF এবং Word ডকুমেন্ট তৈরি করে।

এখন, Factory Method প্যাটার্নের মাধ্যমে আপনি নতুন ধরনের ডকুমেন্ট তৈরি করতে পারেন, যেমন ExcelDocumentCreator যোগ করতে পারবেন, এবং ক্লায়েন্ট কোডে কোনো পরিবর্তন করতে হবে না।

4. Factory Method Pattern এর সুবিধা

1. Encapsulation: অবজেক্ট তৈরি করার প্রক্রিয়াকে ক্লায়েন্ট কোড থেকে আড়াল করা যায়, যা ক্লায়েন্টকে শুধুমাত্র ইন্টারফেসের সাথে কাজ করার সুযোগ দেয়।
2. Extensibility: নতুন ধরনের ডকুমেন্ট যোগ করতে হলে শুধুমাত্র নতুন ConcreteCreator ক্লাস তৈরি করতে হবে। এর ফলে কোডের রক্ষণাবেক্ষণ সহজ হয় এবং নতুন ফিচার যোগ করা সহজ হয়।
3. Loose Coupling: ক্লায়েন্ট কোড সরাসরি ডকুমেন্টের কনক্রিট ক্লাসের উপর নির্ভরশীল নয়। তারা শুধুমাত্র Document ইন্টারফেস ব্যবহার করছে, যা নতুন ক্লাস যোগ করার সময় কোনো সমস্যার সৃষ্টি করবে না।

সারাংশ

Factory Method Pattern একটি কার্যকরী ডিজাইন প্যাটার্ন যা অবজেক্ট তৈরি করার প্রক্রিয়াকে আড়াল করে এবং সাবক্লাসকে নির্ধারণ করতে দেয় কোন অবজেক্ট তৈরি করা হবে। এটি Creational Design Pattern এর মধ্যে পড়ে এবং Loose Coupling ও Extensibility সুবিধা প্রদান করে। এর মাধ্যমে নতুন ধরনের অবজেক্ট তৈরি করা সহজ হয় এবং কোডের রক্ষণাবেক্ষণ সহজতর হয়।

Abstract Factory Pattern হল একটি Creational Design Pattern, যা একাধিক সম্পর্কিত বা নির্ভরশীল অবজেক্ট তৈরি করতে ব্যবহৃত হয়, যেখানে এটি একটি ইন্টারফেস প্রদান করে যা সাবক্লাসগুলিকে কনক্রিট অবজেক্ট তৈরি করার সুযোগ দেয়। এর প্রধান উদ্দেশ্য হল গ্রাহক ক্লাসটি নির্দিষ্ট ক্লাসে নির্ভর না হয়ে, একাধিক ভিন্ন ভিন্ন ক্লাসের সমন্বয়ে অবজেক্ট তৈরি করার সুবিধা প্রদান করা।

1. Abstract Factory Pattern কী?

এটি একটি ডিজাইন প্যাটার্ন যা একটি ইন্টারফেস (এবস্ট্রাক্ট ফ্যাক্টরি) প্রদান করে, যা একাধিক সম্পর্কিত অবজেক্ট তৈরি করতে সাহায্য করে। তবে ক্লায়েন্ট কোড এ ধরনের কনক্রিট ক্লাসের উপর নির্ভর করে না, এবং শুধুমাত্র আবস্ট্রাক্ট ফ্যাক্টরি ইন্টারফেসের মাধ্যমে অবজেক্ট তৈরি করা হয়।

Abstract Factory প্যাটার্নের সাহায্যে, আপনি এক ধরনের অবজেক্টের সমষ্টি তৈরি করতে পারেন, যেমন বিভিন্ন ধরনের গ্রাফিক্যাল ইউজার ইন্টারফেস (GUI) কম্পোনেন্ট (বাটন, টেক্সট ফিল্ড, মেনু ইত্যাদি) একত্রিত করা।

2. Abstract Factory Pattern এর কাঠামো

Abstract Factory Pattern তিনটি প্রধান উপাদান নিয়ে গঠিত:

1. AbstractFactory: একটি ইন্টারফেস বা অ্যাবস্ট্রাক্ট ক্লাস যা ফ্যাক্টরি মেথডগুলির জন্য একক অর্ডার প্রদান করে।
2. ConcreteFactory: এটি AbstractFactory ইন্টারফেসে ঘোষণা করা মেথডগুলোকে বাস্তবায়ন করে।
3. AbstractProduct: একটি অ্যাবস্ট্রাক্ট ক্লাস বা ইন্টারফেস যা বিভিন্ন প্রকারের পণ্য তৈরি করে।
4. ConcreteProduct: এটি AbstractProduct এর বাস্তবায়ন এবং এটি কনক্রিট প্রোডাক্ট তৈরি করে।

3. Abstract Factory Pattern উদাহরণ

ধরা যাক আমাদের দুটি ভিন্ন প্ল্যাটফর্মে (উইন্ডোজ এবং ম্যাক) গ্রাফিক্যাল ইউজার ইন্টারফেস (GUI) উপাদান তৈরি করতে হবে। প্রতিটি প্ল্যাটফর্মের জন্য ভিন্ন ভিন্ন Button এবং Checkbox হবে। তবে, গ্রাহক ক্লাসটি কোন প্ল্যাটফর্মে কাজ করবে তাও জানবে না, শুধু যে প্ল্যাটফর্মের উপাদান প্রয়োজন তা জানবে। এই ধরনের সমস্যা সমাধানে Abstract Factory Pattern ব্যবহৃত হবে।

3.1. Abstract Factory Pattern Implementation

// Abstract product: Button
interface Button {
    void render();
}

// Concrete product: Windows Button
class WindowsButton implements Button {
    public void render() {
        System.out.println("Rendering Windows Button");
    }
}

// Concrete product: Mac Button
class MacButton implements Button {
    public void render() {
        System.out.println("Rendering Mac Button");
    }
}

// Abstract product: Checkbox
interface Checkbox {
    void render();
}

// Concrete product: Windows Checkbox
class WindowsCheckbox implements Checkbox {
    public void render() {
        System.out.println("Rendering Windows Checkbox");
    }
}

// Concrete product: Mac Checkbox
class MacCheckbox implements Checkbox {
    public void render() {
        System.out.println("Rendering Mac Checkbox");
    }
}

// Abstract factory
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// Concrete factory: Windows Factory
class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }

    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

// Concrete factory: Mac Factory
class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }

    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// Client code
public class Application {
    private Button button;
    private Checkbox checkbox;

    // Constructor accepts a GUI factory (abstract factory)
    public Application(GUIFactory factory) {
        button = factory.createButton();
        checkbox = factory.createCheckbox();
    }

    public void renderUI() {
        button.render();
        checkbox.render();
    }

    public static void main(String[] args) {
        // Choose the factory based on the OS
        GUIFactory factory = new WindowsFactory();
        Application app = new Application(factory);
        app.renderUI();  // Will render Windows button and checkbox

        System.out.println("----");

        factory = new MacFactory();
        app = new Application(factory);
        app.renderUI();  // Will render Mac button and checkbox
    }
}

ব্যাখ্যা:

1. Button এবং Checkbox হল AbstractProduct ইন্টারফেস, যা সাধারণ পণ্য তৈরি করে।
2. WindowsButton, MacButton, WindowsCheckbox, এবং MacCheckbox হল ConcreteProduct, যেগুলি নির্দিষ্ট প্ল্যাটফর্মের জন্য বাস্তবায়ন করা হয়েছে।
3. GUIFactory হল AbstractFactory ইন্টারফেস যা createButton() এবং createCheckbox() মেথড ঘোষণা করে।
4. WindowsFactory এবং MacFactory হল ConcreteFactory যা নির্দিষ্ট প্ল্যাটফর্মের উপাদান তৈরি করে।

আউটপুট:

Rendering Windows Button
Rendering Windows Checkbox
----
Rendering Mac Button
Rendering Mac Checkbox

4. Abstract Factory Pattern এর সুবিধা

1. Encapsulation: গ্রাহক কোড (Client code) ফ্যাক্টরি ক্লাসের কার্যকারিতা জানবে না, শুধু উপাদানগুলি তৈরি করার জন্য ইন্টারফেস ব্যবহার করবে। এটি ক্লাসের বাস্তবায়ন সংক্রান্ত তথ্য লুকিয়ে রাখে।
2. Loose Coupling: গ্রাহক কোড এবং কনক্রিট ফ্যাক্টরি (Concrete Factory) এর মধ্যে loose coupling রাখে। এটি একটি ফ্যাক্টরি ইন্টারফেস দিয়ে একাধিক প্ল্যাটফর্মের উপাদান তৈরি করতে সহায়ক।
3. Product Consistency: একটি নির্দিষ্ট প্ল্যাটফর্মের সব উপাদান (যেমন, উইন্ডোজের বাটন এবং চেকবক্স) একইভাবে তৈরি হয় এবং তারা একে অপরের সাথে সামঞ্জস্যপূর্ণ হয়।

5. Abstract Factory Pattern এর ব্যবহার

• GUI Frameworks: একাধিক প্ল্যাটফর্মের জন্য ইউনিফর্ম ইউজার ইন্টারফেস উপাদান তৈরি করতে Abstract Factory Pattern ব্যবহৃত হয়। যেমন উইন্ডোজ, ম্যাক এবং লিনাক্সে এক ধরনের বাটন এবং চেকবক্স তৈরি করা।
• Database Connectivity: একাধিক ডেটাবেস (MySQL, Oracle, PostgreSQL) সংযোগ স্থাপনের জন্য একাধিক ফ্যাক্টরি তৈরি করা যেতে পারে।
• Document Generators: একাধিক ডকুমেন্ট ফর্ম্যাট (PDF, HTML, Word) তৈরির জন্য পৃথক ফ্যাক্টরি ব্যবহৃত হয়।

সারাংশ

Abstract Factory Pattern একটি ডিজাইন প্যাটার্ন যা সম্পর্কিত অবজেক্টগুলির জন্য একটি সাধারণ ইন্টারফেস প্রদান করে, এবং গ্রাহক কোডটি সরাসরি কনক্রিট ক্লাসের উপর নির্ভর না হয়ে, বিভিন্ন প্ল্যাটফর্মের উপাদান তৈরি করতে পারে। এটি ব্যবহৃত হয় বিভিন্ন ধরনের সম্পর্কিত অবজেক্ট একত্রিত করার জন্য এবং এতে loose coupling এবং encapsulation সুবিধা প্রদান করা হয়। Java তে GUI, ডেটাবেস কানেকশন এবং ডকুমেন্ট জেনারেটর তৈরির ক্ষেত্রে এটি ব্যাপকভাবে ব্যবহৃত হয়।

Builder Pattern একটি creational design pattern যা একটি জটিল অবজেক্ট তৈরি করার প্রক্রিয়া সহজতর করে। এই প্যাটার্নটি মূলত ব্যবহার করা হয় যখন একটি অবজেক্টের অনেকগুলি অংশ থাকে এবং অবজেক্টটি তৈরি করার জন্য অনেক ভিন্ন ভিন্ন কনফিগারেশন বা প্যারামিটার থাকতে পারে।

Builder Pattern এর ধারণা

Builder Pattern মূলত একটি builder class তৈরি করে, যা অবজেক্ট তৈরি করার জন্য বিভিন্ন ধাপে কাজ করে। এটি সেই অবজেক্টটির কনফিগারেশন বা গঠন সহজতর করতে সহায়তা করে, বিশেষ করে যখন অবজেক্টটির বিভিন্ন অংশের মান পরিবর্তনশীল বা স্বতন্ত্র হয়।

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

Builder Pattern এর উপকারিতা

1. Separation of Construction Logic: এই প্যাটার্নটি অবজেক্ট তৈরির কনস্ট্রাকশন লজিককে ক্লাসের মূল লজিক থেকে আলাদা করে।
2. Readable Code: এটি কোডের পাঠযোগ্যতা এবং রক্ষণাবেক্ষণকে সহজ করে তোলে, কারণ কনস্ট্রাক্টরের মাধ্যমে সরাসরি অবজেক্ট তৈরি না করে, ধাপে ধাপে অবজেক্ট তৈরি করা হয়।
3. Avoiding Constructor Overloading: যখন অনেক প্যারামিটার থাকে, তখন কনস্ট্রাক্টর ওভারলোডের সমস্যা হয়। Builder Pattern এই সমস্যার সমাধান করে।

Builder Pattern এর কাঠামো (Structure)

Builder Pattern সাধারণত তিনটি প্রধান কম্পোনেন্টের মধ্যে বিভক্ত:

1. Product: যে অবজেক্টটি তৈরি হবে।
2. Builder: অবজেক্ট তৈরি করার জন্য ধাপগুলি নির্দিষ্ট করে।
3. Director: Builder এর মাধ্যমে অবজেক্ট তৈরি করতে নির্দেশনা প্রদান করে।

Builder Pattern এর উদাহরণ

ধরা যাক, আমরা একটি House (বাড়ি) তৈরি করতে যাচ্ছি, যার কিছু অংশ হতে পারে foundation, walls, roof ইত্যাদি। এখানে, আমরা Builder Pattern ব্যবহার করে এই বাড়ি তৈরি করব।

1. Product Class (House)

public class House {
    private String foundation;
    private String walls;
    private String roof;

    // Getters for house parts
    public String getFoundation() {
        return foundation;
    }

    public String getWalls() {
        return walls;
    }

    public String getRoof() {
        return roof;
    }

    // Constructor
    public House(String foundation, String walls, String roof) {
        this.foundation = foundation;
        this.walls = walls;
        this.roof = roof;
    }
}

2. Builder Class (HouseBuilder)

public class HouseBuilder {
    private String foundation;
    private String walls;
    private String roof;

    // Setters for house parts
    public HouseBuilder setFoundation(String foundation) {
        this.foundation = foundation;
        return this;
    }

    public HouseBuilder setWalls(String walls) {
        this.walls = walls;
        return this;
    }

    public HouseBuilder setRoof(String roof) {
        this.roof = roof;
        return this;
    }

    // Method to build the house
    public House build() {
        return new House(foundation, walls, roof);
    }
}

3. Director Class

public class HouseDirector {
    private HouseBuilder builder;

    public HouseDirector(HouseBuilder builder) {
        this.builder = builder;
    }

    // Constructing a specific house
    public House buildHouse() {
        return builder.setFoundation("Concrete Foundation")
                      .setWalls("Brick Walls")
                      .setRoof("Tile Roof")
                      .build();
    }
}

4. Client Code (Main Class)

public class Main {
    public static void main(String[] args) {
        // Using the builder pattern
        HouseBuilder houseBuilder = new HouseBuilder();
        HouseDirector director = new HouseDirector(houseBuilder);
        
        // Construct the house using the director
        House house = director.buildHouse();
        
        // Print the house details
        System.out.println("House built with:");
        System.out.println("Foundation: " + house.getFoundation());
        System.out.println("Walls: " + house.getWalls());
        System.out.println("Roof: " + house.getRoof());
    }
}

Explanation:

1. House Class: এটি মূল অবজেক্ট যা তৈরি করা হচ্ছে। এখানে foundation, walls, এবং roof এর মতো প্রপার্টি রয়েছে।
2. HouseBuilder Class: এই ক্লাসটি builder হিসেবে কাজ করে, যেখানে foundation, walls, এবং roof এর জন্য সেটার মেথড রয়েছে। এটি অবজেক্ট তৈরি করতে ধাপে ধাপে কাজ করে এবং একবার সব কিছু সেট হয়ে গেলে build() মেথড ব্যবহার করে House অবজেক্ট তৈরি করা হয়।
3. HouseDirector Class: এটি মূলত builder এর সাথে কাজ করে এবং সঠিকভাবে গৃহ নির্মাণের জন্য নির্দিষ্ট ধাপগুলি পালন করে। এই ক্লাসটি শুধু গৃহ নির্মাণের প্রক্রিয়াটি নির্দেশ করে এবং এটি ক্লায়েন্টের জন্য একটি পরিষ্কার API প্রদান করে।
4. Client Code: এখানে আমরা HouseBuilder এবং HouseDirector ব্যবহার করে একটি বাড়ি তৈরি করেছি।

Builder Pattern এর সুবিধা

1. Fluent Interface: Builder Pattern fluent interface ধারণা ব্যবহার করে, যেখানে আপনি একাধিক মেথড চেইন করে একটি অবজেক্ট তৈরি করতে পারেন।

   উদাহরণ:

   House house = new HouseBuilder()
                      .setFoundation("Concrete Foundation")
                      .setWalls("Wooden Walls")
                      .setRoof("Metal Roof")
                      .build();
   

2. Readability: এটি কোডের পাঠযোগ্যতা এবং রক্ষণাবেক্ষণকে সহজ করে তোলে, কারণ একাধিক প্যারামিটার বা কনফিগারেশন থাকতে পারে, কিন্তু আপনি ধাপে ধাপে সেগুলিকে সেট করতে পারেন।
3. Avoid Constructor Overloading: যখন একটি ক্লাসের অনেক প্যারামিটার থাকে, তখন কনস্ট্রাক্টর ওভারলোডিং হতে পারে, কিন্তু Builder Pattern এই সমস্যার সমাধান করে।

Builder Pattern এর সময় এবং স্থান জটিলতা

• Time Complexity: Builder Pattern সাধারণত একটি নির্দিষ্ট কাজের জন্য O(1) বা O(n) সময় নিয়ে কাজ করে, কারণ এখানে আমরা একে একে উপাদানগুলো নির্দিষ্ট করে তৈরি করি।
• Space Complexity: Builder Pattern এর space complexity সাধারণত O(1) থাকে, যদি না আপনি বড় কোনো ডাটা স্ট্রাকচার ব্যবহার করেন উপাদান তৈরি করার জন্য।

Builder Pattern একটি অত্যন্ত শক্তিশালী ডিজাইন প্যাটার্ন যা জটিল অবজেক্ট তৈরি করার প্রক্রিয়াকে সহজতর করে তোলে। এটি কেবলমাত্র ডাটা স্ট্রাকচারগুলির ক্ষেত্রে নয়, বিভিন্ন অ্যাপ্লিকেশন ও সিস্টেম ডিজাইনেও ব্যবহার করা যায়। জাভাতে Builder Pattern ব্যবহার করলে, আপনি অবজেক্ট তৈরির জন্য একটি পরিষ্কার, মুঠোফোন পদ্ধতি তৈরি করতে পারবেন এবং কোডকে আরও সহজ এবং কার্যকরী করতে পারবেন।

Prototype Pattern একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা একটি অবজেক্টের নতুন কপি (clone) তৈরি করার জন্য ব্যবহৃত হয়, পরিবর্তে পুনরায় নতুন অবজেক্ট তৈরি করার। এই প্যাটার্নটি মূলত অবজেক্ট কপির জন্য ব্যবহৃত হয় যেখানে একই ধরনের অবজেক্ট বারবার তৈরি করতে হয়। এটি সাধারণত ক্লোনিং এর মাধ্যমে কাজ করে এবং এটি অবজেক্টের এক্সপেনশন বা কাস্টমাইজেশন এর জন্য ব্যবহৃত হয়।

Prototype Pattern এর মূল উদ্দেশ্য হল, যখন একই অবজেক্টের একাধিক কপি তৈরি করা প্রয়োজন, তখন আপনি একটি existing object থেকে ক্লোন তৈরি করতে পারেন, যা সম্পূর্ণ নতুন অবজেক্ট তৈরির চাইতে দ্রুত এবং কার্যকরী।

Prototype Pattern এর বৈশিষ্ট্য:

• ক্লোনিং: এটি একটি অবজেক্টের একটি কপি তৈরি করতে ব্যবহৃত হয়, যার ফলে নতুন অবজেক্ট তৈরি করার সময় প্রয়োজনীয় সময় এবং রিসোর্স কমে যায়।
• কাস্টমাইজেশন: অবজেক্টের কপি তৈরি করার পরে আপনি সেটিকে পরিবর্তন বা কাস্টমাইজ করতে পারেন।
• অপারেশন লোডের উন্নতি: যখন অনেক সংখ্যক একই ধরনের অবজেক্টের প্রয়োজন হয়, তখন এই প্যাটার্ন কার্যকরী হতে পারে।

Prototype Pattern এর ক্লাস ডায়াগ্রাম:

Prototype Pattern এ মূলত দুটি গুরুত্বপূর্ণ উপাদান থাকে:

1. Prototype: একটি ইন্টারফেস যা clone() মেথড সংজ্ঞায়িত করে, যা অবজেক্টের কপি তৈরি করার জন্য ব্যবহৃত হয়।
2. ConcretePrototype: এটি একটি কনক্রিট ক্লাস যা Prototype ইন্টারফেস ইমপ্লিমেন্ট করে এবং আসল ক্লোনিং লজিক সরবরাহ করে।

Prototype Pattern এর উদাহরণ (Java)

ধরা যাক, আমরা একটি Document অবজেক্ট তৈরি করতে চাই, এবং আমাদের প্রয়োজন একাধিক কপি তৈরি করা সেই একই অবজেক্টের, যাতে Document ক্লাসের মধ্যে কিছু পরিবর্তন করা যায়।

Step 1: Prototype Interface (Cloneable Interface)

public interface Prototype {
    Prototype clone();  // ক্লোনিং পদ্ধতি
}

Step 2: Concrete Prototype Class

public class Document implements Prototype {
    private String content;

    public Document(String content) {
        this.content = content;
    }

    // Getter for content
    public String getContent() {
        return content;
    }

    // Setter for content
    public void setContent(String content) {
        this.content = content;
    }

    // Implementing the clone method
    @Override
    public Prototype clone() {
        return new Document(this.content);  // Create a copy of the Document object
    }

    public void display() {
        System.out.println("Document Content: " + content);
    }
}

Step 3: Prototype Test Class

public class PrototypePatternExample {
    public static void main(String[] args) {
        // Creating an initial document
        Document doc1 = new Document("This is a prototype document.");
        doc1.display();

        // Cloning the document
        Document doc2 = (Document) doc1.clone();
        doc2.setContent("This is the cloned document with different content.");
        doc2.display();

        // Original document remains unchanged
        doc1.display();
    }
}

ব্যাখ্যা:

1. Prototype Interface: এখানে আমরা Prototype ইন্টারফেস তৈরি করেছি, যার একটি clone() মেথড রয়েছে।
2. ConcretePrototype Class: Document ক্লাসটি Prototype ইন্টারফেস ইমপ্লিমেন্ট করে এবং clone() মেথডকে Document অবজেক্টের কপি তৈরি করার জন্য বাস্তবায়ন করে।
3. PrototypePatternExample: এখানে একটি মূল Document অবজেক্ট তৈরি করা হয়েছে এবং তারপর তার একটি কপি তৈরি করা হয়েছে। কপি তৈরি করার পর, কপি এবং মূল অবজেক্টের content আলাদা করা হয়েছে, কিন্তু মূল অবজেক্ট অপরিবর্তিত থাকে।

আউটপুট:

Document Content: This is a prototype document.
Document Content: This is the cloned document with different content.
Document Content: This is a prototype document.

Prototype Pattern এর সুবিধা এবং ব্যবহার

সুবিধা:

1. নতুন অবজেক্ট তৈরির প্রয়োজনীয়তা হ্রাস: যখন একই ধরনের অনেক অবজেক্টের প্রয়োজন হয়, তখন ক্লোনিং পদ্ধতি ব্যবহার করলে প্রোগ্রামের কর্মক্ষমতা বাড়ানো যায়, কারণ এতে নতুন অবজেক্ট তৈরির পরিবর্তে ক্লোন করা হয়।
2. দ্রুত কপি তৈরি: পুরানো অবজেক্ট থেকে দ্রুত কপি তৈরি করা যায়, যা অনেক সময় এবং রিসোর্স বাঁচায়।
3. কাস্টমাইজেশন: আপনি ক্লোন হওয়া অবজেক্টটি আরও কাস্টমাইজ করতে পারেন।

ব্যবহার:

• গেম ডেভেলপমেন্ট: গেমে বিভিন্ন ধরনের অবজেক্ট যেমন শত্রু, প্লেয়ার, অস্ত্র, ইত্যাদি থাকে যা একই রকম কপি তৈরি করে পরিচালনা করা যেতে পারে।
• অফিস সফটওয়্যার: বিভিন্ন ধরনের ডকুমেন্ট বা ফাইলের কপি তৈরি করা।
• গ্রাফিক্স সিস্টেম: একাধিক গ্রাফিক্যাল অবজেক্ট তৈরি করার জন্য, যেখানে ডিফল্ট অবজেক্টের কপি তৈরি করা হয়।

সারাংশ

Prototype Pattern একটি ক্রিয়েশনাল ডিজাইন প্যাটার্ন যা একটি অবজেক্টের ক্লোন (কপি) তৈরি করতে ব্যবহৃত হয়, যাতে একই ধরনের অবজেক্টের একাধিক কপি তৈরি করার প্রয়োজন হলে দ্রুত এবং কার্যকরীভাবে সেই কপি তৈরি করা যায়। এটি ক্লোনিং পদ্ধতির মাধ্যমে কাজ করে এবং Java তে এটি clone() মেথড ব্যবহার করে বাস্তবায়ন করা যায়। Prototype Pattern মূলত সেই সমস্ত পরিস্থিতিতে ব্যবহৃত হয় যেখানে একাধিক সমান অবজেক্ট তৈরি করার প্রয়োজন এবং সেগুলিকে কাস্টমাইজড বা পরিবর্তনশীলভাবে ব্যবহৃত করা হয়।