Abstractie

We zijn aangekomen bij het laatste maar zeer belangrijke principe van OOP: Abstractie. Het woord "abstractie" klinkt vrij abstract, en kort samengevat vertelt dit principe ons dat we moeten vertrouwen op abstractie in plaats van op een specifieke implementatie. Dit klinkt nu misschien ingewikkeld. Laten we beginnen met de definitie:

Stel, we hebben een klasse genaamd Person,, en daar zijn veel verschillende klassen van afgeleid. Person heeft verschillende velden en methoden die voor alle klassen gemeenschappelijk zijn. Echter, wanneer we een klasse hebben zoals BasketballPlayer,, wordt het kenmerk height cruciaal, terwijl voor een klasse als Driver height irrelevant en niet belangrijk is. Hier komt abstractie om de hoek kijken. Door te erven van een abstractie kunnen we de parameter height optioneel maken, zodat we deze niet hoeven te gebruiken waar het niet nodig is.

Dit klinkt misschien ingewikkeld, dus laten we doorgaan met een voorbeeld:

De klasse Car stelt niets specifieks voor. Er bestaat niet zoiets als alleen een Car; er zijn sedans, trucks, tractoren. Daarom maken we gebruik van de abstractie genaamd Car. Om het verder te vereenvoudigen: Car is een sjabloon waarop we specifieke autoklassen baseren.

Let op de syntaxis:

Code kopiëren
Expand

Dit is de syntaxis voor het declareren van een abstracte klasse. Let ook op de syntaxis voor het declareren van een abstracte methode:

Code kopiëren
Expand

Een abstracte methode heeft geen body; dit is het belangrijkste kenmerk. Subklassen van een abstracte klasse zullen deze abstracte methode overschrijven om hun eigen implementatie te definiëren, gebruikmakend van polymorfisme.

Laten we nader bekijken wat een abstracte klasse is:

Let op dat we geen object van een abstracte klasse kunnen maken; dit zal tot een fout leiden:

Abstracte klassen zorgen ervoor dat we niet alleen met "objecten" werken; ze bieden een basisstatus en gedrag. Neem het voorbeeld van auto's: elke auto moet een model, bouwjaar, maximale snelheid en kleur hebben. Ze moeten ook kunnen bewegen en stoppen. Dat is alles; vanaf daar ontwerp je je specifieke klassen op basis van deze abstracte blauwdruk.

Regels voor het maken van een abstracte klasse

1. Een abstracte klasse is een klasse die minstens één abstracte methode bevat. Je kunt een abstracte klasse zonder abstracte methoden maken, maar dan heeft deze geen doel. Je kunt geen objecten van een abstracte klasse instantiëren;

2. Abstracte methoden kunnen alleen binnen een abstracte klasse bestaan; je kunt geen abstracte methoden buiten een abstracte klasse maken;

3. Methoden binnen een abstracte klasse kunnen zowel abstracte methoden als methoden met implementatie zijn;

4. Een klasse die erft van een abstracte klasse moet alle abstracte methoden overschrijven;

5. Je kunt van maximaal één klasse erven (abstract of niet-abstract);

6. Een abstracte klasse moet de gemeenschappelijke eigenschappen en gedrag van zijn afgeleide klassen vertegenwoordigen. We bespreken dit uitgebreider bij de SOLID-principes.

Laten we een voorbeeld bekijken om te begrijpen hoe subklassen abstracte methoden moeten overschrijven door te erven van een abstracte klasse, met het voorbeeld van de kindklasse Truck:

Hier is de code uit de screenshot, herschreven voor betere leesbaarheid en duidelijkheid:

Laten we de bovenstaande inhoud in detail bekijken:

• Eerste dia: We maken een subklasse Truck die zal erven van de abstracte klasseCar. We zien dat de IDE ons vraagt om de vereiste methoden te implementeren;

• Tweede dia: We overschrijven de benodigde methoden. Bijvoorbeeld, we schrijven dat de Truck is begonnen met rijden en daarna is gestopt;

• Derde dia: We maken een object in de main-methode. Let op de gebruikte syntaxis: Car name = new Truck();. We beginnen met het creëren van het object via abstractie en eindigen met een specifieke implementatie. Dit wordt compositie genoemd. Vervolgens wijzen we waarden toe aan de velden indien nodig en roepen we de overschreven methoden aan.

Voilà! Als alles duidelijk is, heb je geleerd hoe je een abstracte klasse gebruikt!

Samenvatting

Abstractie is waarschijnlijk het meest uitdagende principe van OOP om te begrijpen, en het is heel waarschijnlijk dat je op dit moment nog niet alles hebt begrepen. Maar denk niet dat je hierin alleen staat. Abstractie is een concept dat voor de meeste ontwikkelaars in het begin moeilijk te doorgronden is. Na verloop van tijd zul je beter begrijpen hoe je effectief kunt werken met abstractie en abstracte klassen. Abstractie is een cruciaal principe omdat het ons in staat stelt onze programma's uitbreidbaar en zeer flexibel te maken.