Ir al contenido

03. Orientação a Objetos

A Programação Orientada a Objetos (POO) é um paradigma que se baseia no desenvolvimento de programas na criação e gestão de elementos...

0lecturas

03. Programação Orientada a Objetos em JavaScript

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

A Programação Orientada a Objetos (POO) é um paradigma que se baseia no desenvolvimento de programas através da criação e gestão de elementos independentes denominados “objetos”, simulando objetos do mundo real. Cada objeto é responsável por tarefas específicas e, através da criação de objetos e da interação entre objetos, avançamos na execução do programa.

Atualmente, o JavaScript suporta a POO tanto com o sistema de “protótipos” tradicional quanto com a sintaxe moderna de classes introduzida no ES6.

A Programação Orientada a Objetos (POO) é um paradigma de programação que se baseia no desenvolvimento de programas através da criação e gestão de elementos independentes chamados “objetos”, que simulam entidades do mundo real. Cada objeto é responsável por tarefas concretas e, mediante a interação entre eles, avançamos na execução do programa.

No JavaScript, a POO pode ser aplicada de duas maneiras:

  • O sistema de protótipos, onde criamos um Object Literal protótipo e os demais herdam deste protótipo.
  • A sintaxe moderna de classes (introduzida no ES6), mais próxima de outras linguagens e que recomendamos.

É a capacidade de representar uma entidade do mundo real de forma simplificada dentro do código. Isso é alcançado definindo classes que modelam características (propriedades) e comportamentos (métodos) dos objetos e ocultando detalhes desnecessários ou complexos.

É um modelo que permite criar objetos. Define a estrutura do objeto a partir da definição de características e comportamentos.

É uma instância de uma classe (elemento criado a partir de uma classe). Representa uma entidade do mundo real e possui características (propriedades) e comportamentos (métodos) associados. Cada objeto pode ter valores de propriedades diferentes, mas compartilham os mesmos métodos definidos na classe.

É o mecanismo para ocultar os detalhes internos de um objeto (propriedades e métodos), expondo apenas uma interface para poder interagir com ele. Através de métodos e propriedades privadas, controlamos o acesso às propriedades e métodos de um objeto. O encapsulamento garante a integridade dos dados e permite ocultar sua implementação (o código) de seu uso externo.

Permite definir novas classes a partir de classes já existentes (superclasse). As novas classes (subclasses) herdam as propriedades e métodos da classe pai. Também podem adicionar novas funcionalidades ou modificar o comportamento herdado. A herança é útil para a reutilização de código e para estabelecer uma hierarquia de classes.

É a capacidade que um objeto possui de responder ou comportar-se de maneira diferente a uma mesma ação ou método (dependendo do contexto). Isso permite que um método com o mesmo nome realize diferentes tarefas dependendo da classe que o implementa. Este processo é implementado por meio da herança e da possibilidade de sobrescrever métodos nas subclasses.

Método construtor: É um método especial que é executado automaticamente ao criar um objeto. Serve para inicializar as propriedades do objeto.

Propriedades: Variáveis que representam as características ou o estado de um objeto. Podem ser de tipos de dados como números, booleanos, strings, arrays, outros objetos, etc.

Métodos: Funções que definem o comportamento de um objeto. Podem receber parâmetros de entrada, retornar resultados e manipular as propriedades do 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;
}
}

Executaremos o código para instanciar e gerir 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}`);

Estabeleceremos a herança e o polimorfismo em nossas classes.

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