Java میں کون سے عام ڈیزائن پیٹرن نظر آتے ہیں؟

Question

Accepted Answer

**Design patterns** بار بار آنے والے software-design مسائل کے لیے دوبارہ استعمال کے قابل حل ہیں۔ Java کی OOP فطرت اور ecosystem کئی patterns کو خاص طور پر عام بناتے ہیں — انہیں جاننے سے آپ کو ثابت شدہ ڈھانچے کو تسلیم کرنے، بات چیت کرنے اور لاگو کرنے میں مدد ملتی ہے۔ یہ creational، structural، اور behavioral زمرہ جات میں تقسیم ہوتے ہیں۔

## Singleton (creational) — ایک مشترک instance

```java
public class Config {
    private static final Config INSTANCE = new Config();   // the single instance
    private Config() {}                                     // private constructor
    public static Config getInstance() { return INSTANCE; }
}
// (enum singletons are an even safer idiom). Used for shared config, connection pools.
```

## Factory (creational) — object کی تخلیق کو محصور کریں

```java
public static Shape createShape(String type) {
    return switch (type) {                 // hides the concrete class from the caller
        case "circle" -> new Circle();
        case "square" -> new Square();
        default -> throw new IllegalArgumentException();
    };
}
// caller depends on Shape, not concrete classes — decoupling.
```

## Builder (creational) — پیچیدہ objects کو مرحلہ وار بنائیں

```java
User user = new User.Builder()
    .name("Ann")
    .email("ann@x.com")
    .age(30)
    .build();    // readable construction; avoids huge telescoping constructors
```

## Strategy (behavioral) — قابل تبدیلی algorithms

```java
interface PaymentStrategy { void pay(double amount); }
class CreditCard implements PaymentStrategy { public void pay(double a) {...} }
class PayPal implements PaymentStrategy { public void pay(double a) {...} }

// swap behavior at runtime — lambdas make this trivial in modern Java
processor.setStrategy(new PayPal());
```

## Observer (behavioral) — publish/subscribe

```java
// subjects notify registered observers of changes (events, listeners)
button.addActionListener(e -> handleClick());   // GUI events use this everywhere
```

## Decorator (structural) — رویے کو شامل کرنے کے لیے لپیٹیں

```java
// Java's I/O streams ARE the decorator pattern:
BufferedReader r = new BufferedReader(new FileReader("f.txt"));
// BufferedReader wraps FileReader, adding buffering
```

## جہاں patterns Java میں خود ظاہر ہوتے ہیں

```text
Singleton  → Runtime.getRuntime()
Factory    → Calendar.getInstance(), DriverManager
Builder    → StringBuilder, Stream.Builder
Observer   → event listeners, java.util.Observer
Decorator  → java.io streams (BufferedReader wrapping FileReader)
Iterator   → the Iterator interface / Collections
Strategy   → Comparator, functional interfaces
```

## زیادہ استعمال سے احتیاط

```text
Patterns are tools, not goals. Applying them where they don't fit ADDS complexity.
Use them when they genuinely solve your problem — many can be simpler with lambdas now.
```

## یہ اہم کیوں ہے

Design patterns عام design مسائل کے لیے ایک مشترک لغت اور ثابت شدہ حل فراہم کرتے ہیں، جو بات چیت ("یہاں Strategy استعمال کریں")، موجودہ code میں ڈھانچے کو تسلیم کرنے، اور غلط حل دوبارہ ایجاد کرنے سے بچنے کے لیے قیمتی ہے۔

یہ Java کی اپنی libraries میں ظاہر ہوتے ہیں (I/O decorators، factory methods، builders، observer-based events)، اس لیے انہیں سمجھنا آپ کو standard library کو موثر طریقے سے استعمال اور بڑھانے میں مدد دیتا ہے۔

اہم patterns کو جاننا — Singleton، Factory، Builder، Strategy، Observer، Decorator — اور ہر ایک کہاں فٹ بیٹھتا ہے یہ تجربہ کار developers کی نشاندہی ہے اور ایک بار بار آنے والا انٹرویو موضوع ہے۔

بیک وقت اہم یہ فیصلہ کرنا ہے کہ انہیں مناسب طریقے سے لاگو کریں (حقیقی مسائل کو حل کریں) بجائے انہیں مجبور کرنے کے، خاص طور پر جب جدید خصوصیات جیسے lambdas بہت سے روایتی patterns کو سادہ بناتے ہیں۔