Ce este modelul Adapter?

Question

Accepted Answer

Modelul **Adapter** permite obiectelor cu **interfețe incompatibile** să funcționeze împreună prin încapsularea uneia cu o interfață pe care o așteaptă cealaltă. Acționează ca un translator între două interfețe, permițând integrarea fără a modifica codul existent.

## Ce face modelul Adapter

```text
ADAPTER → convert one interface into another that a client expects (a "translator"):
  → wrap an object whose interface is INCOMPATIBLE, exposing the interface the client needs
  → the adapter translates calls/data between the two interfaces
→ makes incompatible things work together WITHOUT changing either's code
```

## Exemplu

```js
// a third-party library with an incompatible interface
class ThirdPartyLogger { logMessage(text) { /* ... */ } }

// our code expects a .log(msg) interface → adapt it
class LoggerAdapter {
  constructor(thirdParty) { this.logger = thirdParty; }
  log(msg) { this.logger.logMessage(msg); }   // translate our interface to theirs
}
const logger = new LoggerAdapter(new ThirdPartyLogger());
logger.log('hello');   // our code uses .log; the adapter calls .logMessage
```

## Utilizări și beneficii

```text
USES → integrate THIRD-PARTY libraries with incompatible interfaces; make legacy code work
  with new code; unify different APIs behind a common interface; swap implementations
BENEFITS:
  ✓ INTEGRATION → make incompatible interfaces work together without modifying either
  ✓ DECOUPLING → your code depends on YOUR interface; adapters isolate external/incompatible
    code → swap or upgrade dependencies behind the adapter
  ✓ Reuse existing code that doesn't quite fit
```

## De ce este important

Înțelegerea modelului Adapter este valoroasă deoarece este un **model structural foarte comun și practic** pentru integrarea codului incompatibil, deci este cunoaștere de proiectare relevantă.

Modelul Adapter permite obiectelor cu **interfețe incompatibile să funcționeze împreună** prin încapsularea uneia cu interfața pe care o așteaptă cealaltă — acționând ca un translator între interfețe.

Înțelegerea a ceea ce face (încapsularea unui obiect cu o interfață incompatibilă pentru a expune interfața pe care o necesită un client, traducerea între cele două) este cunoașterea de bază.

Înțelegerea **utilizărilor** este deosebit de valoroasă deoarece sunt nevoi comune și reale: **integrarea bibliotecilor terță parte** cu interfețe incompatibile (o situație frecventă — trebuie să folosiți o bibliotecă, dar interfața sa nu se potrivește codul dumneavoastră), făcerea **codului moștenit să funcționeze cu codul nou**, unificarea diferitelor API-uri în spatele unei interfețe comune, și permițând schimbul implementărilor.

Aceste nevoi de integrare apar constant în dezvoltare reală.

Înțelegerea **beneficiilor** — **integrarea** (făcerea interfețelor incompatibile să funcționeze împreună fără a modifica niciunul dintre ele, ceea ce este adesea necesar atunci când nu puteți schimba codul terță parte sau moștenit), și **decuplarea** (codul dumneavoastră depinzând de propria interfață, iar adapterii izolează codul extern/incompatibil, deci puteți schimba sau actualiza dependențe în spatele adaptorului — un beneficiu arhitectural valoros) — clarifică de ce Adapter este practic important.

Modelul Adapter este unul dintre cele mai practic utile modele deoarece integrarea codului incompatibil (biblioteci terță parte, sisteme moștenite, API-uri diferite) este o nevoie constantă și reală în dezvoltare.

Deoarece modelul Adapter este un model foarte comun și practic pentru integrarea interfețelor incompatibile (biblioteci terță parte, cod moștenit, API-uri diferite) fără a modifica niciunul — o nevoie constantă și reală — și oferă decuplare valoroasă, și deoarece înțelegerea a ceea ce face, utilizările și beneficiile sale este relevantă pentru munca de integrare reală, înțelegerea modelului Adapter este cunoaștere de proiectare valoroasă și practic relevantă — un model frecvent necesar pentru sarcina comună de a face cod diferit să funcționeze împreună, oferind integrare și decuplare, și cunoaștere de proiectare importantă pentru provocarea reală și recurentă de a face diferite bucăți de cod să funcționeze împreună.