Adapter (designmönster)/kodexempel- Huvudartikel: Adapter (designmönster) Ett exempel på en mönsterimplementering i C# med System; namnområdesadapter (klass MainApp ( static void Main() ( ... Wikipedia

Proxymönster (designmönster)

Design mönster- Denna term har andra betydelser, se Mönster. Inom mjukvaruutveckling är ett designmönster en repeterbar arkitektonisk design som representerar en lösning på ett problem... ... Wikipedia

Gränssnitt (designmönster)- Design mönster Gränssnitt Beskrivs i designmönster Nej Inom datavetenskap är ett gränssnittsmönster inte ett speciellt mönster bland designmönster. Det är en generell metod för strukturering datorprogram för det... Wikipedia

Suppleant (designmönster)- Proxymönster (ställföreträdande) Designmönster. Tillhandahåller ett åtkomstkontrollerande objekt som avlyssnar alla anrop till det. Innehåll 1 Mål 1.1 Uppgift 1.2 Lösning 2 Fördelar 3 ... Wikipedia

Guardian (designmönster)- Design Pattern Guardian Memento Typ: Beteende Beskrivs i designmönster Ja Guardian (även känd som Memento, Token, Token) är ett beteendedesignmönster. Låter dig fixa utan att bryta inkapslingen... Wikipedia

Iterator (designmönster)- Designmönster Iterator Iterator Typ: beteende Beskrivs i designmönster Ja Iteratormönster (även känd som markör) Ett designmönster som refererar till beteendemönster. Det är ett objekt som låter dig få ... Wikipedia

Tolk (designmönster)- Designmönster Tolk Typ: beteende Syfte: löser ett ofta förekommande, förändringsbenäget problem Beskrivet i Designmönster Ja Tolkmönster (engelska ... Wikipedia

Linker (designmönster)- Designmönster Komposittyp: strukturell Beskrivs i designmönster Ja Kompositmönster är ett designmönster, hänvisar till strukturella mönster, kombinerar ett objekt ... Wikipedia

Tillstånd (designmönster)- Tillståndsdesignmönster Typ: beteende Beskrivs i designmönster Ja Tillstånd är ett designmönster. Det används i de fall där, under programkörning, ett objekt ... Wikipedia

Huvudartikel: Adapter (designmönster) Exempelimplementering av mönstret i C# med hjälp av System; namnområdesadapter (klass MainApp ( static void Main() ( ... Wikipedia

Denna term har andra betydelser, se Mönster. Inom mjukvaruutveckling är ett designmönster en repeterbar arkitektonisk design som representerar en lösning på ett problem... ... Wikipedia

Gränssnittsdesignmönster Gränssnitt som beskrivs i designmönster Nej Inom datavetenskap är gränssnittsmönstret inte ett speciellt mönster bland designmönster. Det är en allmän metod för att strukturera datorprogram för att... Wikipedia

Proxy mönster design mönster. Tillhandahåller ett åtkomstkontrollerande objekt som avlyssnar alla anrop till det. Innehåll 1 Mål 1.1 Uppgift 1.2 Lösning 2 Fördelar 3 ... Wikipedia

Designmönster Guardian Memento Typ: Beteende Beskrivs i designmönster Ja Guardian (även känd som Memento, Token, Token) är ett beteendedesignmönster. Låter dig fixa utan att bryta inkapslingen... Wikipedia

Designmönster Iterator Iterator Typ: Beteende Beskrivs i designmönster Ja Iteratormönster (även känd som markör) Ett designmönster som refererar till beteendemönster. Det är ett objekt som låter dig få ... Wikipedia

Designmönster Tolk Typ: beteende Syfte: löser ett ofta förekommande, förändringsbenäget problem Beskrivet i Designmönster Ja Tolkmönster (engelska ... Wikipedia

Designmönster Komposittyp: strukturell Beskrivs i designmönster Ja Kompositmönster är ett designmönster, hänvisar till strukturella mönster, kombinerar ett objekt ... Wikipedia

Designmönster Tillstånd Typ: beteende Beskrivs i designmönster Ja Tillstånd är ett designmönster. Det används i de fall där, under programkörning, ett objekt ... Wikipedia

Innan du läser, vänligen granska följande konventioner och koncept. Den här artikeln uppdateras med viss frekvens, så om du har läst den tidigare är det inte ett faktum att uppgifterna inte har ändrats.

Adapter tillhör klassen strukturell mönster. Det används för att konvertera ett gränssnitt till ett annat som krävs av klienten. Adaptern säkerställer kompatibilitet för inkompatibla gränssnitt genom att implementera ett lager.

Funktionsprincip

Adaptern ärver målgränssnittet på ett öppet sätt (låt oss kalla det Mål), och ett slutet anpassningsbart gränssnitt ( Adaptee). Vid implementeringen av målgränssnittsmetoderna omdirigeras (delegeras) förfrågningar till en klass med ett anpassningsbart gränssnitt

Exempel

// Målgränssnitt, klienten kan bara arbeta med dets gränssnitt iTarget ( public function query(); ) // Anpassningsbart gränssnitt. Klienten vet inte hur man arbetar med det, men vill verkligen ha gränssnittet iAdaptee ( public function request(); ) // En klass som implementerar en anpassningsbar gränssnittsklass Adaptee implementerar iAdaptee ( public function request() ( return __CLASS__ . ":: " . __METHOD__; ) ) klass Adapter implementerar iTarget ( skyddad $adaptee = null; offentlig funktion __construct() ( $this -> adaptee = new Adaptee(); ) public function query() ( return $this -> adaptee -> request (); ) ) $ Target = new Adapter(); print $Target -> query(); // "Adaptee::request"

Slutsats

En adapter kan anpassa flera gränssnitt till ett samtidigt, detta mönster kallas objektadapter Användningen av detta mönster är motiverat i flera fall. Om du vill använda en befintlig klass med ett annat gränssnitt. Om du ska använda det anpassningsbara gränssnittet på flera ställen, och inte har möjlighet att få det att se likadant ut överallt, så kan det vara en bra idé att använda utbytbara adaptrar.

Syftet med adaptermönstret

Ofta i nytt mjukvaruprojekt Det går inte att återanvända befintlig kod. Till exempel kan befintliga klasser ha önskad funktionalitet, men har inkompatibla gränssnitt. I sådana fall bör du använda adaptermönstret.

Adaptermönstret, som är ett mjukvaruomslag över befintliga klasser, omvandlar deras gränssnitt till en form som lämpar sig för efterföljande användning.

Låt oss titta på ett enkelt exempel på när adaptermönstret ska användas. Låt oss utveckla ett klimatkontrollsystem utformat för att automatiskt hålla omgivningstemperaturen inom specificerade gränser. En viktig komponent Ett sådant system är en temperatursensor, med vilken den omgivande temperaturen mäts för efterföljande analys. För denna sensor finns det redan en färdig programvara från tredjepartsutvecklare, vilket är en klass med lämpligt gränssnitt. Du kan dock inte använda denna klass direkt, eftersom sensoravläsningarna tas i grader Fahrenheit. Du behöver en adapter som omvandlar temperaturen till Celsius.

Kö-, priority_queue- och stackbehållarna i standard-STL-mallbiblioteket implementeras på basis av den sekventiella listan, deque- och vektorbehållaren, och anpassar deras gränssnitt till den önskade formen. Det är därför dessa behållare kallas adapterbehållare.

Beskrivning av adaptermönstret

Låt klassen vars gränssnitt behöver anpassas till önskad form få namnet Adaptee. För att lösa problemet med att transformera dess gränssnitt introducerar adaptermönstret följande klasshierarki:

• Mål virtuell basklass. Meddelas här användargränssnitt lämplig typ. Endast detta gränssnitt är tillgängligt för användaren.
• En härledd klass av Adapter som implementerar Target-gränssnittet. Den här klassen innehåller också en pekare eller referens till en Adaptee-instans. Adaptermönstret använder den här pekaren för att vidarebefordra klientsamtal till Adaptee. Eftersom Adaptee- och Target-gränssnitten är inkompatibla med varandra kräver dessa samtal vanligtvis konvertering.

Implementering av adaptermönstret

Klassisk implementering av adaptermönstret

Här är en implementering av adaptermönstret. För exemplet ovan anpassar vi avläsningarna för temperatursensorn i klimatkontrollsystemet och konverterar dem från grader Fahrenheit till grader Celsius (det antas att koden för denna sensor inte är tillgänglig för modifiering).

#omfatta // Redan befintlig miljötemperatursensor klass klass FahrenheitSensor ( offentlig: // Få temperaturavläsningar i Fahrenheit float getFahrenheitTemp() ( float t = 32.0; // ... någon kod returnerar t; ) ); class Sensor ( offentlig: virtuell ~Sensor() () virtuell flytande getTemperature() = 0; ); klass Adapter: public Sensor ( public: Adapter(FahrenheitSensor* p) : p_fsensor(p) ( ) ~Adapter() ( ta bort p_fsensor; ) float getTemperature() (retur (p_fsensor->getFahrenheitTemp()-32.0)*5.0/9.0 ; ) privat: FahrenheitSensor* p_fsensor; ); int main() (Sensor* p = ny Adapter(ny FahrenheitSensor); cout<< "Celsius temperature = " << p->getTemperature()<< endl; delete p; return 0; }

Implementering av adaptermönstret baserat på slutet arv

Låt vårt klimatkontrollsystems temperatursensor stödja justeringsfunktionen för mer exakta avläsningar. Denna funktion behöver inte användas, vilket förmodligen är anledningen till att motsvarande adjust()-metod förklaras skyddad av utvecklarna i den befintliga FahrenheitSensor-klassen.

Systemet vi utvecklar måste stödja mätanpassning. Eftersom åtkomst till en skyddad metod via en pekare eller länk är förbjuden är den klassiska implementeringen av adaptermönstret inte längre lämplig här. Den enda lösningen är att ärva från FahrenheitSensor-klassen. Gränssnittet för denna klass måste förbli otillgängligt för användaren, så arvet måste vara privat.

De mål som eftersträvas när man använder öppet och slutet arv är olika. Medan öppet arv används för gränssnitt och implementeringsarv, används stängt arv endast för implementeringsarv.

#omfatta class FahrenheitSensor ( public: float getFahrenheitTemp() ( float t = 32.0; // ... return t; ) protected: void adjust() () // Justera sensorn (skyddad metod) ); class Sensor ( offentlig: virtuell ~Sensor() () virtuell flytande getTemperature() = 0; virtuell void justera() = 0; ); class Adapter: public Sensor, private FahrenheitSensor ( public: Adapter() ( ) float getTemperature() (retur (getFahrenheitTemp()-32.0)*5.0/9.0; ) void adjust() ( FahrenheitSensor::adjust(); ) ); int main() ( Sensor * p = new Adapter(); p->adjust(); cout<< "Celsius temperature = " << p->getTemperature()<< endl; delete p; return 0; }

Resultat av applicering av adaptermönstret

Fördelar med adaptermönstret

• Adaptermönstret låter dig återanvända befintlig kod genom att anpassa dess inkompatibla gränssnitt till en användbar form.

Nackdelar med adaptermönstret

• Uppgiften att konvertera gränssnitt kan vara svår om klientanrop och/eller skickade parametrar inte har en funktionell överensstämmelse i objektet som anpassas.

Hej alla! Idag ska vi prata om Designmönster för mönsteradapter. Som namnet antyder tjänar det till att säkerställa att något anpassa, men vad? Och den här artikeln kommer att svara på den här frågan för dig.

Beskrivning av adapterns designmönster

Låt oss gå lite bort från programmering och titta på adaptrar I verkligheten. Till exempel har du köpt en del utrustning (till exempel en dator) utomlands. När du kom hem med den upptäckte du att kontakten av en annan standard inte passade i vårt ryska uttag. Vad ska man göra? Höger! Du måste gå till affären och köpa adapter, med hjälp av vilken du kan ansluta din dator till nätverket. Alltså den här adapter och där är adapter. Vi sätter in en främmande kontakt i den och ansluter själva adaptern till nätverket och allt fungerar utmärkt. De där. det tjänar helt enkelt lager mellan vårt uttag och främmande kontakt.

Så jag tror att du har förstått det vad är en adapter i livet. I programmering är det samma sak.

Exempel på adapterimplementering i PHP

gränssnitt iMain (
public function send();
}

Interface iAdaptee (
offentlig funktionsutredning();
}

Klass Adaptee implementerar iAdaptee (
public function enquiry() (
returnera __KLASS__."::".__METHOD__;
}
}

Klassadapter implementerar iMain (
skyddad $adaptee = null;

Offentlig funktion __construct() (
$this->adaptee = new Adaptee();
}

Public function send() (
returnera $this->adaptee->inquiry();
}
}

$goal = new Adapter();
echo $goal->send(); // "Adaptee::förfrågan"
?>

Så här är vår kod. Låt oss ta reda på det. Vi har ett gränssnitt iMain, kan klientkoden fungera med den. Därefter har vi gränssnittet iAdaptee, som klientkoden inte kan fungera med, men vi måste på något sätt interagera med den. Sen har vi klass Adaptee iAdaptee och inuti den har en metod som kallas förfrågan, som helt enkelt returnerar en sträng som KLASS::METOD. Här kommer vi till klassen Adapter, som ärver gränssnittet iMain. Inuti den skapar vi en skyddad egendom anpassad, likvärdig null. Därefter skapar vi ett klassobjekt i konstruktorn Adaptee och skriv det till vår skyddade egendom. I metod skicka vi returnerar metodanropet förfrågan.

Det är allt. Nu skapar vi vårt adapterobjekt och anropar metoden skicka.

De där. hela poängen är att vi kan arbeta med ett gränssnitt, men inte med ett annat, och för att på något sätt interagera med detta gränssnitt som är otillgängligt för oss skapar vi adapter, ett lager genom vilket vi genomför vår uppgift.

Slutsats

Nu kan det tyckas för dig att allt är väldigt komplicerat och svårt, men det är inte så. Jag tror att du förstår innebörden av adaptern, men nu behöver du mer övning. Ta en titt på koden som ges i den här artikeln igen och försök förstå det. Gå igenom det rad för rad och recitera det som om du vore en tolk php. Jag råder dig också att titta på koden för något ramverk, eftersom den här mallen används där ganska ofta.

Detta avslutar denna ganska långa artikel, tack för din uppmärksamhet!