Ir al contenido

03. Orientacja obiektowa

Programowanie obiektowe (POO) to paradygmat, który opiera się na rozwoju programów w tworzeniu i zarządzaniu elementami...

0odwiedzin

Programowanie obiektowe (POO) to paradygmat, który opiera się na rozwoju programów w tworzeniu i zarządzaniu niezależnymi elementami zwanymi 'obiektami', symulującymi obiekty ze świata rzeczywistego. Każdy obiekt jest odpowiedzialny za określone zadania, a poprzez tworzenie obiektów i interakcję między obiektami, posuwamy naprzód wykonanie programu.

Obecnie JavaScript obsługuje POO zarówno z tradycyjnym systemem 'prototypów', jak i z nowoczesną składnią klas wprowadzoną w ES6.

Programowanie obiektowe (POO) to paradygmat programowania, który opiera się na rozwoju programów w tworzeniu i zarządzaniu niezależnymi elementami zwanymi 'obiektami', które symulują podmioty ze świata rzeczywistego. Każdy obiekt jest odpowiedzialny za określone zadania, a poprzez interakcję między nimi, posuwamy naprzód wykonanie programu.

W JavaScript POO można stosować na dwa sposoby:

  • System prototypów, gdzie tworzymy prototyp Object Literal, a pozostałe obiekty dziedziczą po tym prototypie.
  • Nowoczesna składnia klas (wprowadzona w ES6), bliższa innym językom i zalecana.

Jest to zdolność do reprezentowania podmiotu ze świata rzeczywistego w uproszczonej formie w kodzie. Osiąga się to poprzez definiowanie klas, które modelują cechy (właściwości) i zachowania (metody) obiektów oraz ukrywanie zbędnych lub skomplikowanych szczegółów.

Jest to szablon, który pozwala tworzyć obiekty. Definiuje strukturę obiektu na podstawie cech i zachowań.

Jest to instancja klasy (element utworzony na podstawie klasy). Reprezentuje podmiot ze świata rzeczywistego i posiada cechy (właściwości) oraz zachowania (metody) z nim związane. Każdy obiekt może mieć różne wartości właściwości, ale współdzielą te same metody zdefiniowane w klasie.

Jest to mechanizm ukrywający wewnętrzne szczegóły obiektu (właściwości i metody), udostępniając jedynie interfejs do interakcji z nim. Dzięki metodom i właściwościom prywatnym, kontrolujemy dostęp do właściwości i metod obiektu. Enkapsulacja gwarantuje integralność danych oraz pozwala ukryć ich implementację (kod) przed zewnętrznym użyciem.

Pozwala definiować nowe klasy na podstawie istniejących klas (nadklasa). Nowe klasy (podklasy) dziedziczą właściwości i metody klasy nadrzędnej. Mogą również dodawać nowe funkcjonalności lub modyfikować zachowanie odziedziczone. Dziedziczenie jest przydatne do ponownego wykorzystania kodu oraz ustalenia hierarchii klas.

Jest to zdolność obiektu do reagowania lub zachowania się w różny sposób w odpowiedzi na tę samą akcję lub metodę (w zależności od kontekstu). Umożliwia to metodę o tym samym nazwie do wykonywania różnych zadań w zależności od klasy, która ją implementuje. Proces ten jest realizowany poprzez dziedziczenie oraz możliwość przepisywania metod w podklasach.

Metoda konstruktora: Jest to specjalna metoda, która jest wykonywana automatycznie podczas tworzenia obiektu. Służy do inicjowania właściwości obiektu.

Właściwości: Zmienne, które reprezentują cechy lub stan obiektu. Mogą być typu danych, takich jak liczby, wartości logiczne, łańcuchy, tablice, inne obiekty itp.

Metody: Funkcje, które definiują zachowanie obiektu. Mogą przyjmować parametry wejściowe, zwracać wyniki i modyfikować właściwości obiektu.

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

Wykonamy kod do instancjacji i zarządzania obiektami.

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

Ustalimy dziedziczenie i polimorfizm w naszych klasach.

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