Waɗannan shine nau'in tsarin ƙira da aka saba da jiya a Java?

Question

Accepted Answer

**Nau'in tsarin ƙira** su ne mafi amfani mafita ga matsalolin nau'in tsarin software da aka saba da jiya. Yanayin OOP na Java da kuma ecology din sa suna mai yawa nau'in tsarin - sanin su yana taimakawa ka fahimta, saida, da amfani da nau'i da aka tabbatar. Suna faɗi cikin kategori na ƙirewa, gida, da hali.

## Singleton (ƙirewa) — daya lakabjiji

```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 (ƙirewa) — tattare da samarrwa

```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 (ƙirewa) — gina abubuwa masu rikitarwa ta wayo

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

## Strategy (hali) — ilimin 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 (hali) — wallafal/daidaita

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

## Decorator (gida) — lulluɓe don ƙara hali

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

## Inda nau'in tsarin ya bayyana a Java kanta

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

## Gargajiya akan wuce gida

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

## Me ya sa yana mahimmanci

Nau'in tsarin ƙira suna bayar da alaƙa da jiya mafita ga matsalolin ƙira na jiya, wanda ke da muhimmanci don saida ("yi amfani da Strategy a nan"), fahimta nau'i a cikin code da ake yin, da kuma suzuwa sake ƙirewa mafi laifi.

Suna bayyana a cikin dakunan Java kanta (I/O masu ƙira, ƙira hanyoyi, gidaje, abubuwa da aka kira observer), don haka fahimta su yana taimakawa ka yi amfani da kuma ƙara dakunan standard a inganci.

Sanin manyan nau'in — Singleton, Factory, Builder, Strategy, Observer, Decorator — da kuma sanin inda kowanne ya zo shine siffa na masu ƙirewa da ƙwararru da kuma aiki da aka saba.

Ya daidaita ma lura in yi amfani da su a inganci (barin matsaloli na gaske) maimakon tilasta su, musamman lokacin da fasalissai na zamani kamar lambdas suka sauki da yawa nau'in tsarin da baje baje.