De diversificatie van de toepassingsgebieden van programmeren heeft geleid tot verschillende soorten talen. In dit artikel zullen we ontdekken: wat is objectgeoriënteerd programmeren? en wat zijn de soorten objectgeoriënteerde programmeertalen die er zijn. Durf je kennis uit te breiden!
Object georiënteerd programmeren
Over het algemeen vereist programmeren kennis van een taal die verantwoordelijk is voor het verzenden van opdrachten naar de computer en een algoritme dat in een programma wordt omgezet, maar wat is programmeren?
Programmeren is een reeks acties die leiden tot het schrijven van een code die in staat is om het doel te bereiken waarvoor deze is gemaakt. Van zijn kant, een broncode is de interne representatie van een programma of software, en een programma is een groep orders die de werking van computers regelen.
In principe doorloopt een programma drie fasen: het bewerken van het programma in een geschikte taal, het omzetten van de broncode in instructies voor de machine, en het koppelen van de objectcodes aan de functiebibliotheken, wat uiteindelijk leidt tot wat het staat bekend als uitvoerbare code.
Een programma moet geschreven zijn in een programmeertaal die begrijpelijk is voor de gebruiker. Om dit te laten gebeuren, moet de programmeur een van de vele bestaande programmeerparadigma's overnemen, die de visie bepalen en dus de keuze van de methoden die moeten worden gevolgd bij de constructie ervan.
Programmeerparadigma's
Vooruitgang in programmering en technologie hebben geleid tot verschillende programmeermethodologieën of paradigma's. Deze hebben op hun beurt geleid tot verschillende programmeerstijlen en verschillende vormen van probleemoplossing. Dit zijn de bestaande paradigma's:
Dwingend paradigma
Daarin staat dat programma's een strikte opeenvolging van instructies van boven naar beneden zijn, die alleen wordt onderbroken door ergens een subprogramma in op te nemen.
Gestructureerd paradigma
Het dwingt codestructuren af die zijn gegroepeerd op blokken van procedures en functies. De code wordt gereproduceerd in de vorm van een lus, gedomineerd door een logische reden.
Declaratief paradigma
Het bepaalt niet de volgorde die moet worden gevolgd bij het uitvoeren van de acties die nodig zijn om een probleem op te lossen. Daarin worden twee typen onderscheiden: het functionele paradigma, waarbij het probleem en de oplossing worden beschreven als functies, en het logische paradigma, gebaseerd op een logisch predikaat.
Paradigma voor evenementprogrammering
Het is gebaseerd op oneindige iteratie om het probleem te detecteren en vast te stellen hoe het kan worden opgelost.
Parallelle, gedistribueerde en gelijktijdige paradigma's
De realisatie van het programma vereist meerdere rekeneenheden. De routines draaien onafhankelijk op andere rekeneenheden.
Objectgeoriënteerd paradigma
Dit type programmering is gebaseerd op drie basisprincipes: gegevensinkapseling, objectabstractie en typecontrole volgens de klassenhiërarchie.
Het is belangrijk op te merken dat een programmeertaal meestal niet alleen op één paradigma reageert, maar het resultaat kan zijn van de combinatie van verschillende typen ervan. Hieronder zullen we ons echter alleen in detail wijden aan het definiëren van wat is objectgeoriënteerd programmeren? en wat zijn de verschillende? objectgeoriënteerde programmeertalen die bestaan
Kwaliteiten
Het is tegenwoordig het meest wijdverbreide paradigma, omdat het een beter beheer van complexiteit mogelijk maakt tegen redelijke kosten. Hiermee wordt de mogelijkheid voorgesteld om onderdelen in te bouwen, dat wil zeggen het werk te verdelen op basis van componenten, wat resulteert in robuuste, draagbare en herbruikbare toepassingen, met voordelen op de lange termijn.
In tegenstelling tot andere soorten programmering, zoekt objectgeoriënteerd programmeren naar onderdelen in entiteiten die voortkomen uit het probleemdomein, en niet binnen de probleemoplossing zelf. De primaire vereiste is dat elk onderdeel zich op een verwachte manier gedraagt, zodat onze ontwikkeling niet wordt beïnvloed door de manier waarop het wordt geïmplementeerd, en dat we a priori de voorwaarden kennen die elk onderdeel biedt, evenals hoe we verbinding kunnen maken met de .
Vanuit een ander gezichtspunt kunnen we vermelden dat objectgeoriënteerd programmeren gerelateerd is aan de kennistheorie, die stelt dat de mens informatie opslaat volgens vooraf bepaalde schema's, het product van zijn ervaringen als persoon. Op deze manier maakt dit type programmering het mogelijk om kennis op een heuristische of theoretische manier weer te geven, via de mentale schema's van het individu, gebruikmakend van eerdere kennis die is opgeslagen in informatie-eenheden.
Origenes
https://youtu.be/aESIbDclIzw?t=5
Objectgeoriënteerd programmeren is een techniek, stijl of methodologie die in de jaren zestig is ontwikkeld als gevolg van de crisis die is ontstaan door de onmogelijkheid om complexe programma's te wijzigen of aan te passen. Situatie die steeds erger werd door het gebrek aan gespecialiseerd personeel dat de programma's wilde onderhouden.
De tijdelijke oplossing voor deze crisis lag in de handen van gestructureerde programmering, die erin bestond de programma's op te splitsen in afzonderlijke procedures die specifieke taken afzonderlijk zouden uitvoeren. Dit bracht andere nadelen met zich mee, voornamelijk veroorzaakt door de moeilijkheid om coördinatie te bereiken tussen de vele ontwikkelaars die bij een project betrokken waren, aangezien hoe groter het aantal betrokken taken, hoe groter het aantal programmeurs.
Zonder twijfel was het belangrijkste nadeel van dit type programmering de noodzaak om de gegevens conceptueel van de codes te scheiden. Een situatie die direct werd verergerd door de omvang en complexiteit van het programma.
Dus, om de complexiteit van programma's te verminderen, werd objectgeoriënteerd programmeren geboren. Het belangrijkste voordeel is dat het het mogelijk maakt om complexe programma's te bouwen met behulp van eenvoudigere objecten. Deze objecten vormen de entiteiten van de software die onder deze methodologie wordt georiënteerd. De mogelijkheid om zowel gegevens als code van bestaande applicaties te erven, verbetert de productiviteit van ontwikkelaars. Evenzo maakt het het gemakkelijk om klassen uit te breiden en opnieuw te gebruiken in andere toepassingen, zonder dat de originele code sterk hoeft te worden gewijzigd.
Kenmerken
Objectgeoriënteerd programmeren heeft meerdere kwaliteiten, hier zijn de belangrijkste:
- De basis van objectgeoriënteerd programmeren zijn klassen, geen algoritmen. Deze vormen logische bouwstenen.
- Elk object is een instantie van een klasse.
- Een programma wordt gezien als een middel om berichten te verzenden en te ontvangen, via een reeks objecten die op elkaar reageren.
- Elk object moet zoeken naar de beste manier om op elk ontvangen bericht te reageren.
- Elk object kan op verschillende manieren op berichten reageren.
- Het maakt het gemakkelijk om de software te wijzigen omdat de componenten uitwisselbaar zijn.
- Gedeeltelijke en interne veranderingen hebben geen invloed op het gedrag van de rest van het systeem.
- Als de basisprincipes van objectgeoriënteerd programmeren worden gevolgd, zullen de kosten voor het bouwen van het systeem lager zijn dan in gevallen waarin de onderdelen onderling afhankelijk zijn.
- Het is mogelijk dat klassen afgeleid van anderen de kennis en vaardigheden van hun voorgangers erven. Door overerving zijn de klassen aan elkaar gerelateerd en wordt de manier van werken uitgebuit zonder dat de code opnieuw hoeft te worden geschreven.
- De methoden van een klasse kunnen verschillende dingen doen, zelfs als ze dezelfde naam behouden. Dat wil zeggen, door polymorfisme kan de programmeur verschillende vormen van dezelfde methode implementeren, afhankelijk van de klasse waarop de implementatie is gemaakt. Dit betekent dat meerdere methoden toegankelijk zijn onder dezelfde naam of toegangsmedium.
Verschillen: gestructureerd programmeren vs. Object georiënteerd programmeren
Zoals we al hebben vermeld, vertegenwoordigt objectgeoriënteerd programmeren de evolutie van gestructureerd programmeren, wat niet betekent dat het beter is dan dat, aangezien elk zijn nut heeft, afhankelijk van het type systeem dat zal worden ontwikkeld. De fundamentele verschillen die tussen de twee bestaan, worden hieronder uiteengezet:
Gestructureerd programmeren lost algoritmische problemen op, vanaf de introductie van enkele gegevens wordt een uitvoer gegenereerd. Objectgeoriënteerd programmeren is gebaseerd op objectmodellering, erg handig bij de ontwikkeling van webapplicaties.
De eerste richt zich op een datastructuur, terwijl de tweede is gebaseerd op objecten, met een eigen toestand en gedrag.
De informatie binnen gestructureerd programmeren stroomt door structuren en oproepen naar functies, bij objectgeoriënteerd programmeren is het het resultaat van de interactie daartussen, door berichten te verzenden en te ontvangen.
Basisprincipes
Als gevolg van het concept van objectgeoriënteerd programmeren ontstaan drie basisprincipes van dit paradigma. Dit zijn:
Gegevens inkapseling
Zoals we al hebben vermeld, wordt van objecten verwacht dat ze weten hoe ze moeten reageren op de berichten die ze ontvangen en een specifiek gedrag vertonen. Wat we echter niet willen, is dat degene die het bericht verzendt, weet hoe hij het doet. Het bereiken van dit doel is wat bekend staat als inkapseling van de gegevens. Met andere woorden, u wilt dat elk onderdeel van het programma alleen weet wat het interesseert, waardoor neveneffecten met betrekking tot andere objecten worden vermeden.
Kortom, met de inkapseling van de gegevens is toegang tot de componenten van de objecten onmogelijk, dat wil zeggen, deze worden beschermd binnen een enkele goed gedefinieerde programmeereenheid, omdat elk van hen ontwerpspecificaties heeft die ze onafhankelijk van elkaar maken.
De belangrijkste reden waarom we willen dat het clientobject de manier van implementatie negeert, is dat er over het algemeen verschillende alternatieven voor dezelfde bewerking kunnen zijn. Bovendien kunnen we in de toekomst besluiten om van het ene alternatief naar het andere over te stappen, zonder dat de klant hiervan op de hoogte is of de dienstverlening wordt beïnvloed.
Objectabstractie
Een essentieel kenmerk van objectgeoriënteerd programmeren is dat het het probleem in delen probeert aan te pakken. Op deze manier is het eerste wat het doet de objecten vinden, vervolgens bepalen hoe ze met elkaar moeten omgaan en ten slotte hun gedrag implementeren. Bijgevolg hebben we dat de objecten die we vinden degenen zijn die ons zullen helpen het probleem op te lossen.
Abstractie omvat twee soorten kennis, gegevens of variabelen, die het mentale schema vormen, en methoden, functies of procedures, die het schema relateren aan andere vooraf bepaalde schema's. Dat wil zeggen, dankzij data-abstractie kunnen het domein en de structuur van de gegevens worden gedefinieerd, evenals de methoden om toegang te krijgen tot deze gegevens. Ten slotte wordt de abstractie een nieuw type gegevens gedefinieerd door de programmeur, bestaande uit attributen en methoden die op de eerste worden toegepast.
Vanwege het bestaan van meerdere mentale schema's voor hetzelfde probleem, kan elke programmeur de lessen op verschillende manieren organiseren, volgens zijn persoonlijke perceptie. Wat hij bedoelt is dat objectabstractie het vermogen is binnen het programmaontwerp om door de gebruiker gedefinieerde gegevens te creëren.
Typecontrole volgens klassenhiërarchie
Dit is wanneer u de taal kiest om typecontroles uit te voeren. Er zijn talen die besluiten dit te doen tijdens het compileren en andere tijdens de uitvoering. Andere talen compileren niet eens, wat je niet de mogelijkheid geeft om wat voor soort controle dan ook uit te voeren, tot runtime.
Wanneer de controle tijdens runtime wordt uitgevoerd, wordt dit een dynamische controle genoemd. Als het daarentegen tijdens het compileren wordt gedaan, wordt het statische controle genoemd.
Vanwege het feit dat bij de statische controle de fouten vanaf het begin ontstaan, zonder het moment van uitvoering te bereiken, wordt vaak gezegd dat dit type controle veiliger is. Dynamisch testen maakt echter gedeeltelijke implementaties mogelijk, zonder dat de code herhaaldelijk hoeft te worden herschreven.
Hoe werkt het?
De eerste stap om een probleem onder dit paradigma op te lossen, is het vinden van de objecten of entiteiten van het probleemdomein. Vervolgens is het nodig om de manier te vinden waarop deze entiteiten met elkaar omgaan om het probleem op te lossen, door de berichten vast te stellen die de objecten verzenden, in welke volgorde en onder welke voorwaarden. Ten slotte moet je het gedrag van de objecten implementeren, verwijzend naar de reactie die ze geven met betrekking tot de berichten.
Samenvattend, wanneer een programma wordt uitgevoerd onder het objectgeoriënteerde programmeerparadigma, gebeuren er drie dingen: objecten worden naar behoefte gemaakt, berichten stromen van het ene object naar het andere parallel aan de informatieverwerking door het programma, en wanneer objecten niet langer nodig zijn, ze worden verwijderd om geheugen vrij te maken in het systeem.
Sleutelbegrippen
Om iets meer te begrijpen over wat is objectgeoriënteerd programmeren?, moeten we de volgende basisconcepten noemen:
- Object: het verwijst naar de entiteit die de ontvanger van berichten kan zijn, terwijl het erop kan reageren en berichten naar andere objecten kan verzenden. Het is de entiteit die gedrag vertoont.
- Identiteit: het is het aspect dat het ene object van het andere onderscheidt.
- Bericht: Dit is de resulterende interactie tussen een entiteit die een dienst aanvraagt en een andere die deze levert.
- Clientobject: Het is degene die het bericht verzendt.
- Ontvangerobject: Het is het object dat het bericht ontvangt.
- Delegatie: verwijst naar het verzenden van berichten van een object naar andere objecten. Wanneer een object de medewerking van anderen nodig heeft om op berichten te kunnen reageren.
- Gedrag: Dit zijn de reacties op de berichten die door een ontvangend object worden ontvangen.
- Status: Verwijst naar de huidige situatie van elk object.
- Verantwoordelijkheid: Het is de interactie tussen de staat en het gedrag van een object.
- Methode: Het verwijst naar de implementatie van het antwoord dat door een object op een ontvangen bericht wordt gegeven.
- Polymorfisme: dit is het vermogen van sommige objecten om op dezelfde boodschap te reageren, maar op verschillende manieren.
- Klassen: het zijn verzamelingen objecten die zich op dezelfde manier gedragen. Ze kunnen worden gedefinieerd door de programmeur. Het zijn mentale schema's die het mogelijk maken om objecten te abstraheren en te bepalen hoe ze zich tot elkaar verhouden.
- Attribuut: Het verwijst naar een interne variabele van het object dat is gemaakt om een deel van zijn status op te slaan.
- Contract: Verwijst naar de kennis van wat elk onderdeel biedt en de manier om ermee te verbinden.
Probleemoplossing op basis van objectgeoriënteerd programmeren
Zodra het probleem is geïdentificeerd en de mogelijke oplossing is voorgesteld, is het nodig om het in een programmeertaal te transcriberen zodat het door een computer kan worden uitgevoerd met behulp van een programma. Onder de methodologie van objectgeoriënteerd programmeren worden de volgende fasen gedefinieerd:
- Definitie van het programma: Het behandelt de schematische beschrijving van het probleem, op een duidelijke, begrijpelijke en goed gedefinieerde manier. Het gaat om de identificatie van de herkomst en het aspect van de te verwerken gegevens, evenals de beschrijving van de resultaten en de wijze waarop deze zullen worden gepresenteerd.
- Objectgeoriënteerde analyse en ontwerp: verwijst naar de identificatie en beschrijving van objecten in het probleemdomein. Daarna worden de te volgen attributen, relaties en methoden vastgesteld, dit om de klassen te definiëren die in een specifieke programmeertaal zullen worden geïmplementeerd.
- Programmering: in principe verwijst het naar de transcriptie van het programma, inclusief het correct schrijven van de code in een programmeertaal, met behulp van een ontwikkelingsstijl die de kwaliteit van het product kan garanderen, wat de juiste oplossing van het probleem zal veroorzaken. Deze fase omvat de constructie van algoritmen, de uitwerking van stroomdiagrammen en de uiteindelijke programmering, het doorlopen van de desktoptests, de codering, compilatie en uitvoering van het programma.
- Documentatie: Het omvat de beschrijving van de volgorde van stappen die nodig zijn om de oplossing van een probleem te bereiken. Het impliceert de opname van commentaarregels die de betekenis van de coderegels die verwarrend kunnen zijn, verduidelijken of uitleggen, met name die welke verwijzen naar identifiers en gedeclareerde datastructuren, controlestructuren en -methoden en hun parameters. Deze fase is essentieel voor het succes van het eindproduct, want als de documentatie faalt, zijn de programma's moeilijk te lezen en te debuggen, en meer nog, hun wijziging en onderhoud wordt bijna onmogelijk.
In een andere geest kunnen we zeggen dat de functionaliteit van programmeertalen in de loop der jaren is toegenomen, voornamelijk door het verschijnen van nieuwe en gevarieerde toepassingsgebieden. Hoewel het waar is dat deze talen in het begin in feite werden gebruikt om grote hoeveelheden gegevens te verwerken en bepaalde numerieke berekeningen uit te voeren.
Nu worden programmeertalen gebruikt in bijna elk gebied van de samenleving, waaronder databasebeheer, het genereren van afbeeldingen en zelfs kunstmatige intelligentie, naast vele andere aspecten.
Vooral de geboorte van nieuwe software-engineeringtechnologieën heeft geleid tot de opkomst van de programmeertalen die we hieronder zullen zien.
Objectgeoriënteerde programmeertalen
Het zijn talen die zijn ontworpen om gegevens en applets in klassen te integreren. Deze kunnen eigenschappen van andere getransformeerde codes erven en aanleiding geven tot nieuwe kenmerken, die ook leiden tot een nieuwe programmeermethodologie.
Classificatie
Zoals we later zullen zien, zijn er meerdere programmeertalen die inspelen op het objectgeoriënteerde paradigma. Volgens hun manier van implementatie zijn ze geclassificeerd als:
- Terwijl ze het gedrag implementeren: het omvat de talen die zijn gebaseerd op klassen en op prototypen of voorbeelden.
- Als ze objectcreatie implementeren: Ze zijn gebaseerd op de uitvoeringstijd in het dynamische geheugengebied of de compilatietijd van de stapel.
- Volgens typecontrole: verwijst naar verificatie tijdens compilatie of verificatie tijdens runtime.
Onder de belangrijkste objectgeoriënteerde talen hebben we:
Koetjes en kalfjes
Het kan alleen worden geprogrammeerd onder het paradigma van objectgeoriënteerd programmeren. Het is een op klassen gebaseerde taal, die tijdens runtime objecten in het dynamische geheugengebied ontwerpt. Het voert alleen typecontroles uit tijdens runtime, dat wil zeggen, het is een dynamische controletaal.
Java
Het is een van de meest gebruikte talen van vandaag, het is volledig objectgeoriënteerd, met syntaxis vergelijkbaar met C en C ++. Het is platformonafhankelijk.
Net als Smalltalk is het een op klassen gebaseerde taal, die de objecten in het dynamische geheugengebied tijdens runtime maakt, maar geen typecontroles uitvoert tijdens runtime, maar eerder tijdens het compileren, met het verschil dat het een tussenliggende niet-uitvoerbare code creëert, afkomstig van een precompilatie. Dit maakt het een statische controletaal.
Java objectgeoriënteerd programmeren ze draaien op een virtuele machine die gespecialiseerd is in dit soort taal, die werkt alsof het een computer is en daarom hun uitvoering mogelijk maakt zonder ze te hoeven wijzigen. Dit type machine wordt een tolk genoemd.
JavaScript
In tegenstelling tot Smalltalk en Java is het een taal die afhankelijk is van prototyping of voorbeelden. Het wordt geïnterpreteerd en zonder typen, dat wil zeggen, het voert geen typecontroles uit tijdens runtime of tijdens compileren. Maakt tijdens runtime objecten in het dynamische geheugengebied. Omdat het geen compilatie heeft, wordt het een dynamisch gecontroleerde taal.
Het is een krachtige taal, dankzij de draagbaarheid en integratie, evenals de standaard en eenvoudige programmeertechnieken. Met andere woorden, JavaScript is een code die is ingebed in een webpagina, met als doel de dynamiek van die pagina te verbeteren.
C + +
Het vormt een uitbreiding van de traditionele C-taal, door de voordelen van deze taal te absorberen en ondersteuningen voor objecten op te nemen. Hoewel het drie verschillende programmeerparadigma's omvat, zoals: gestructureerd programmeren, generiek programmeren en objectgeoriënteerd programmeren, was hij het die de overgang van het gestructureerde paradigma naar het objectgeoriënteerde paradigma leidde.
Het is een veelzijdige taal, die zeer vaak wordt gebruikt door applicatieprogrammeurs, zowel in Windows als in GNU Linux. Maakt tijdens runtime objecten in dynamisch geheugen. Het richt zich in feite op prestaties, draagbaarheid en abstractie. Het grootste nadeel is dat bij het compileren een uitvoerbaar bestand wordt gegenereerd waarvan de code alleen geldig is voor het platform waarop de compilatie is uitgevoerd. Aan de andere kant, omdat het een uitvoerbare taal is, is het niet platformonafhankelijk.
C#
Het is een programmeertaal die draait tijdens runtime en is opgenomen in het .NET-platform, waarmee u uw bibliotheken kunt delen en herkennen. Het is volledig objectgeoriënteerd en maakt het mogelijk om allerlei soorten applicaties te maken.
Het vormt een evolutie van de C- en C ++ -talen, waardoor de complexiteit van de laatste wordt geëlimineerd, omdat het gemakkelijker te gebruiken is en de foutenmarge tijdens de werking ervan wordt verminderd, dankzij de acceptatie van precompilatie.
Python
Het is een multiplatformtaal, voornamelijk objectgeoriënteerd, maar omvat andere paradigma's zoals imperatief programmeren, functioneel programmeren en aspectgericht programmeren.
De zuivere syntaxis, die heel dicht bij natuurlijke taal ligt, bevordert het lezen van de code. Het is een echte aanrader om te beginnen in de programmeerwereld.
Het wordt uitgevoerd via een tussenprogramma, dat wil zeggen via een interpreter. Omdat het een semi-geïnterpreteerde taal is, is het flexibel en draagbaar. Het is dynamisch getypt, wat betekent dat het gegevenstype tijdens runtime wordt bepaald.
Pascal
Momenteel is het de taal die bij uitstek wordt gebruikt bij het leren van programmeren. Het heeft een eenvoudige syntaxis, met een zeer gestructureerde taal, die het lezen en interpreteren van de programma's vergemakkelijkt. De compilatie kan worden gedaan op elke machine die een Pascal-compiler heeft.
Ondanks dat het een gestructureerde taal is, maakt het objectgeoriënteerd programmeren mogelijk via de Turbo Pascal-versie. Het heeft een geïntegreerde omgeving, van waaruit het mogelijk is om de programma's te schrijven en te testen. Uiteindelijk is Pascal een taal voor algemene doeleinden.
Als het onderwerp dat u interesseert, te maken heeft met programmeren, nodig ik u uit om te lezen Wat is een algoritme in programmeren?