# Objectgeoriënteerd

Objectgeoriënteerd, vaak afgekort tot OO als afkorting voor het Engelse object-oriented, is een paradigma dat gebruikt wordt bij het objectgeoriënteerd programmeren en de objectgeoriënteerde opslag van data. Bij deze benadering wordt een systeem opgebouwd uit objecten.
Eenvoudig gezegd bestaat een object uit bepaalde gegevens en de programmatuur die gebruikt wordt om die gegevens te verwerken. Bij voorkeur zijn die gegevens uitsluitend te benaderen via de bijbehorende programmatuur. Een bestand kan bijvoorbeeld als object worden gedefinieerd, waarbij de gebruiker van het object slechts lees- en schrijfopdrachten kan geven, en interne gegevens zoals de "handle" van het bestand aan het zicht worden onttrokken. Kenmerkend voor objecten is ook dat zij in een hiërarchisch verband tot elkaar kunnen staan: zo is een invoerbestand een soort bestand.
Zuiver technisch biedt objectgeoriënteerd programmeren niet de mogelijkheid om een nieuw soort toepassingen te implementeren. Het dient uitsluitend om programma's beter te structureren, met het oog op de overzichtelijkheid, onderhoudbaarheid en herbruikbaarheid van componenten. Als dusdanig is het objectgeoriënteerde paradigma een opvolger van gestructureerd programmeren. Gestructureerd programmeren heeft veel klein- en middelschalige softwareprojecten tot een goed einde helpen brengen, maar bleek minder succesvol bij de grootschalige projecten die gebruikelijker werden tegen het einde van de jaren 1980.
Het objectgeoriënteerde paradigma kende een opmars in het begin van de jaren 90. Vele talen ondersteunen tegenwoordig objectgeoriënteerd programmeren.
Belangrijke voorzieningen in het objectgeoriënteerd programmeren zijn:
* Informatie verbergen: het kunnen verbergen van de interne werking van objecten, waarmee modulariteit afdwingbaar wordt.
* Modulariteit: programma's bestaan uit onderdelen die onafhankelijk kunnen worden aangepast zolang hun interface hetzelfde kan blijven; zo kan programmatuur gemakkelijker hergebruikt en uitgebreid worden.
* Overerving: de definitie van een klasse als een uitbreiding of aanpassing van een andere klasse.
* Polymorfisme: bij het aanroepen van een functie kan gekozen worden uit verschillende implementaties, vaak pas tijdens programmauitvoering.
De eerste twee voorzieningen zijn niet specifiek voor objectoriëntatie, maar worden ook gebruikt in modulaire programmeertalen zoals Modula, Ada en CLU. De specifieke kenmerken van overerving en polymorfisme zijn tegelijk de meest controversiële.

## Geschiedenis

Het objectgeoriënteerde programmeerparadigma werd voor het eerst gebruikt in de programmeertaal Simula van Ole-Johan Dahl en Kristen Nygaard in de jaren 60 van de 20e eeuw. Deze taal was een uitbreiding van de imperatieve taal Algol met objectgeoriënteerde elementen.
Een tweede, veel radicaler objectgeoriënteerde taal is Smalltalk, ontwikkeld in de jaren 70 bij Xerox PARC. Smalltalk is veel populairder geworden dan Simula, vooral voor prototyping; voor ontwikkeling van productiesoftware is de taal minder geschikt.
Objectgeoriënteerd programmeren kwam in een stroomversnelling terecht rond 1986, wat vooral bleek uit de ruime belangstelling voor twee conferenties: de Object Oriented Programming Workshop van IBM en de 1st International Conference on Object-Oriented Programming Languages, Systems and Applications (OOPSLA) te Portland (Oregon). Die plotse belangstelling had verschillende redenen, maar de belangrijkste was de opkomst van werkstations. De grafische gebruikersomgeving van werkstations stelt de programmeur voor specifieke problemen waarop objectgeoriënteerd programmeren een antwoord biedt.
De eerste objectgeoriënteerde taal die grootschalige aanhang verwierf onder professionele softwareontwikkelaars was C++, ook tegenwoordig een van de meest gebruikte programmeertalen. Naast C++ ontstonden in de jaren 80 ook Object Pascal, Objective C en andere veelgebruikte objectgeoriënteerde talen. De principes vonden zeer breed ingang in de ontwikkelpraktijk.
Van de nieuwere objectgeoriënteerde talen zijn de meest gebruikte Java (bekend vanaf 1995) en C# (vanaf 2001).

## Concept

In objectgeoriënteerde talen die gebruik maken van strenge typering worden objecten gemodelleerd als elementen ("instanties") van een klasse.
Een klasse is een blauwdruk voor objecten. Een klasse definieert:
* attributen om de eigenschappen en toestand van objecten mee vast te leggen;
* methoden: functies om die toestand uit te lezen of aan te passen, waarmee elk aan het object toe te rekenen gedrag wordt gespecificeerd; berekeningen, bewerkingen, acties, replieken etc.
Met een speciale constructor-functie kunnen objecten worden geïnstantieerd. Elk object heeft zijn eigen waarden van eigenschappen en toestand.
Deze aanpak doet natuurlijk aan omdat we op een vergelijkbare manier over de wereld denken. Bijvoorbeeld: de tafel waaraan u nu zit kunnen we beschouwen als een object van de klasse tafel; een specifieke cirkel in de meetkunde als een object van de klasse cirkel.
Als we in een programma een tafel of een cirkel nodig hebben, kunnen we die als klassen definiëren. Attributen zullen bijvoorbeeld de plaats van de tafel, of cirkel, vastleggen; methoden kunnen bijvoorbeeld het object verplaatsen of bepalen of een gegeven ander object zich erop bevindt.

### Overerving en polymorfisme

Een van de krachtige instrumenten van OO is de mogelijkheid tot hiërarchische classificatie. Een superklasse op het hoogste niveau kan in meerdere niveaus opgesplitst worden in lagere klassen. Daarbij 'erft' elke klasse op het lagere niveau de attributen en methoden van de klassen op het niveau boven de klasse. Dat mechanisme noemen we overerving (inheritance).
Overerving laat ook toe varianten van klassen te maken. We spreken dan van basis- en specifiekere klassen. In sommige situaties kan de basisklasse aangeven welke operaties mogelijk zijn op een object, terwijl een specifieke klasse een specifieke implementatie van de operatie geeft. Zo kan een basisklasse figuur gemaakt worden, met methoden zoals"hoogte, breedte, spiegel en draai. Daarvan kunnen specifieke implementaties worden gemaakt zoals cirkel en vierkant, die misschien heel verschillend werken (spiegel en draai hoeven bijvoorbeeld voor een cirkel niets te doen), terwijl code die een figuur gebruikt daar niets van hoeft te weten. Dit concept wordt polymorfisme genoemd.

### Inkapselen van data (encapsulatie)

Objecten vormen de koppeling tussen enerzijds gegevens en anderzijds bewerkingen die op die gegevens worden uitgevoerd. We spreken van inkapselen of encapsulatie als andere programma-eenheden de gegevens niet rechtstreeks aanspreken, maar wel via de tussenlaag van een bewerking. Programmeurs die een object gebruiken hoeven zich slechts bewust te zijn van de interface van dat object, terwijl de implementatie alleen een zaak is van de programmeurs die het object ontwikkelen.
Bij klasse-gebaseerde talen betekent encapsulatie dat de programmeur die een object van een klasse gebruikt, niet hoeft na te denken over de interne werking van die klasse. Een cirkelklasse kan bijvoorbeeld zijn attribuut "diameter" niet publiek maken maar de verschillende methoden om de oppervlakte op te vragen of de diameter te veranderen wel. De cirkelklasse zou dan eenvoudig aangepast kunnen worden om toch in plaats van de diameter intern de straal op te slaan, zonder dat de gebruiker van de cirkelklasse dit hoeft te weten: de publieke toegang tot de klasse is immers niet veranderd.

## Programmeertalen

* C-achtige syntaxis
** C++
** C#
** Java
** Objective-C
* Pascal-achtige syntaxis
** Oberon (Niklaus Wirth)
** Object Pascal (Borland, Embarcadero)
* Diversen
** Smalltalk de eerste echte OO-programmeertaal.
** Eiffel
** Swift, Apples eigen programmeertaal, uitgebracht op de WWDC van 2014.
* CODESYS
* Objectgeoriënteerde scriptingtalen
** Perl
** Python
** Ruby
** PHP
** JavaScript

## Objectgeoriënteerde gebruikersinterface

Een geheel ander soort objectgeoriënteerdheid treft men aan in de objectgeoriënteerde gebruikersinterface. Dit is een vorm van een grafische gebruikersomgeving waarbij de nadruk niet ligt op de programma's die gebruikt worden om taken uit te voeren, maar op de documenten of bestanden waarmee men werkt. De Workplace Shell van OS/2 is een voorbeeld van een dergelijke interface.