Verschil tussen interface en abstracte klasse in Java & C #

• 2019

Interface en abstracte klasse dragen beide bij tot het "incomplete type" in OOP. Soms hebben we een superklasse nodig om te definiëren "wat te doen" maar niet "hoe te doen", het is hoe te doen een deel zal worden geïmplementeerd door de afgeleide klasse volgens zijn behoefte, " interface " biedt hier een oplossing voor. Soms hebben we een superklasse nodig die een gegeneraliseerde structuur definieert die kan worden geïmplementeerd door afgeleide klassen en een bepaalde structuur die kan worden gebruikt door de afgeleide klassen, " abstracte klasse " biedt hier een oplossing voor. Het fundamentele verschil tussen interface en abstracte klasse is dat de interface volledig incompleet is en dat de abstracte klasse gedeeltelijk onvolledig is.

Vergelijkingstabel

Basis voor vergelijking	Interface	Abstracte klasse
basis-	Wanneer u alleen de kennis van de vereisten niet over de implementatie ervan heeft, gebruikt u "Interface".	Wanneer u gedeeltelijk op de hoogte bent van de implementaties gebruikt u "Abstracte klassen".
methoden	Interface bevat alleen abstracte methoden.	Abstracte klasse bevat zowel abstracte methoden als concrete methoden.
Toegang Modifier van methoden	Interfacemethoden zijn altijd "Openbaar" en "Abstract", zelfs als we dit niet aangeven. Vandaar dat het gezegd kan worden als 100%, pure abstracte klasse.	Het is niet verplicht dat de methode in abstracte klasse openbaar en abstract is. Het kan ook concrete methoden hebben.
Beperkte modifier voor methoden	Een interfacemethode kan niet worden gedeclareerd met de volgende modifiers: Openbaar: privé en beschermd Abstract: definitief, statisch, gesynchroniseerd, native, strictfp.	Er zijn geen beperkingen voor de modifiers van de abstracte klassenvariabele.
Toegang Modifier van variabelen	Toegestane Acess Modifier voor interfacevariabelen zijn openbaar, statisch en definitief, of we nu declareren of niet.	De variabelen in abstracte klasse hoeven niet openbaar, statisch en definitief te zijn.
Beperkte modifiers voor variabelen	Interface-variabelen kunnen niet worden gedeclareerd als privé, beschermd, van voorbijgaande aard, vluchtig.	Er is geen beperking op de modifiers van abstracte klassevariabelen.
Initialisatie van variabelen	De interfacevariabelen moeten worden geïnitialiseerd op het moment van de declaratie.	Het is niet verplicht dat abstracte klassenvariabelen moeten worden geïnitialiseerd op het moment van de verklaring.
Exemplaar en statische blokken	Binnen interface, kunt u een instantie of een statisch blok niet declareren.	Abstracte klasse staat een exemplaar of statisch blok erin toe.
constructors	U kunt constructor inside interface niet declareren.	Je kunt een constructor binnen een abstracte klasse declareren.

Definitie van interface

Java staat meerdere overerving niet toe. Dat wil zeggen, een enkele klasse kan niet meer dan één klasse tegelijk erven. De reden hierachter kan met een voorbeeld worden uitgelegd. Laten we veronderstellen dat we twee ouderklasse A en B en een afgeleide klasse C hebben. De afgeleide klasse C erft zowel de klassen A als B. Nu hebben beide de klasse A en B methode set (), dan is het een vraag voor klasse C moet de methode van de klasse set () worden geërfd. De oplossing voor dit probleem is "interface".

Interface is een pure abstracte klasse. Het sleutelwoord voor het maken van een interface is "interface". Omdat alle methoden in de interface volledig abstract zijn. De interface geeft alleen aan wat een klasse moet doen, maar definieert niet hoe deze het doet. Omdat alle binnen de interface gedeclareerde methoden abstract zijn, wordt er geen instantie voor een interface gemaakt. De algemene vorm van "interface" in Java is:

 access_specifier interface interface_naam {return-type methode-name1 (parameter-lijst); return-type methode-name2 (parameter-lijst); type final-varname1 = waarde; type final-varname2 = waarde; // ... return-type methode-nameN (parameter-lijst); type finale-varnameN = waarde; } 

De toegangsspecificatie wordt openbaar verklaard omdat de klassen de interface moeten implementeren.

We hebben het concept "interface" niet in C ++. Maar Java en C # definiëren de interface erg goed.

Interface in Java:

• Variabelen van een interface zijn standaard altijd openbaar, statisch en definitief.
• Variabelen moeten worden geïnitialiseerd op het moment van de declaratie.
• Variabelen kunnen nooit als privé, beschermd, vluchtig en vluchtig worden verklaard.
• Methoden van een interface zijn altijd openbaar en abstract, terwijl ze nooit als privé, beschermd, definitief, statisch, gesynchroniseerd, native en strictfp kunnen worden verklaard.
• U kunt geen constructor in interface declareren omdat het hoofddoel van de constructor de initialisatie van klassenvariabelen is, maar in interfacevariabelen worden geïnitialiseerd op het moment van de declaratie.
• Interface kan andere interfaces erven, maar de klasse die een dergelijke interface implementeert, moet de methoden van alle overgeërfde interfaces implementeren.
• Een klasse kan meer dan één interface tegelijk erven en moet alle methoden van alle overgeërfde interfaces implementeren.

De algemene vorm van het implementeren van een interface in Java:

 class class_name implementeert Interface_name {// class-body} 

Voor het overerven van een interface gebruikt een klasse een sleutelwoord "implementeert", en de klasse implementeert alle methoden gedeclareerd door een geërfde interface.

Interface in C #:

Interface in C # lijkt bijna op interface in Java, behalve:

• Interface in C # declareren geen variabelen.
• De naam van de interface wordt voorafgegaan door een hoofdletter I en wordt overgenomen door een dubbele punt (:).

De algemene vorm van het implementeren van een interface in C #:

 class class_name: interface_name {// class-body} 

Definitie van abstracte klasse

Een klasse die een of meer abstracte methoden bevat, wordt abstracte klasse genoemd en een klasse wordt als abstract gedeclareerd met het sleutelwoord 'abstract', voorafgegaan door het sleutelwoord 'klasse' aan het begin van de klassedeclaratie. Omdat de abstracte klasse de abstracte methode bevat, vormt deze tot een incompleet type. Daarom kun je geen objecten van een abstracte klasse maken. Telkens wanneer een klasse een abstracte klasse overerft, moet deze alle abstracte methoden van de abstracte klasse implementeren, als dit niet het geval is, moet het ook als abstract worden verklaard. Het abstracte attribuut is geërfd totdat de volledige implementatie van abstracte methoden is bereikt.

De abstracte klasse kan ook concrete methoden bevatten die door de afgeleide klasse kunnen worden gebruikt zoals die is. Maar je kunt een abstracte constructor of een abstracte statische methode niet binnen een abstracte klasse declareren. De algemene vorm van de abstracte klasse in Java is als volgt:

 abstracte klasse class_name {abstract methode_naam1 (); abstract method_name2 (); : return_type method_name3 (parameter_list) {// concrete methode} return_type method_name4 (parameter_list) {// concrete methode}}; 

Het concept van een abstracte klasse is vergelijkbaar in zowel Java als C #. Een abstracte klasse is iets anders in C ++.

In C ++ als een klasse minstens één virtuele functie heeft, wordt de klasse een abstracte klasse. In plaats van het trefwoord "abstract", wordt het sleutelwoord "virtueel" gebruikt om een ​​abstracte methode te declareren.

Belangrijkste verschillen tussen interface en abstracte klasse in Java & C #

1. Wanneer u de kennis hebt van "wat nodig is" maar niet van "hoe het zou worden geïmplementeerd", moet de interface worden gebruikt. Aan de andere kant, als je weet wat nodig is en gedeeltelijk weet hoe het zou worden geïmplementeerd, gebruik dan een abstracte klasse.
2. Een interface heeft alle methoden abstract, maar een abstracte klasse heeft een aantal abstracte methoden en een aantal concrete methoden.
3. De methoden in een interface zijn openbaar en abstract en daarom wordt het ook wel een pure abstracte klasse genoemd. Aan de andere kant zijn de methoden binnen een abstract niet beperkt tot alleen publiek en abstract.
4. Een interfacemethode kan nooit privé, beschermd, definitief, statisch, gesynchroniseerd, native of strictfp zijn. Aan de andere kant zijn er geen beperkingen aan methoden van een abstracte klasse.
5. De variabelen in een interface zijn openbaar en definitief, ongeacht of we deze al dan niet declareren, terwijl dergelijke variabelen van een abstracte klasse niet als zodanig alleen openbaar en definitief zijn.
6. Variabelen in een interface kunnen nooit privé-beveiligd transiënt of vluchtig zijn, terwijl er geen beperking is voor variabelen in een abstracte klasse.
7. De variabele van een interface moet tijdens de aangifte worden geïnitialiseerd. Aan de andere kant kunnen de variabelen in een abstracte klasse op elk moment worden geïnitialiseerd.
8. Binnen een interface kan een instantie of statisch blok niet worden gedeclareerd, maar u kunt een exemplaar of statisch blok binnen een abstracte klasse declareren.
9. U kunt de constructor niet in een interface definiëren, terwijl u de constructor in een abstracte klasse kunt definiëren.

Conclusie:

Wanneer u een basisklasse moet maken die een gegeneraliseerde vorm van methoden bevat die volgens de behoefte door de afgeleide klassen kan worden geïmplementeerd, helpt het concept van interface en abstracte klasse daarbij.