Gränssnitt (objektorienterad programmering)

Interface ( English  interface ) - en program/syntaxstruktur som definierar en relation med objekt som förenas endast av något beteende. När du designar klasser är design av ett gränssnitt detsamma som att designa en specifikation (den uppsättning metoder som varje klass som använder ett gränssnitt måste implementera).

Gränssnitt, tillsammans med abstrakta klasser och protokoll, etablerar ömsesidiga skyldigheter mellan elementen i ett mjukvarusystem, vilket är grunden för konceptet programmering genom kontrakt ( Eng.  design by contract , DbC). Ett gränssnitt definierar en interaktionsgräns mellan klasser eller komponenter genom att specificera en viss abstraktion som en implementerare implementerar.

Gränssnittet i OOP är ett strikt formaliserat element i ett objektorienterat språk och används flitigt i källkoden för program.

Gränssnitt tillåter multipelt arv av objekt och löser samtidigt problemet med diamantformat arv . I C++-språket löses det genom klassarv med hjälp av virtual.

Beskrivning och användning av gränssnitt

Beskrivningen av ett OOP-gränssnitt, förutom detaljerna om syntaxen för specifika språk, består av två delar: namnet och metoderna för gränssnittet.

• Gränssnittsnamnet är byggt enligt samma regler som andra identifierare för det programmeringsspråk som används. Olika språk och utvecklingsmiljöer har olika kodningskonventioner, enligt vilka gränssnittsnamn kan bildas enligt vissa regler som hjälper till att skilja gränssnittsnamnet från namnen på andra programelement. Till exempel, i COM -teknik och på alla språk som stöder den, finns det en konvention, efter vilken gränssnittsnamnet är byggt enligt I<Имя>mönstret " ", det vill säga det består av ett meningsfullt namn skrivet med stor bokstav , föregås av en stor latinsk bokstav I( IUnknown, IDispatch, IStringListetc.) .
• Gränssnittsmetoder . Beskrivningen av gränssnittet definierar namnen och signaturerna för de metoder som ingår i det, det vill säga klassens procedurer eller funktioner.

Gränssnitt kan användas på två sätt:

• En klass kan implementera ett gränssnitt. Implementeringen av gränssnittet är att i klassbeskrivningen indikeras detta gränssnitt som implementerat, och i klasskoden är alla metoder som beskrivs i gränssnittet nödvändigtvis definierade i full överensstämmelse med signaturerna från beskrivningen av detta gränssnitt. Det vill säga, om en klass implementerar ett gränssnitt, för någon instans av denna klass, finns alla metoder som beskrivs i gränssnittet och kan anropas. En klass kan implementera flera gränssnitt samtidigt.
• Det är möjligt att deklarera variabler och metodparametrar som att de har typen "gränssnitt". En instans av vilken klass som helst som implementerar gränssnittet kan skrivas till en sådan variabel eller parameter. Om ett gränssnitt deklareras som returtyp för en funktion betyder det att funktionen returnerar ett objekt av klassen som implementerar det givna gränssnittet.

Som regel, i objektorienterade programmeringsspråk, kan gränssnitt, som klasser, ärvas från varandra. I det här fallet inkluderar det underordnade gränssnittet alla metoder för förfadergränssnittet och lägger eventuellt till sina egna metoder till dem.

Således är ett gränssnitt å ena sidan ett "kontrakt" som klassen som implementerar det åtar sig att uppfylla, å andra sidan är ett gränssnitt en datatyp, eftersom dess beskrivning tydligt nog definierar egenskaperna hos objekt för att kunna skriva in variabler på lika villkor med klassen. Det bör dock betonas att ett gränssnitt inte är en komplett datatyp, eftersom det bara definierar objektens yttre beteende. Den interna strukturen och implementeringen av beteendet som specificeras av gränssnittet tillhandahålls av klassen som implementerar gränssnittet; det är därför det inte finns några "gränssnittsinstanser" i dess rena form, och varje variabel av typen "gränssnitt" innehåller instanser av konkreta klasser.

Användningen av gränssnitt är ett alternativ för att tillhandahålla polymorfism i objektspråk och miljöer. Alla klasser som implementerar samma gränssnitt, i termer av beteendet de definierar, beter sig på samma sätt externt. Detta låter dig skriva generaliserade databehandlingsalgoritmer som använder gränssnittsparametrar som typer och applicera dem på objekt av olika typer, varje gång du får det önskade resultatet.

Till exempel kan " "-gränssnittet Cloneablebeskriva abstraktionen av kloning (skapa exakta kopior) av objekt genom att specificera en metod " Clone" som ska kopiera innehållet i ett objekt till ett annat objekt av samma typ. Då måste alla klasser vars objekt kan behöva kopieras implementera gränssnittet Cloneableoch tillhandahålla en metod Clone, och var som helst i programmet där objektkloning krävs anropas metoden på objektet för detta ändamål Clone. Dessutom behöver koden som använder denna metod bara ha en beskrivning av gränssnittet, den kanske inte vet något om den faktiska klassen vars objekt kopieras. Således tillåter gränssnitt dig att dela upp ett mjukvarusystem i moduler utan ömsesidigt kodberoende.

Gränssnitt och abstrakta klasser

Det kan ses att ett gränssnitt, från en formell synvinkel, bara är en ren abstrakt klass , det vill säga en klass där ingenting är definierat förutom abstrakta metoder . Om ett programmeringsspråk stöder flera nedärvnings- och abstrakta metoder (som till exempel C++ ), så finns det inget behov av att införa ett separat koncept för "gränssnitt" i språkets syntax. Dessa entiteter beskrivs med hjälp av abstrakta klasser och ärvs av klasser för att implementera abstrakta metoder.

Att stödja multipelarv i sin helhet är dock ganska komplicerat och orsakar många problem, både på språkimplementeringsnivån och på applikationsarkitekturnivån. Introduktionen av konceptet med gränssnitt är en kompromiss som gör att du kan få många av fördelarna med multipelt arv (särskilt förmågan att bekvämt definiera logiskt relaterade uppsättningar av metoder som klassliknande enheter som tillåter arv och implementering), utan att implementera den i sin helhet och därmed utan att stöta på de flesta av de svårigheter som är förknippade med den.

På exekveringsnivån orsakar det klassiska schemat med multipelt arv ytterligare ett antal olägenheter:

• om ett objekt kan ärva n klasser parallellt, finns det n oberoende sätt att komma åt det, vilket betyder att det måste finnas (n - 1) ytterligare pekare till det; ur synvinkeln för automatisk minneshantering kommer detta att innebära att det finns referenser som pekar mot mitten av objektet;
• stöd för virtuella anrop innebär att objektet lagrar en referens till sin virtuella tabell , och i fallet med flera arv, n referenser; aktiv användning av multipelt arv kommer att avsevärt öka mängden minne som upptas av varje objekt (instans).

Att använda ett schema med gränssnitt (istället för multipelt arv) undviker dessa problem, förutom frågan om anrop av gränssnittsmetoder (det vill säga virtuella metodanrop i multipelt arv, se ovan). Den klassiska lösningen är (till exempel i JVM för Java eller CLR för C#) att gränssnittsmetoder anropas på ett mindre effektivt sätt, utan hjälp av en virtuell tabell: med varje anrop bestäms först en specifik objektklass, och sedan söks den önskade metoden i den (naturligtvis med många optimeringar).

Flera arvs- och gränssnittsimplementeringar

Vanligtvis tillåter programmeringsspråk att ett gränssnitt ärvs från flera förfädersgränssnitt. Alla metoder som deklareras i förfädersgränssnitt blir en del av deklarationen av det underordnade gränssnittet. Till skillnad från klassarv är multipel nedärvning av gränssnitt mycket lättare att implementera och orsakar inga betydande svårigheter.

En kollision med flera arv av gränssnitt och med implementering av flera gränssnitt av en klass är dock fortfarande möjlig. Det inträffar när två eller flera gränssnitt ärvt av ett nytt gränssnitt eller implementerat av en klass har metoder med samma signatur. Utvecklare av programmeringsspråk tvingas välja för sådana fall vissa metoder för att lösa motsägelser. Det finns flera alternativ här: ett förbud mot implementering, en explicit indikation på en specifik, och en implementering av basgränssnittet eller klassen.

• Förbjuda. I en klass är det helt enkelt förbjudet att implementera flera gränssnitt som har metoder med samma signaturer. Om en klass kräver en kombination av inkompatibla gränssnitt måste programmeraren välja ett annat sätt att lösa problemet, till exempel separera flera klasser, som var och en implementerar ett av de nödvändiga gränssnitten, och använda deras instanser tillsammans.
• Explicit disambiguation. Om kompilatorn upptäcker en kollision måste programmeraren uttryckligen ange vilken gränssnittsmetod han implementerar och anropar. Det vill säga, metoder med samma namn implementeras separat, och när de anropas anges vilken av dem som kallas. När man anropar metoder med samma namn genom en variabel av typen "gränssnitt" uppstår ingen tvetydighet om gränssnittet som används som variabeltyp endast har en metod med det angivna namnet. En variant av denna lösning är explicit namnbyte för ärvda eller implementerade metoder som har samma namn, vilket gör att det inte finns några metoder med samma namn inom den implementerande klassen, men när de nås via gränssnittet anropas alltid den önskade implementeringen.
• Allmän implementering av metoder med samma namn. Om flera metoder med samma signatur ärvs eller implementeras, kombineras de i arvsgränssnittet, och i implementeringsklassen får de en gemensam implementering. Detta är väl lämpat för fall där metoder med samma namn på olika gränssnitt är identiska i avsedd funktionalitet, men kan orsaka oönskade effekter om beteendet hos dessa metoder skulle vara olika.

Gränssnitt i specifika språk och system

Implementeringen av gränssnitt bestäms till stor del av språkets initiala kapacitet och syftet med vilket gränssnitt introduceras i det. Funktionerna med att använda gränssnitt i Java , Object Pascal , Delphi och C++ är mycket vägledande , eftersom de visar tre fundamentalt olika situationer: språkets initiala orientering för att använda konceptet med gränssnitt, deras användning för kompatibilitet och deras emulering av klasser.

• I Java ingår gränssnitt initialt i språket, och är en integrerad del av det.
• Det fanns inga gränssnitt i objektundersystemet för Object Pascal-språket; deras stöd introducerades i Delphi 2 för att säkerställa skrivning och användning av COM-komponenter. Följaktligen är Delphi-gränssnittsmekanismen främst inriktad på användningen av COM-teknik.
• Strängt taget finns det inga gränssnitt i C++ alls. En mekanism som är analog med (och historiskt före) gränssnitt implementeras på andra sätt av språkets extremt kraftfulla objektsubsystem.

Delphi

Gränssnitt introducerades i Delphi för att stödja Microsofts COM - teknik . Men när Kylix släpptes frikopplades gränssnitt som en del av språket från COM-teknik. Alla gränssnitt ärver från gränssnittet [1] , som på win32-plattformen är detsamma som standard COM-gränssnittet med samma namn, precis som alla klasser i det är ättlingar till klassen . Den explicita användningen av IUnknown som en förfader är reserverad för kod som använder COM-teknik. IInterface IUnknownTObject

Exempel på gränssnittsdeklaration: