Verschil tussen abstracte klasse en interface in Java

Verschil tussen Abstracte Klasse en Interface is een veelgestelde vraag tijdens sollicitatiegesprekken. Abstracte klasse en Interface vormen een kernonderdeel van de Java-programmeertaal. Of je nu een interface of een abstracte klasse moet kiezen, is een ontwerpbeslissing waarmee elke architect te maken krijgt. In mijn laatste artikelen heb ik zoveel mogelijk details gegeven over Java-interface en abstracte klasse. In deze post zullen we het verschil tussen abstracte klasse en interface leren, en wanneer we interface boven de abstracte klasse moeten gebruiken en vice versa.

Verschil tussen Abstracte Klasse en Interface

1. abstract-sleutelwoord wordt gebruikt om een abstracte klasse te maken en kan ook worden gebruikt met methoden, terwijl interface-sleutelwoord wordt gebruikt om een interface te creëren en kan niet worden gebruikt met methoden.
2. Onderklassen gebruiken het extends-sleutelwoord om een abstracte klasse uit te breiden en ze moeten implementatie bieden voor alle gedeclareerde methoden in de abstracte klasse, tenzij de onderklasse ook een abstracte klasse is, terwijl onderklassen het implements-sleutelwoord gebruiken om interfaces te implementeren en ze moeten implementatie bieden voor alle methoden die in de interface zijn gedeclareerd.
3. Abstracte klassen kunnen methoden hebben met implementaties, terwijl een interface absolute abstractie biedt en geen methodenimplementaties kan hebben. Merk op dat vanaf Java 8 we standaard- en statische methoden kunnen creëren in een interface die de methodenimplementaties bevat.
4. Abstracte klassen kunnen constructeurs hebben, maar interfaces kunnen geen constructeurs hebben.
5. Abstracte klassen hebben alle functies van een normale Java-klasse, behalve dat we deze niet kunnen instantiëren. We kunnen het sleutelwoord abstract gebruiken om een klasse abstract te maken, maar interfaces zijn een volledig ander type en kunnen alleen openbare statische definitieve constanten en methodedeclaraties hebben.
6. Methoden van abstracte klassen kunnen toegangsmodificatoren hebben zoals openbaar, privé, beschermd, statisch, maar methoden van interfaces zijn impliciet openbaar en abstract, we kunnen geen andere toegangsmodificatoren gebruiken bij methoden van interfaces.
7. A subclass can extend only one abstract class but it can implement multiple interfaces.
8. Abstracte klassen kunnen andere klassen uitbreiden en interfaces implementeren, maar een interface kan alleen andere interfaces uitbreiden.
9. We kunnen een abstracte klasse uitvoeren als deze de methode main() heeft, maar we kunnen geen interface uitvoeren omdat ze geen implementatie van de hoofdmethode kunnen hebben.
10. Interfaces worden gebruikt om contracten voor de subklassen te definiëren, terwijl abstracte klassen ook contracten definiëren, maar ze kunnen ook andere methodenimplementaties bieden voor subklassen om te gebruiken.

Dat is alles voor het verschil tussen een interface en abstracte klassen, laten we nu verder gaan om te begrijpen wanneer we een interface boven een abstracte klasse moeten gebruiken en vice versa.

Interface of Abstracte Klasse

Of het kiezen tussen een interface of abstracte klasse voor het leveren van een contract voor subklassen een ontwerpbepaling is en afhangt van vele factoren. Laten we eens kijken wanneer interfaces de beste keuze zijn en wanneer we abstracte klassen kunnen gebruiken.

1. Java ondersteunt geen meervoudige klassenniveau-erfenis, zodat elke klasse slechts één superklasse kan uitbreiden. Maar een klasse kan meerdere interfaces implementeren. Dus zijn interfaces meestal een goede keuze om de basis te bieden voor klassenhiërarchie en contracten. Ook is coderen in termen van interfaces een van de beste praktijken voor coderen in Java.
2. Als er veel methoden in het contract zijn, is een abstracte klasse nuttiger omdat we een standaardimplementatie kunnen bieden voor sommige van de methoden die gemeenschappelijk zijn voor alle subklassen. Ook kunnen subklassen, als ze een bepaalde methode niet hoeven te implementeren, de implementatie vermijden. Maar in het geval van een interface moet de subklasse de implementatie voor alle methoden bieden, zelfs als deze niet wordt gebruikt en de implementatie slechts een leeg blok is.
3. Als ons basiscontract voortdurend verandert, kunnen interfaces problemen veroorzaken omdat we geen aanvullende methoden aan de interface kunnen toevoegen zonder alle implementatieklassen te wijzigen. Met de abstracte klasse kunnen we de standaardimplementatie bieden en alleen de implementatieklassen wijzigen die daadwerkelijk de nieuwe methoden gaan gebruiken.

Gebruik zowel Abstracte klassen als Interfaces

Het gebruik van interfaces en abstracte klassen samen is de beste aanpak om een systeem te ontwerpen. Bijvoorbeeld, in JDK java.util.List is een interface die veel methoden bevat, dus er is een abstracte klasse java.util.AbstractList die een skeletimplementatie biedt voor alle methoden van de List-interface, zodat elke subklasse deze klasse kan uitbreiden en alleen de vereiste methoden kan implementeren. We moeten altijd beginnen met een interface als basis en methoden definiëren die elke subklasse moet implementeren. Als er vervolgens methoden zijn die alleen bepaalde subklassen moeten implementeren, kunnen we de basisinterface uitbreiden en een nieuwe interface maken met die methoden. De subklassen hebben dan de mogelijkheid om te kiezen tussen de basisinterface of de kindinterface om te implementeren volgens hun vereisten. Als het aantal methoden sterk groeit, is het geen slecht idee om een skeletabstracte klasse te bieden die de kindinterface implementeert en flexibiliteit biedt aan de subklassen om te kiezen tussen interface en een abstracte klasse.

Java 8 interface wijzigingen

Vanaf Java 8 kunnen we methodimplementaties in de interfaces hebben. We kunnen standaardmethoden evenals statische methoden in de interfaces maken en een implementatie ervoor bieden. Dit heeft de kloof tussen abstracte klassen en interfaces overbrugd en nu zijn interfaces de weg te gaan omdat we deze verder kunnen uitbreiden door standaardimplementaties voor nieuwe methoden te bieden. Voor meer details, bekijk Java 8 interface standaard statische methoden.