X'inhi l-mudelli ta' disinn komuni f'Java?

Question

Accepted Answer

**Mudelli ta' disinn** huma soluzzjonijiet li jistgħu jad-diġitali għal problemi ta' disinn ta' softwer li jirrikorrenti. In-natura OOP ta' Java u l-ekosistema tagħha jagħmlu diversi mudelli partikolarment komuni — it-tgħallim tagħhom jgħinek tgħarraf, tikomunika, u tapplika strutturi proven. Huma jaqsmu f'kategoriji ta' kreazzjoni, strutturali, u ta' imġiba.

## Singleton (kreazzjoni) — istanza waħda maqsuma

```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 (kreazzjoni) — inkapsulat il-ħolqien tal-oġġetti

```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 (kreazzjoni) — ibni l-oġġetti kumplessi pass għal pass

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

## Strategy (imġiba) — algoritmi li jistgħu jissostitwu

```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 (imġiba) — ippubblika/issottoskrivi

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

## Decorator (strutturali) — jappakkan biex iżżid imġiba

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

## Fejn jidher il-mudelli f'Java nnifsu

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

## Twissija kontra l-ġarr doppju

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

## Għaliex huwa importanti

Il-mudelli ta' disinn jipprovdu vokabolariu kondiviż u soluzzjonijiet proven għal problemi ta' disinn komuni, li huwa valuwuż għall-komunikazzjoni ("uża Strateġija hawn"), taʻrif ta' strutturi f'kodiċi eżistenti, u evitament ta' rinvenzzjoni ta' soluzzjonijiet difettuż.

Huma jidħru fuq il-librerija standard ta' Java (dekoratori I/O, metodi tal-faċċata, bennejja, avvenimenti bbażati fuq l-osservatur), għaldaqstant il-fehim tagħhom jgħinek tuża u testendi l-librerija standard b'mod effettiv.

It-tgħallum tal-mudelli prinċipali — Singleton, Factory, Builder, Strategy, Observer, Decorator — u fejn kull wieħed jifit huwa sinjal ta' sviluppatur esperjenzat u suġġett ta' intervista frekwenti.

Egwalment importanti huwa l-ħakma li japplika b'mod xieraq (soluzzjoni ta' problemi reali) minflok ma' jforzawhom, speċjalment billi l-features moderni bħal lambdas jissimplifikaw ħafna mudelli klassiċi.