Themapagina Object georienteerd algemeen en OO Concepten

De basis van object georiënteerd programmeren.
(c) Hein Pragt 1999

Voordat ik begin uit te leggen wat object georiënteerd (vanaf nu OO) programmeren is, begin ik met een definitie wat objecten zijn. Objecten zijn alle dingen die wij kunnen bevatten, met duidelijk afgebakende grenzen. Voorbeelden zijn, een punt op het scherm, een pomp, een bankrekening, een computer, een mens of een programmeertaal. Twee verschillende objecten zijn duidelijk van elkaar te onderscheiden.

Een object heeft een aantal kenmerken:

Een identiteit is de unieke code of naam waarmee we twee objecten van elkaar onderscheiden, voorbeelden zijn een boek of een bankrekening.

De toestand is de huidige waarde van de interne structuur van een object, een voorbeeld is een bankrekening met een saldo van 1023 gulden.

Het gedrag van een object zijn de diensten die het verleent aan de buitenwereld. In het geval van een bankrekening kan dit het opvragen van het saldo of het verhogen van het saldo zijn.

De buitenwereld heeft geen directe toegang tot het saldo van de bankrekening, maar kan alleen via de boodschappen (member functies) de huidige toestand opvragen, of iets aan de huidige toestand te veranderen.

Een class is een definitie van een object, waarmee instances (echte objecten) van de class gemaakt kan worden. Een class op zich is geen object, er kunnen objecten mee gemaakt worden. Van een class kunnen we meer dan een object (instances) maken. De class is vergelijkbaar met een gietvorm waar we veel dezelfde beeldjes mee kunnen gieten.
In de class definiëren we een interface. We kunnen alleen met een object communiceren via deze interface. Ook definiëren we in de class de interne data, waarin we de toestand van een object opslaan. Interne data is dus ingekapseld en niet direct benaderbaar door de buitenwereld.
OO software is gebaseerd op deze objecten. Een object kunnen we beschouwen als een "gesloten apparaat" met een vast gedefinieerde interface. We hoeven niet te weten wat er zich in het object bevind, we kennen de interface waarmee we communiceren met het object.

Een voorbeeld is een televisie toestel.
We hoeven niet weten wat er in de T.V. zit, we gebruiken alleen de knoppen en het scherm als interface. Als we een andere zender willen kiezen, veranderen en we niet de afstemkring door binnen in het toestel aan een van de onderdelen te draaien, maar we geven de interface via een knop de opdracht op een andere zender af te stemmen. Via deze knoppen kunnen we ook zenders zoeken en in het geheugen van de T.V. opslaan. Hoe dit intern gebeurt willen we niet weten, en is voor het normaal gebruik van het toestel niet belangrijk. Intern kan dit in verschillende toestellen anders opgelost zijn, vanuit de interface zien we hetzelfde. Deze inkapseling van data en methodes is de basis van OO programmeren.

De interface functies zijn ook weer onder te verdelen in vier soorten:

Constructors. Dit is de member functie die gebruikt word om een object een begin toestand te geven. Deze zal bij het creëren van een object zorgen voor een voorinstelling van de waardes van interne variabelen.

Destructors. Deze member functie ruimt een object netjes op uit het geheugen, als de levenduur van het object afgelopen is.

Modifiers. Dit zijn member functies die iets aan de interne toestand van het object veranderen, bijvoorbeeld in het geval van de bankrekening kan de methode StortBedrag het saldo veranderen.

Selectors. Dit zijn member functies die de interne toestand van een object terugmelden. Deze zullen niets aan de interne toestand veranderen. Dit is dus een read-only bewerking, het mag niets aan de interne toestand van het object veranderen.

De constructor en destructor zijn interne functies van het object, de modifier en de selector zijn van buiten het object te gebruiken.

Doordat de buitenwereld geen directe toegang heeft op de interne data van een object, kan via de interface functies bijvoorbeeld validatie plaatsvinden. Als gedefinieerd is dat een bankrekening niet negatief mag zijn kan de member functie VerlaagSaldo een controle uitvoeren of het saldo door deze bewerking niet negatief kan worden. In dit geval kan de member functie een fout afhandeling starten of een foutmelding genereren.
De interface bewaakt dus de interne toestand van een object.

De tegenhanger van OO programmeren is het procedure gericht programmeren. Hier staan de bewerkingen centraal, in tegenstelling van OO programmeren waar de gegevens en hun toestand centraal staan. In OO begint men met een data model, waarna men deze via objecten in categorieën onderbrengt, om daarna de interface en de bewerkingen te definiëren. Dit is duidelijk een andere aanpak, die het ook nodig maakt eerst over het programma en het data model na te denken. Dit in contrast met procedure gericht programmeren waar vaak een globale opzet van een programma word gemaakt, waarna deze procedures uitgewerkt worden. Dit is niet per definitie een slechtere aanpak, maar een andere, die ook zijn voordelen kan hebben.
Ik heb wel eens te horen gekregen, als is een ontwerp op papier aan het maken was, "wanneer begin je nu met het project". Deze mensen dachten dat het inkloppen van code het programmeren is. Dit is echter maar een klein deel van het programmeer werk. Het meeste is ook zonder computer te doen.

Een tweede eigenschap van OO programmeren is overerving.

Als we eenmaal een class gedefinieerd hebben, ligt deze vast. Als er nu een specialisatie plaats moet vinden, kan de reeds ontworpen class als basis dienen voor een nieuwe class. De nieuwe class bevat alle onderdelen van de oorspronkelijke class, met een aantal toevoegingen speciaal voor de nieuwe class. Als we een bankrekening zonder rente gedefinieerd hebben met een groot aantal bewerkingen, kunnen we hiervan een rekening met rente afleiden. De bewerkingen die we kunnen uitvoeren op de oorspronkelijke rekening kunnen we ook uitvoeren op de rekening met rente. Deze rekening heeft echter een paar uitbreidingen t.o.v. de oude rekening, en dat is een rentepercentage variabele, een functie om het rentepercentage op te vragen en een functie om het rentepercentage te veranderen. Ook zal er een functie moeten komen om de rente bij te boeken. De code om het saldo op te vragen en het saldo af te boeken hoeven we niet opnieuw te schrijven.

Dit is een eigenschap van OO programmeren die ik nogal eens uit de hand zie lopen. Een goede class hiërarchie opbouwen is een kunst, en soms zie je een ad-hoc class hiërarchie die ondoorzichtig en niet te onderhouden is.
Het werken met OO is geen garantie voor goede en goed onderhoudbare code. Een paar goede voorbeelden van een class hiërarchie zijn OWL van Inprise en MFC van Microsoft.

OO werken ten opzichte van procedureel programmeren betekend vaak de je veel vrijheden die je had moet opgeven en binnen een strakkere structuur moet werken. Dit voorkomt echter heel veel basis programmeer fouten, zodat het resultaat beter, en beter onderhoudbaar is.
Deze vorm van jezelf de beperkingen van een goede structuur opleggen, schrikt sommige 'C' en assembler programmeurs nog wel eens af. Een collega van mij plaagt me wel eens, als ik weer iets met de bestaande code wil doen waarin niet voorzien is, dat beperkingen opleggen geheel in de stijl van OO programmeren is. Ik probeer dan uit te leggen dat ik vanuit de bestaande code deze functionaliteit niet kan toevoegen, maar dat dit in een OO omgeving eenvoudig te doen zou zijn.

Het grote voordeel van OO programmeren is dat het uitnodigt tot goed gestructureerd werken, en dat je in staat bent goede interfaces te maken. Data hiding is in mijn visie een van de beste onderdelen van OO.