Factory pattern શું છે?

Question

IT Interview Practice · Accepted Answer

The **Factory** pattern provides a way to **create objects without specifying their exact class** — a method or class that handles object creation, deciding which type to instantiate. It centralizes and abstracts object creation, decoupling code from concrete classes.

## Factory pattern શું કરે છે

```text
FACTORY → encapsulate object CREATION (instead of calling constructors directly):
  → a factory method/class decides WHICH class to instantiate and creates it
  → the caller asks the factory for an object (by type/parameter) → gets the right object
    WITHOUT knowing/specifying the concrete class
→ decouples code from CONCRETE classes; centralizes creation logic
```

## ઉદાહરણ

```js
// a factory creates the right type based on input
class ShapeFactory {
  static create(type) {
    switch (type) {
      case 'circle': return new Circle();
      case 'square': return new Square();
      default: throw new Error('Unknown shape');
    }
  }
}
const shape = ShapeFactory.create('circle');   // caller doesn't use 'new Circle' directly
// → to add a new shape, change the factory, not all the calling code
```

## લાભો અને વિવિધતાઓ

```text
BENEFITS:
  ✓ DECOUPLING → callers depend on an interface/factory, not concrete classes
  ✓ CENTRALIZED creation → creation logic in one place (easier to change/extend)
  ✓ FLEXIBILITY → easy to add new types (change the factory) or swap implementations
VARIATIONS:
  → FACTORY METHOD → a method (often overridden by subclasses) creates objects
  → ABSTRACT FACTORY → creates families of related objects
  → simple factory (as above) is the basic form
```

## તે શા માટે મહત્વપૂર્ણ છે

Factory pattern સમજવું મૂલ્યવાન છે કારણ કે તે **વૃદ્ધિશીલ પદ્ધતિનો એક સામાન્ય, ઉપયોગી પ્રકાર** છે જે કોડને object creation થી અલગ રાખે છે, તેથી તે વ્યવહારિક-પ્રাસંગિક ડિઝાઇન જ્ઞાન છે.

Factory pattern object creation ને encapsulate કરે છે — એક factory method અથવા class નક્કી કરે છે કે કયો class instantiate કરવો, તેથી callers object માટે પૂછે છે (type અથવા parameter દ્વારા) અને યોગ્ય મેળવે છે **concrete class જાણ્યા અથવા સ્પષ્ટ કર્યા વિના**.

તે સમજવું મૂલ્યવાન છે કારણ કે તે વાસ્તવિક જરૂર સંબોધે છે: **કોડને concrete classes થી અલગ રાખવું** (callers factory/interface પર આધાર રાખે છે, specific implementations નહીં) અને **centralized creation logic** (એક જગ્યાએ, જેથી તેને બદલવું અને વિસ્તરણ કરવું સરળ હોય).

તે **લાભો** સમજવું — decoupling, centralized creation, અને flexibility (સરળતાથી નવા types ઉમેરવું factory બદલીને, અથવા implementations સ્વૅપ કરવું, બધા calling code કોઈ પણ રીતે બદલ્યા વિના) — સ્પષ્ટ કરે છે કે પ્રકાર શા માટે maintainable, flexible code માટે ઉપયોગી છે.

તે **વિવિધતાઓ** સમજવું — simple factory (એક method નક્કી કરે છે કે શું બનાવવું), the **factory method** (ઘણી વખત subclasses દ્વારા override કર્યું જાય છે), અને the **abstract factory** (related objects ના families બનાવવું) — factory approaches ની સંપૂર્ણ શ્રેણી આવરી લે છે.

Factory pattern સામાન્ય રીતે ઉપયોગમાં લેવાય છે અને વારંવાર ચર્ચા કરવામાં આવે છે, જ્યાં ભ્રમણ કરે છે તે વાસ્તવિક codebases અને frameworks ધરી જ્યાં object creation flexible અથવા decoupled હોવું જોઈએ.

KuDos Factory pattern એક સામાન્ય, ઉપયોગી creational pattern છે જે કોડને object creation થી અલગ રાખે છે અને creation logic ને centralize કરે છે (flexibility અને maintainability માં સુધાર કરે છે), અને કારણ કે તે શું કરે છે, તેના લાભો, અને તેની વિવિધતાઓ સમજવું વ્યવહારિક પ્રાસંગિક છે, Factory pattern સમજવું મૂલ્યવાન, સામાન્ય-લાગુ design knowledge છે — decoupling અને flexibility માટે એક વારંવાર-ઉપયોગી creational pattern object creation માં, વાસ્તવિક codebases અને frameworks માં સામાન્ય, અને maintainable, flexible code લખવા માટે મહત્વપૂર્ણ design knowledge.

Factory pattern શું કરે છે

ઉદાહરણ

લાભો અને વિવિધતાઓ

તે શા માટે મહત્વપૂર્ણ છે

સંબંધિત પ્રશ્નો