Java ਵਿੱਚ ਕਿਹੜੇ ਸਾਂਝੇ design patterns ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ?

Question

Accepted Answer

**Design patterns** ਰੀਯੂਜ਼ੇਬਲ ਹੱਲ ਹਨ ਜੋ ਆਵਰਤੀ software-design ਸਮੱਸਿਆਵਾਂ ਲਈ ਹਨ। Java ਦੀ OOP ਪ੍ਰਕਿਰਤੀ ਅਤੇ ਈਕੋਸਿਸਟਮ ਕਈ 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 creation ਨੂੰ encapsulate ਕਰੋ

```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) — interchangeable 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) — wrap ਕਰਕੇ behavior ਸ਼ਾਮਿਲ ਕਰੋ

```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
```

## Overuse ਦੇ ਖਿਲਾਫ ਸਾਵਧਾਨੀ

```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 ਦੇ ਆਪਣੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਵਾਪਰਦੇ ਹਨ (I/O decorators, factory methods, builders, observer-based events), ਇਸ ਲਈ ਇਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਨੂੰ standard library ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਵਰਤਣ ਅਤੇ ਸਮਰਥ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਮੁੱਖ patterns — Singleton, Factory, Builder, Strategy, Observer, Decorator — ਨੂੰ ਜਾਣਨਾ ਅਤੇ ਜਾਣਨਾ ਕਿ ਹਰੇਕ ਕਿੱਥੇ ਫਿੱਟ ਹੈ ਅਨੁਭਵੀ developers ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਅਤੇ ਇੱਕ ਵਾਰਵਾਰ interview ਵਿਸ਼ਾ ਹੈ।

ਸਮਾਨ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਇਹ ਨਿਰਣਾ ਹੈ ਕਿ ਉਹਨਾਂ ਨੂੰ appropriately ਲਾਗੂ ਕਰੋ (ਅਸਲ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰੋ) ਬਜਾਏ ਉਹਨਾਂ ਨੂੰ ਮਜਬੂਰ ਕਰਨ ਦੇ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਿਵੇਂ ਮਾਡਰਨ ਫੀਚਰਸ ਜਿਵੇਂ lambdas ਬਹੁਤ ਸਾਰੇ ਕਲਾਸਿਕ patterns ਨੂੰ ਸਰਲ ਬਣਾਉਂਦੇ ਹਨ।