Wat is precies het verschil tussen een interface en een abstracte klasse?
Een interface is een contract: De persoon die de interface schrijft zegt, "hey, ik accepteer dat dingen er zo uitzien", en de persoon die de interface gebruikt zegt "OK, de klasse die ik schrijf ziet er zo uit".
Een interface is een leeg omhulsel. Er zijn alleen de handtekeningen van de methoden, wat impliceert dat de methoden geen lichaam hebben. De interface kan'niets doen. Het'is gewoon een patroon.
Bijvoorbeeld (pseudo code):
// I say all motor vehicles should look like this:
interface MotorVehicle
{
void run();
int getFuel();
}
// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{
int fuel;
void run()
{
print("Wrroooooooom");
}
int getFuel()
{
return this.fuel;
}
}
Het implementeren van een interface verbruikt heel weinig CPU, omdat het geen klasse is, alleen een stel namen, en daarom is er geen dure look-up te doen. Het is geweldig als het belangrijk is, zoals in ingebedde apparaten.
Abstracte klassen zijn, in tegenstelling tot interfaces, klassen. Ze zijn duurder in gebruik, omdat er een look-up gedaan moet worden wanneer je ervan erft.
Abstracte klassen lijken veel op interfaces, maar ze hebben iets meer: Je kunt er een gedrag voor definiëren. Het gaat er meer om dat iemand zegt: "deze klassen moeten er zo uitzien, en ze hebben dat gemeen, dus vul de lege plekken in!".
Bijvoorbeeld:
// I say all motor vehicles should look like this:
abstract class MotorVehicle
{
int fuel;
// They ALL have fuel, so lets implement this for everybody.
int getFuel()
{
return this.fuel;
}
// That can be very different, force them to provide their
// own implementation.
abstract void run();
}
// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
void run()
{
print("Wrroooooooom");
}
}
Hoewel abstracte klassen en interfaces verondersteld worden verschillende concepten te zijn, maken de implementaties die bewering soms onwaar. Soms zijn ze zelfs niet wat je denkt dat ze zijn.
In Java wordt deze regel sterk gehandhaafd, terwijl in PHP, interfaces abstracte klassen zijn zonder gedeclareerde methode.
In Python zijn abstracte klassen meer een programmeertrucje dat je uit de ABC-module kunt halen en is eigenlijk het gebruik van metaclasses, en dus klassen. En interfaces hebben meer te maken met duck typing in deze taal en het'is een mix tussen conventies en speciale methodes die descriptors aanroepen (de \method_methodes).
Zoals gebruikelijk met programmeren is er theorie, praktijk, en praktijk in een andere taal :-)
Een uitleg is hier te vinden: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm
Een abstracte klasse is een klasse die slechts gedeeltelijk geïmplementeerd is door de programmeur. Hij kan een of meer abstracte methodes bevatten. Een abstracte methode is gewoon een functiedefinitie die dient om de programmeur te vertellen dat de methode moet worden geïmplementeerd in een child klasse.
Een interface is vergelijkbaar met een abstracte klasse; inderdaad interfaces bezetten de dezelfde namespace als klassen en abstracte klassen. Om die reden, kunt u geen een interface definiëren met dezelfde naam als een klasse. Een interface is een volledig abstracte klasse; geen van zijn methoden zijn geïmplementeerd en in plaats van een klasse ervan te subklassen, wordt er gezegd dat ze die interface te implementeren.
Hoe dan ook, ik vind deze uitleg van interfaces enigszins verwarrend. Een meer gebruikelijke definitie is: An interface defines a contract that implementing classes must fulfil. Een interface definitie bestaat uit signatures van publieke leden, zonder enige implementatie code.
Niet echt het antwoord op de oorspronkelijke vraag, maar zodra je het antwoord hebt op het verschil tussen beide, kom je in het wanneer-te-gebruiken dilemma: https://stackoverflow.com/questions/1231985/when-to-use-interfaces-or-abstract-classes-when-to-use-both
Ik'heb beperkte kennis van OOP, maar interfaces zien als een equivalent van een bijvoeglijk naamwoord in de grammatica heeft tot nu toe voor mij gewerkt (corrigeer me als deze methode onzin is!). Bijvoorbeeld, interface namen zijn als attributen of mogelijkheden die je aan een klasse kunt geven, en een klasse kan er veel van hebben: ISerializable, ICountable, IList, ICacheable, IHappy, ....