Ir al contenido

03. Orientación a Objetos

La Programación Orientada a Objetos (POO) es un paradigma que se basa en el desarrollo de programas en la creación y gestión de elementos...

0lecturas

03. Programación Orientada a Objetos en JavaScript

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

La Programación Orientada a Objetos (POO) es un paradigma que se basa en el desarrollo de programas en la creación y gestión de elementos independientes denominados “objetos”, simulando objetos del mundo real. Cada objeto es responsable de unas tareas específicas y, mediante la creación de objetos y la interacción entre objetos, avanzamos la ejecución del programa.

Actualmente, JavaScript soporta la POO tanto con el sistema de “prototipos” tradicional como con la sintaxis moderna de clases introducida en ES6.

La Programación Orientada a Objetos (POO) es un paradigma de programación que se basa en el desarrollo de programas en la creación y gestión de elementos independientes llamados “objetos”, que simulan entidades del mundo real. Cada objeto es responsable de unas tareas concretas y, mediante la interacción entre ellos, avanzamos la ejecución del programa.

En JavaScript, la POO se puede aplicar de dos maneras:

  • El sistema de prototipos, donde creamos un Object Literal prototipo y los demás heredan de este prototipo.
  • La sintaxis moderna de clases (introducida en ES6), más próxima a otros lenguajes y que recomendamos.

Fundamento de la Programación Orientada a Objetos

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

Es la capacidad de representar una entidad del mundo real en una forma simplificada dentro del código. Esto se logra definiendo clases que modelan características (propiedades) y comportamientos (métodos) de los objetos y ocultando los detalles innecesarios o complejos.

Es una plantilla que permite crear objetos. Define la estructura del objeto a partir de definir características y comportamientos.

Es una instancia de una clase (elemento creado a partir de una clase). Representa una entidad del mundo real y dispone de características (propiedades) y comportamientos (métodos) asociados. Cada objeto puede tener valores de propiedades diferentes, pero comparten los mismos métodos definidos en la clase.

Es el mecanismo para ocultar los detalles internos de un objeto (propiedades y métodos), exponiendo únicamente una interfaz para poder interactuar con él. Mediante métodos y propiedades privadas, controlamos el acceso a las propiedades y métodos de un objeto. El encapsulamiento garantiza la integridad de los datos y permite ocultar su implementación (el código) de su uso externo.

Permite definir nuevas clases a partir de clases ya existentes (superclase). Las nuevas clases (subclases) heredan las propiedades y métodos de la clase padre. También pueden agregar nuevas funcionalidades o modificar el comportamiento heredado. La herencia es útil para la reutilización de código y establecer una jerarquía de clases.

Es la capacidad que dispone un objeto para responder o comportarse de manera diferente a una misma acción o método (en función del contexto). Esto permite a un método con el mismo nombre realizar diferentes tareas en función de la clase que lo implementa. Este proceso se implementa mediante la herencia y la posibilidad de sobreescribir métodos en las subclases.

Método constructor: Es un método especial que se ejecuta automáticamente al crear un objeto. Sirve para inicializar las propiedades del objeto.

Propiedades: Variables que representan las características o el estado de un objeto. Pueden ser de tipo de datos como números, booleanos, cadenas, arrays, otros objetos, etc.

Métodos: Funciones que definen el comportamiento de un objeto. Pueden recibir parámetros de entrada, retornar resultados y manipular las propiedades del objeto.

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

Ejecutaremos el código para instanciar y gestionar objetos.

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

Estableceremos la herencia y el polimorfismo en nuestras clases.

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