03. Objectgeoriënteerdheid
Objectgeoriënteerd programmeren (OOP) is een paradigma dat is gebaseerd op de ontwikkeling van programma's in de creatie en het beheer van elementen...
03. Objectgeoriënteerd programmeren in JavaScript
Sección titulada «03. Programación Orientada a Objetos en JavaScript»Objectgeoriënteerd programmeren (OOP) is een paradigma dat bij de ontwikkeling van programma's gebaseerd is op het creëren en beheren van onafhankelijke elementen die 'objecten' worden genoemd, die objecten uit de echte wereld simuleren. Elk object is verantwoordelijk voor specifieke taken en door het creëren van objecten en de interactie tussen objecten, brengen we de uitvoering van het programma vooruit.
Tegenwoordig ondersteunt JavaScript OOP zowel met het traditionele 'prototype'-systeem als met de moderne class-syntaxis die in ES6 is geïntroduceerd.
Objectgeoriënteerd programmeren (OOP) is een programmeerparadigma dat bij de ontwikkeling van programma's gebaseerd is op het creëren en beheren van onafhankelijke elementen genaamd 'objecten', die entiteiten uit de echte wereld simuleren. Elk object is verantwoordelijk voor specifieke taken en door de interactie tussen hen, brengen we de uitvoering van het programma vooruit.
In JavaScript kan OOP op twee manieren worden toegepast:
- Het prototypesysteem, waarbij we een prototype Object Literal creëren en de rest hiervan overerft.
- De moderne class-syntaxis (geïntroduceerd in ES6), die dichter bij andere talen ligt en die wij aanbevelen.
Fundamenten van Objectgeoriënteerd programmeren
Sección titulada «Fundamento de la Programación Orientada a Objetos»Abstractie:
Sección titulada «La Abstracción:»Het is het vermogen om een entiteit uit de echte wereld in een vereenvoudigde vorm binnen de code weer te geven. Dit wordt bereikt door klassen te definiëren die kenmerken (eigenschappen) en gedragingen (methoden) van objecten modelleren en de onnodige of complexe details verbergen.
Een Klasse:
Sección titulada «Una Clase:»Het is een sjabloon waarmee objecten kunnen worden gemaakt. Het definieert de structuur van het object door kenmerken en gedragingen te definiëren.
Een object:
Sección titulada «Un Objeto:»Het is een instantie van een klasse (een element dat is gemaakt op basis van een klasse). Het vertegenwoordigt een entiteit uit de echte wereld en beschikt over bijbehorende kenmerken (eigenschappen) en gedragingen (methoden). Elk object kan verschillende eigenschapswaarden hebben, maar ze delen dezelfde methoden die in de klasse zijn gedefinieerd.
Encapsulatie:
Sección titulada «El Encapsulamiento:»Het is het mechanisme om de interne details van een object (eigenschappen en methoden) te verbergen, waarbij alleen een interface wordt blootgesteld om ermee te kunnen communiceren. Door middel van private methoden en eigenschappen controleren we de toegang tot de eigenschappen en methoden van een object. Encapsulatie waarborgt de integriteit van de gegevens en maakt het mogelijk de implementatie (de code) te verbergen voor extern gebruik.
Overerving:
Sección titulada «La Herencia:»Maakt het mogelijk om nieuwe klassen te definiëren op basis van bestaande klassen (superklasse). De nieuwe klassen (subklassen) erven de eigenschappen en methoden van de ouderklasse. Ze kunnen ook nieuwe functionaliteiten toevoegen of het geërfde gedrag wijzigen. Overerving is nuttig voor het hergebruik van code en het opzetten van een klassenhiërarchie.
Polymorfisme:
Sección titulada «El Polimorfismo:»Het is het vermogen van een object om op een verschillende manier te reageren of zich anders te gedragen bij dezelfde actie of methode (afhankelijk van de context). Dit stelt een methode met dezelfde naam in staat om verschillende taken uit te voeren op basis van de klasse die het implementeert. Dit proces wordt geïmplementeerd via overerving en de mogelijkheid om methoden in subklassen te overschrijven.
Class-declaratie
Sección titulada «Declaración de Clases»Constructor: Dit is een speciale methode die automatisch wordt uitgevoerd bij het aanmaken van een object. Het dient om de eigenschappen van het object te initialiseren.
Eigenschappen: Variabelen die de kenmerken of de status van een object vertegenwoordigen. Deze kunnen datatypen zijn zoals getallen, booleans, strings, arrays, andere objecten, etc.
Methoden: Functies die het gedrag van een object definiëren. Ze kunnen invoerparameters ontvangen, resultaten retourneren en de eigenschappen van het object manipuleren.
// Declaració d'una classeclass Jugador { constructor(nom, vides) { // mètode constructor this.nom = nom; // propietat this.vides = vides; this.posicio = 100; this.punts = 0; }
moureJugador() { // mètode públic this.posicio += 5; }}Instantiëren en beheer van objecten
Sección titulada «Instanciación y Gestión de Objetos»We gaan de code uitvoeren om objecten te instantiëren en te beheren.
// Instanciació d'una classeconst jugador1 = new Jugador('Pepet', 3);const jugador2 = new Jugador('Lucky', 5);
// Accés a propietats i ús de mètodesconsole.log(`Nom Jugador 1:${jugador1.nom}`);console.log(`Nom Jugador 2:${jugador2.nom}`);
jugador1.moureJugador();jugador1.vides--;
for (let i = 0; i < 5; i++) { jugador2.moureJugador();}
console.log(`Vides Jugador 1:${jugador1.vides}`);console.log(`Posicio Jugador 2:${jugador2.posicio}`);Overerving en polymorfisme
Sección titulada «Herencia y Polimorfismo»We zullen overerving en polymorfisme in onze klassen implementeren.
// Classe base que representa un personatge del jocclass Entitat { constructor(nom, vides, posicio) { this.nom = nom; this.vides = vides; this.posicio = posicio; }
moure() { this.posicio.x += 1; this.posicio.y += 1; }}
// Herència: Jugador hereta propietats i mètodes d'Entitatclass Jugador extends Entitat { constructor(nom, vides, posicio) { super(nom, vides, posicio); // crida al constructor de la classe base this.punts = 0; // propietat específica de Jugador }
// Polimorfisme: Jugador redefineix el mètode moure() de la classe base moure() { this.posicio.y += 1; // Moviment vertical }
// Mètode propi del Jugador sumarPunts(enemic) { this.punts += 10; enemic.vides--; }}
// Herència: Enemic hereta propietats i mètodes d'Entitatclass Enemic extends Entitat { constructor(nom, vides, nivell) { super(nom, vides); this.nivell = nivell; // propietat específica de Enemic }
// Polimorfisme: Enemic redefineix el mètode moure() de la classe base moure() { this.posicio.x -= 1; // Moviment horitzontal }
// Mètode propi de l'Enemic atacar(jugador) { jugador.vides--; jugador.punts = jugador.punts - this.nivell; }}
const jugador = new Jugador('Jugador1', 3, { x: 100, y: 100 });const enemic = new Enemic('Enemic1', 2, { x: 300, y: 500 }, 1);
jugador.moure();enemic.moure();
jugador.sumarPunts(enemic);enemic.atacar(jugador);
console.log(`Vides Jugador: ${jugador.vides} i Posició: ${jugador.posicio.y}`);console.log(`Vides Enemic: ${enemic.vides} i Posició: ${enemic.posicio.x}`);
