Object georiënteerd programmeren

1. Introductie van de principes van OOP

Vandaag ontdek je een nieuwe en interessante wereld. De wereld van objectgeoriënteerd programmeren ( OOP ). Je hebt eerder geleerd over klassen en objecten. Vandaag leer je er meer over, veel meer.

OOP ontstond als reactie op de toenemende complexiteit van programma's. Toen het aantal variabelen en methoden in programma's in de tienduizenden begon te lopen, werd duidelijk dat er iets moest gebeuren. Een oplossing was om gegevens en bijbehorende methoden te combineren in afzonderlijke objecten.

Nu moesten programmeurs afzonderlijk beschrijven hoe objecten extern op elkaar inwerken en hoe ze zich intern gedragen. Dit maakte het veel gemakkelijker om programma's te begrijpen en te schrijven. Er bleef echter een vraag over: welke methoden moeten intern zijn voor een object en welke moeten beschikbaar zijn voor andere objecten?

Er werden veel benaderingen geprobeerd. En op basis van de ontdekte best practices kwamen 4 principes van OOP naar voren. Het zijn abstractie, inkapseling, overerving en polymorfisme . Voorheen waren dat er maar drie, maar experts besloten later ook abstractie toe te voegen.

2. Abstractie

Mensen op internet maken nog steeds ruzie over de definitie van abstractie in OOP . Het probleem is niet dat iedereen ongelijk heeft. Het is dat iedereen gelijk heeft . Hoe kleiner een programma is, hoe meer abstractie verbonden is aan de Java-taal. Hoe groter een programma is, hoe meer abstractie verbonden is aan het modelleren/vereenvoudigen van objecten uit de echte wereld.

Maar de knapste koppen lijken het erover eens te zijn dat:

Abstractie is het gebruik van alleen die kenmerken van een object die het voldoende nauwkeurig weergeven in een programma. Het belangrijkste idee is om het object weer te geven met de kleinste set velden en methoden waarmee tegelijkertijd uw taken met voldoende nauwkeurigheid kunnen worden opgelost .

In Java wordt abstractie bereikt door middel van abstracte klassen en interfaces.

Abstractie in het echte leven

Een goed voorbeeld van abstractie in het echte leven zijn functiebeschrijvingen bij een bedrijf of organisatie. De titel van een functie is één ding, maar de specifieke verantwoordelijkheden die aan een functie zijn toegewezen, zijn een heel andere zaak.

Stel je voor dat je de organisatiestructuur van je toekomstige bedrijf ontwerpt. Je kunt secretariële taken verdelen over verschillende functies. U kunt de CEO-functie opsplitsen in verschillende afzonderlijke functies: CFO, CTO, CMO, HR-directeur. Of combineer bijvoorbeeld de functies van officemanager en recruiter tot één.

Je bedenkt functietitels en verdeelt vervolgens de verantwoordelijkheden voor deze functies. Abstractie is loskomen van het object als geheel en de essentiële eigenschappen en componenten selecteren die we nodig hebben.

Vanuit programmeeroogpunt is abstractie de juiste verdeling van een programma in objecten . Doorgaans zijn er tientallen manieren om een ​​groot programma weer te geven als interactieve objecten. Met abstractie kun je de essentiële kenmerken selecteren en de niet-essentiële kenmerken negeren.

3. Inkapseling

Het doel van inkapseling is om interacties te verbeteren door objecten eenvoudiger te maken.

En de beste manier om iets te vereenvoudigen, is alles wat gecompliceerd is voor nieuwsgierige blikken te verbergen. Als je bijvoorbeeld in de cockpit van een Boeing jumbojet wordt gezet, begrijp je niet meteen hoe je hem moet bedienen:

Maar voor de passagiers in het vliegtuig is alles eenvoudiger: je koopt een kaartje en stapt in het vliegtuig, dat opstijgt en dan landt. U kunt gemakkelijk van het ene continent naar het andere vliegen met alleen de mogelijkheid om "een kaartje te kopen" en "in een vliegtuig te stappen". Alle complexiteit van het voorbereiden van het vliegtuig op vliegen, opstijgen, landen en verschillende noodsituaties is voor u verborgen. Om nog maar te zwijgen van de satellietnavigatie, de automatische piloot en de luchtverkeersleidingscentra. En dit vereenvoudigt het leven voor ons.

Vanuit programmeeroogpunt is inkapseling "de implementatie verbergen". Ik hou van deze definitie. Onze klas kan honderden methoden bevatten en zeer complex gedrag in verschillende situaties implementeren. Maar we kunnen al zijn methoden verbergen voor nieuwsgierige blikken (door ze te markeren met de private modifier), en slechts twee of drie methoden overlaten voor interactie met andere klassen (door ze te markeren met de public modifier). Dan zullen alle andere klassen van ons programma alleen de drie openbare methoden zien en ze aanroepen, maar andere niet. En alle complexiteit wordt verborgen in de klas, net zoals de cockpit verborgen is voor blije passagiers.

4. Overerving

Er zijn twee kanten aan erfenis . Overerving in programmering en overerving in het echte leven. Bij het programmeren is overerving een speciale relatie tussen twee klassen . Maar overerving in het echte leven is veel interessanter.

Als we iets in het echte leven moeten creëren, hebben we twee opties:

1. Maak het ding dat we nodig hebben helemaal opnieuw, besteed veel tijd en moeite.
2. Creëer het ding dat we nodig hebben op basis van iets dat al bestaat.

De optimale strategie is deze: neem een ​​bestaande goede oplossing, pas deze een beetje aan, pas hem aan onze behoeften aan en gebruik hem dan.

Als we de menselijke geschiedenis terugvoeren naar het begin, ontdekken we dat er miljarden jaren zijn verstreken sinds het leven op de planeet begon. Maar als we het uitgangspunt van de mens beschouwen als onze voorouders van primaten (dwz mensen zijn "gebaseerd" op voorouders van primaten), dan zijn er nog maar een paar miljoen jaar verstreken. Vanaf nul opbouwen duurt langer. Veel langer.

Bij het programmeren kun je iets soortgelijks doen door een klasse te maken op basis van een andere. De nieuwe klasse stamt af van (erft) de bestaande klasse. Dit is erg handig wanneer een bestaande klasse 80-90% van de gegevens en methoden heeft die we nodig hebben. We declareren gewoon de juiste klasse als de ouder van onze nieuwe klasse en alle gegevens en methoden van de ouderklasse verschijnen automatisch in de nieuwe klasse. Handig toch?

5. Polymorfisme

Polymorfisme is een programmeerconcept. Het beschrijft een situatie waarin verschillende implementaties verborgen zijn achter één enkele interface. Kijkend naar het echte leven voor een tegenhanger, vinden we dat het besturen van een voertuig goed bij elkaar past.

Als iemand een vrachtwagen kan besturen, kan ze ook achter het stuur van een ambulance of achter het stuur van een sportwagen worden gezet. Een mens kan een auto besturen, ongeacht het soort auto, omdat alle auto's dezelfde bedieningsinterface hebben: een stuur, pedalen en versnellingspook. De binnenkant van de auto's is verschillend, maar ze hebben allemaal dezelfde bedieningsinterface.

Terugkerend naar de wereld van programmeren, maakt polymorfisme het mogelijk om objecten van verschillende klassen (meestal met een gemeenschappelijke voorouder) op dezelfde manier te benaderen, een eigenschap waarvan de waarde nauwelijks kan worden overschat. De waarde neemt toe naarmate het programma groter wordt.

OOP betekent principes. Interne wetten. Elk van hen beperkt ons op de een of andere manier, maar levert grote voordelen op als het programma groot wordt. De vier principes van OOP zijn als vier poten van een tafel. Haal er een weg en het hele systeem wordt instabiel.