Abstractie

We zijn aangekomen bij het laatste, maar zeer belangrijke principe van OOP: Abstractie. Het woord "abstractie" klinkt vrij abstract, en in het kort 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 veel verschillende klassen zijn hiervan afgeleid. Person heeft diverse 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 specifieke autoklassen worden gebaseerd.

Let op de syntaxis:

public abstract class className{ }.

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

public abstract returnValue methodName();

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 resulteren in een foutmelding:

Abstracte klassen bevrijden ons van het werken met alleen "objecten"; ze bieden een basisstatus en gedrag. Neem het voorbeeld van auto's: elke auto moet een model, productiejaar, 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 maken zonder abstracte methoden, maar dan heeft deze geen functie. Je kunt geen objecten van een abstracte klasse instantiëren;
2. Abstracte methoden kunnen alleen bestaan binnen een abstracte klasse; je kunt geen abstracte methoden buiten een abstracte klasse maken;
3. Methoden binnen een abstracte klasse kunnen zowel abstracte methoden als methoden met implementaties 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 het behandelen van 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 als voorbeeld de kindklasse Truck:

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

Laten we in detail bekijken wat hierboven is geschreven:

• Eerste dia: We maken een subklasse Truck die zal erven van de abstracte klasse Car. 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 begint te rijden en daarna stopt;

• Derde dia: We maken een object aan in de main-methode. Let op de gebruikte syntaxis: Car name = new Truck();. We beginnen met het aanmaken 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 je alles begrijpt, 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 goed mogelijk 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 lastig te begrijpen is. Na verloop van tijd zul je beter begrijpen hoe je effectief met abstractie en abstracte klassen kunt werken. Abstractie is een cruciaal principe omdat het ons in staat stelt onze programma's uitbreidbaar en zeer flexibel te maken.