Ir al contenido

03. Objektorientierung

Die Objektorientierte Programmierung (OOP) ist ein Paradigma, das auf der Entwicklung von Programmen basiert, indem es Elemente erstellt und verwaltet...

0Lesungen

03. Objektorientierte Programmierung in JavaScript

Sección titulada «03. Programación Orientada a Objetos en JavaScript»

Die objektorientierte Programmierung (OOP) ist ein Paradigma, das bei der Entwicklung von Programmen auf der Erstellung und Verwaltung unabhängiger Elemente, sogenannter „Objekte“, basiert, die Objekte der realen Welt simulieren. Jedes Objekt ist für bestimmte Aufgaben verantwortlich, und durch die Erstellung von Objekten und die Interaktion zwischen ihnen treiben wir die Programmausführung voran.

Heutzutage unterstützt JavaScript die OOP sowohl mit dem traditionellen „Prototypen“-System als auch mit der modernen Klassen-Syntax, die mit ES6 eingeführt wurde.

Die objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das auf der Entwicklung von Programmen durch die Erstellung und Verwaltung unabhängiger Elemente namens „Objekte“ basiert, welche Entitäten der realen Welt simulieren. Jedes Objekt ist für bestimmte Aufgaben verantwortlich, und durch die Interaktion zwischen ihnen wird die Ausführung des Programms vorangetrieben.

In JavaScript kann OOP auf zwei Arten angewendet werden:

  • Das Prototypensystem, bei dem wir ein prototypisches Object Literal erstellen, von dem andere erben.
  • Die moderne Klassen-Syntax (eingeführt in ES6), die anderen Sprachen näherkommt und die wir empfehlen.

Grundlagen der objektorientierten Programmierung

Sección titulada «Fundamento de la Programación Orientada a Objetos»

Es ist die Fähigkeit, eine Entität der realen Welt in einer vereinfachten Form innerhalb des Codes darzustellen. Dies wird durch die Definition von Klassen erreicht, die Eigenschaften (Attribute) und Verhaltensweisen (Methoden) von Objekten modellieren und unnötige oder komplexe Details verbergen.

Sie ist eine Vorlage, die das Erstellen von Objekten ermöglicht. Sie definiert die Struktur des Objekts durch die Festlegung von Eigenschaften und Verhaltensweisen.

Es ist eine Instanz einer Klasse (ein aus einer Klasse erstelltes Element). Es repräsentiert eine Entität der realen Welt und verfügt über zugehörige Merkmale (Eigenschaften) und Verhaltensweisen (Methoden). Jedes Objekt kann unterschiedliche Eigenschaftswerte haben, teilt aber dieselben in der Klasse definierten Methoden.

Es ist der Mechanismus zum Verbergen interner Details eines Objekts (Eigenschaften und Methoden), wobei nur eine Schnittstelle zur Interaktion mit ihm bereitgestellt wird. Durch private Methoden und Eigenschaften steuern wir den Zugriff auf die Eigenschaften und Methoden eines Objekts. Die Kapselung gewährleistet die Datenintegrität und ermöglicht es, die Implementierung (den Code) vor der externen Nutzung zu verbergen.

Ermöglicht die Definition neuer Klassen auf Basis bereits existierender Klassen (Superklasse). Die neuen Klassen (Subklassen) erben die Eigenschaften und Methoden der Elternklasse. Sie können auch neue Funktionalitäten hinzufügen oder das geerbte Verhalten ändern. Vererbung ist nützlich für die Wiederverwendung von Code und den Aufbau einer Klassenhierarchie.

Es ist die Fähigkeit eines Objekts, auf dieselbe Aktion oder Methode unterschiedlich zu reagieren oder sich anders zu verhalten (je nach Kontext). Dies ermöglicht es einer Methode mit demselben Namen, je nach der sie implementierenden Klasse unterschiedliche Aufgaben auszuführen. Dieser Prozess wird durch Vererbung und die Möglichkeit der Methodenüberschreibung in den Unterklassen realisiert.

Konstruktor: Dies ist eine spezielle Methode, die automatisch beim Erstellen eines Objekts ausgeführt wird. Sie dient der Initialisierung der Eigenschaften des Objekts.

Eigenschaften: Variablen, die die Merkmale oder den Zustand eines Objekts darstellen. Sie können Datentypen wie Zahlen, Booleans, Strings, Arrays, andere Objekte usw. sein.

Methoden: Funktionen, die das Verhalten eines Objekts definieren. Sie können Eingabeparameter entgegennehmen, Ergebnisse zurückgeben und die Eigenschaften des Objekts manipulieren.

// 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;
}
}

Instanziierung und Verwaltung von Objekten

Sección titulada «Instanciación y Gestión de Objetos»

Wir werden den Code ausführen, um Objekte zu instanziieren und zu verwalten.

// 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}`);

Wir werden Vererbung und Polymorphie in unseren Klassen implementieren.

// 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}`);