Ir al contenido

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...

0lecturas

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»

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.

Het is een sjabloon waarmee objecten kunnen worden gemaakt. Het definieert de structuur van het object door kenmerken en gedragingen te definiëren.

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.

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.

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.

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.

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 classe
class 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;
}
}

We gaan de code uitvoeren om objecten te instantiëren en te beheren.

// Instanciació d'una classe
const jugador1 = new Jugador('Pepet', 3);
const jugador2 = new Jugador('Lucky', 5);
// Accés a propietats i ús de mètodes
console.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}`);

We zullen overerving en polymorfisme in onze klassen implementeren.

// Classe base que representa un personatge del joc
class 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'Entitat
class 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'Entitat
class 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}`);