Factory এবং Abstract Factory Pattern এর মধ্যে পার্থক্য কী?

Factory Pattern এবং Abstract Factory Pattern দুটি Creational Design Patterns যা অ্যাবস্ট্রাকশন ব্যবহার করে বিভিন্ন ধরনের অবজেক্ট তৈরি করতে সহায়ক হয়। তবে, এদের মধ্যে কিছু মূল পার্থক্য রয়েছে। নিচে দুইটি প্যাটার্নের পার্থক্য ব্যাখ্যা করা হয়েছে:

1. Factory Pattern (Factory Method Pattern)

Factory Method Pattern একটি Creational Design Pattern যা সাব-ক্লাসগুলিকে নির্দিষ্ট অবজেক্ট তৈরি করতে সাহায্য করে। এটি একটি "মেথড" ব্যবহার করে অবজেক্ট তৈরি করে এবং ক্লাসের ইন্সট্যান্স তৈরির দায়িত্ব সাব-ক্লাসে হস্তান্তর করে। এই প্যাটার্নের মূল উদ্দেশ্য হল অবজেক্ট তৈরি করার কোডটি একটি নির্দিষ্ট ক্লাসের বাইরে স্থানান্তর করা, যাতে ক্লাসটি তার কনস্ট্রাকটরের সাথে সম্পর্কিত না থাকে।

মূল বৈশিষ্ট্য:

• Single product তৈরি করে (একটি নির্দিষ্ট ধরণের অবজেক্ট)।
• এটি একটি method (যেমন create() বা getObject()) ব্যবহার করে।
• Client কোডটি অবজেক্ট তৈরি করার প্রক্রিয়া থেকে আড়াল করা হয়।

উদাহরণ:

// Product interface
interface Product {
    void create();
}

// Concrete Product
class ConcreteProductA implements Product {
    public void create() {
        System.out.println("Product A created.");
    }
}

class ConcreteProductB implements Product {
    public void create() {
        System.out.println("Product B created.");
    }
}

// Creator or Factory
class ProductFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

public class FactoryPatternExample {
    public static void main(String[] args) {
        ProductFactory factory = new ProductFactory();
        Product productA = factory.createProduct("A");
        productA.create();
        Product productB = factory.createProduct("B");
        productB.create();
    }
}

Output:

Product A created.
Product B created.

2. Abstract Factory Pattern

Abstract Factory Pattern একটি আরও বড় এবং উন্নত প্যাটার্ন, যা একাধিক সম্পর্কিত বা প্যারামিটারাইজড অবজেক্ট তৈরি করতে ব্যবহৃত হয়। এটি একটি interface বা abstract class দিয়ে গোষ্ঠীবদ্ধ (family) পণ্য তৈরি করার কাজটি সহজ করে। Abstract Factory মূলত বিভিন্ন ফ্যাক্টরি ক্লাসের একটি গ্রুপ তৈরি করে, যেখানে প্রতিটি ফ্যাক্টরি এক ধরনের অবজেক্ট তৈরি করে।

মূল বৈশিষ্ট্য:

• একাধিক সম্পর্কিত পণ্য তৈরি করার জন্য একটি গোষ্ঠী ফ্যাক্টরি ক্লাস।
• Multiple products (অথবা product families) তৈরি করে।
• ক্লায়েন্ট কোডটি কেবল একটিমাত্র ফ্যাক্টরি ব্যবহার করে বিভিন্ন ধরণের পণ্য তৈরি করতে পারে।

উদাহরণ:

// Abstract Product A
interface ProductA {
    void create();
}

// Abstract Product B
interface ProductB {
    void create();
}

// Concrete Product A1
class ConcreteProductA1 implements ProductA {
    public void create() {
        System.out.println("Product A1 created.");
    }
}

// Concrete Product A2
class ConcreteProductA2 implements ProductA {
    public void create() {
        System.out.println("Product A2 created.");
    }
}

// Concrete Product B1
class ConcreteProductB1 implements ProductB {
    public void create() {
        System.out.println("Product B1 created.");
    }
}

// Concrete Product B2
class ConcreteProductB2 implements ProductB {
    public void create() {
        System.out.println("Product B2 created.");
    }
}

// Abstract Factory
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// Concrete Factory 1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// Concrete Factory 2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public class AbstractFactoryPatternExample {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.create();
        ProductB productB1 = factory1.createProductB();
        productB1.create();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.create();
        ProductB productB2 = factory2.createProductB();
        productB2.create();
    }
}

Output:

Product A1 created.
Product B1 created.
Product A2 created.
Product B2 created.

3. Factory Pattern এবং Abstract Factory Pattern এর মধ্যে পার্থক্য:

• Factory Pattern সাধারণত একটি নির্দিষ্ট প্রোডাক্ট তৈরির জন্য ব্যবহৃত হয় এবং একটি নির্দিষ্ট মেথড ব্যবহার করে তা তৈরি করা হয়।
• Abstract Factory Pattern বেশি জটিল এবং একাধিক সম্পর্কিত প্রোডাক্ট তৈরির জন্য ব্যবহৃত হয়, যেখানে প্রতিটি ফ্যাক্টরি একটি নির্দিষ্ট প্রোডাক্ট ফ্যামিলি তৈরি করে।

যখন আপনি একাধিক সম্পর্কিত প্রোডাক্ট তৈরি করতে চান, তখন Abstract Factory Pattern ব্যবহার করবেন, এবং যখন আপনি একটি নির্দিষ্ট প্রোডাক্ট তৈরি করতে চান, তখন Factory Pattern ব্যবহার করবেন।