Ir al contenido

03. Orientamento agli oggetti

La Programmazione Orientata agli Oggetti (POO) è un paradigma che si basa sullo sviluppo di programmi nella creazione e gestione di elementi...

0letture

03. Programmazione orientata agli oggetti in JavaScript

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

La Programmazione Orientata agli Oggetti (POO) è un paradigma che si basa sullo sviluppo di programmi attraverso la creazione e la gestione di elementi indipendenti denominati “oggetti”, che simulano oggetti del mondo reale. Ogni oggetto è responsabile di compiti specifici e, attraverso la creazione di oggetti e l'interazione tra essi, si procede con l'esecuzione del programma.

Attualmente, JavaScript supporta la POO sia con il tradizionale sistema di “prototipi” sia con la sintassi moderna delle classi introdotta in ES6.

La Programmazione Orientata agli Oggetti (POO) è un paradigma di programmazione che si basa sullo sviluppo di programmi attraverso la creazione e la gestione di elementi indipendenti chiamati “oggetti”, che simulano entità del mondo reale. Ogni oggetto è responsabile di compiti concreti e, attraverso l'interazione tra essi, si procede con l'esecuzione del programma.

In JavaScript, la POO può essere applicata in due modi:

  • Il sistema di prototipi, in cui creiamo un Object Literal prototipo e gli altri ereditano da questo prototipo.
  • La sintassi moderna delle classi (introdotta in ES6), più vicina ad altri linguaggi e che raccomandiamo.

Fondamenti della Programmazione Orientata agli Oggetti

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

È la capacità di rappresentare un'entità del mondo reale in una forma semplificata all'interno del codice. Ciò si ottiene definendo classi che modellano caratteristiche (proprietà) e comportamenti (metodi) degli oggetti e nascondendo i dettagli non necessari o complessi.

È un modello che permette di creare oggetti. Definisce la struttura dell'oggetto definendo caratteristiche e comportamenti.

È un'istanza di una classe (elemento creato a partire da una classe). Rappresenta un'entità del mondo reale e dispone di caratteristiche (proprietà) e comportamenti (metodi) associati. Ogni oggetto può avere valori di proprietà differenti, ma condividono gli stessi metodi definiti nella classe.

È il meccanismo per nascondere i dettagli interni di un oggetto (proprietà e metodi), esponendo esclusivamente un'interfaccia per poter interagire con esso. Attraverso metodi e proprietà private, controlliamo l'accesso alle proprietà e ai metodi di un oggetto. L'incapsulamento garantisce l'integrità dei dati e permette di nascondere la sua implementazione (il codice) dal suo uso esterno.

Permette di definire nuove classi a partire da classi già esistenti (superclasse). Le nuove classi (sottoclassi) ereditano le proprietà e i metodi della classe padre. Possono anche aggiungere nuove funzionalità o modificare il comportamento ereditato. L'ereditarietà è utile per il riutilizzo del codice e per stabilire una gerarchia di classi.

È la capacità di un oggetto di rispondere o comportarsi in modo diverso rispetto alla stessa azione o metodo (in base al contesto). Ciò consente a un metodo con lo stesso nome di eseguire compiti diversi in base alla classe che lo implementa. Questo processo viene implementato tramite l'ereditarietà e la possibilità di sovrascrivere i metodi nelle sottoclassi.

Metodo costruttore: È un metodo speciale che viene eseguito automaticamente alla creazione di un oggetto. Serve per inizializzare le proprietà dell'oggetto.

Proprietà: Variabili che rappresentano le caratteristiche o lo stato di un oggetto. Possono essere di tipi di dati come numeri, booleani, stringhe, array, altri oggetti, ecc.

Metodi: Funzioni che definiscono il comportamento di un oggetto. Possono ricevere parametri di input, restituire risultati e manipolare le proprietà dell'oggetto.

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

Eseguiremo il codice per istanziare e gestire gli oggetti.

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

Stabiliremo l'ereditarietà e il polimorfismo nelle nostre classi.

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