Factory pattern என்றால் என்ன?

Question

Accepted Answer

**Factory** pattern என்பது **object களை அவற்றின் exact class ஐ specify செய்யாமல் create செய்வதற்கான ஒரு வழி** — object creation ஐ handle செய்யும் ஒரு method அல்லது class, எந்த type ஐ instantiate செய்வது என்பதை தீர்மானிக்கும். இது object creation ஐ centralize செய்து abstract பண்ணுகிறது, code ஐ concrete classes இல் இருந்து decouple செய்கிறது.

## 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 ஐ புரிந்துகொள்வது மதிப்புள்ளது ஏனெனில் இது ஒரு **பொதுவான, பயனுள்ள creational pattern** object creation இலிருந்து code ஐ decouple செய்ய, அதனால் இது pragmatically-relevant design knowledge ஆகும்.

Factory pattern object creation ஐ encapsulate செய்கிறது — factory method அல்லது class எந்த class ஐ instantiate செய்வது என்பதை தீர்மானிக்கிறது, அதனால் callers ஒரு object க்கு (type அல்லது parameter மூலம்) கேட்டு சரியான ஒன்றை பெறுகிறார்கள் **concrete class ஐ தெரியாமல் அல்லது specify செய்யாமல்**.

இதை புரிந்துகொள்வது மதிப்புள்ளது ஏனெனில் இது ஒரு உண்மையான தேவையை address செய்கிறது: **code ஐ concrete classes இலிருந்து decouple செய்வது** (callers specific implementations ஐ பெயரிடுவதற்கு பதிலாக factory/interface ஐ depend செய்கிறார்கள்) மற்றும் **creation logic ஐ centralize செய்வது** (ஒரு இடத்தில், மாற்றுவதை மற்றும் extend செய்வதை எளிதாக்குவது).

**நன்மைகள்** — decoupling, centralized creation, மற்றும் flexibility (factory ஐ மாற்றுவதன் மூலம் எளிதாக புதிய types ஐ சேர்க்கலாம், அல்லது implementations ஐ swap செய்யலாம், அனைத்து calling code ஐ modify செய்யாமல்) — ஐ புரிந்துகொள்வது pattern ஏன் maintainable, flexible code க்கு பயனுள்ளது என்பதை தெளிவுபடுத்துகிறது.

**மாறுபாடுகள்** — simple factory (ஒரு method என்ன create செய்வது என்பதை தீர்மானிக்கிறது), **factory method** (பெரும்பாலும் subclasses மூலம் override செய்யப்படுகிறது), மற்றும் **abstract factory** (related objects களின் families ஐ create செய்கிறது) — ஐ புரிந்துகொள்வது factory approaches இன் spectrum ஐ cover செய்கிறது.

Factory pattern பொதுவாக பயன்படுத்தப்படுகிறது மற்றும் அடிக்கடி நட்புடன் பேசப்படுகிறது, real codebases மற்றும் frameworks முழுவதும் தோன்றுகிறது எங்கு object creation flexible அல்லது decoupled ஆக இருக்க வேண்டிய அவசியம் உண்டு.

Factory pattern ஒரு பொதுவான, பயனுள்ள creational pattern object creation இலிருந்து code ஐ decouple செய்வது மற்றும் creation logic ஐ centralize செய்வது (flexibility மற்றும் maintainability ஐ மேம்படுத்துவது), மற்றும் என்ன செய்கிறது, அதன் நன்மைகள், மற்றும் அதன் மாறுபாடுகளை புரிந்துகொள்வது pragmatically relevant என்பதால், Factory pattern ஐ புரிந்துகொள்வது மதிப்புள்ளது, commonly-applicable design knowledge — object creation இல் decoupling மற்றும் flexibility க்கான ஒரு frequently-used creational pattern, real codebases மற்றும் frameworks இல் பொதுவானது, மற்றும் maintainable, flexible code ஐ எழுதுவதற்கான முக்கியமான design knowledge.