Klasy i programowanie obiektowe

function stworzUcznia(imie, oceny) {
  return {
    imie,
    oceny,
    srednia() {
      const suma = this.oceny.reduce((acc, o) => acc + o, 0);
      return suma / this.oceny.length;
    },
  };
}

const ola = stworzUcznia('Ola', [5, 4, 5]);
const bartek = stworzUcznia('Bartek', [3, 4]);
console.log(ola.srednia()); // 4.666…
console.log(bartek.srednia()); // 3.5
console.log(ola.srednia === bartek.srednia); // false – każdy obiekt ma WŁASNĄ kopię funkcji

class Uczen {
  // konstruktor uruchamia się przy każdym `new Uczen(...)`
  constructor(imie, oceny) {
    this.imie = imie;
    this.oceny = oceny;
  }

  // metoda – bez słowa `function`, bez przecinków między metodami
  srednia() {
    const suma = this.oceny.reduce((acc, o) => acc + o, 0);
    return suma / this.oceny.length;
  }

  opis() {
    return `${this.imie}: średnia ${this.srednia().toFixed(2)}`;
  }
}

const ola = new Uczen('Ola', [5, 4, 5]);
const bartek = new Uczen('Bartek', [3, 4]);
console.log(ola.opis()); // Ola: średnia 4.67
console.log(bartek.opis()); // Bartek: średnia 3.50
console.log(ola.srednia === bartek.srednia); // true – jedna wspólna metoda
console.log(typeof Uczen); // function – klasa to specjalny rodzaj funkcji

class Uczen {
  constructor(imie) {
    this.imie = imie;
  }
  przedstawSie() {
    return `Jestem ${this.imie}`;
  }
}
const ola = new Uczen('Ola');

console.log(Object.getPrototypeOf(ola) === Uczen.prototype); // true
console.log(Object.hasOwn(ola, 'imie')); // true – własne pole
console.log(Object.hasOwn(ola, 'przedstawSie')); // false – metoda jest w prototypie
console.log('przedstawSie' in ola); // true – `in` szuka też w prototypach
console.log(ola.toString()); // [object Object] – z Object.prototype, dwa piętra wyżej
console.log(ola.constructor === Uczen); // true

class Prostokat {
  constructor(a, b) {
    this.a = a;
    this.b = b;
  }

  // getter – czytasz jak pole, liczy się przy każdym odczycie
  get pole() {
    return this.a * this.b;
  }

  // setter – przypisanie przechodzi przez funkcję
  set bok(wartosc) {
    if (wartosc <= 0) {
      throw new RangeError('Bok musi być dodatni');
    }
    this.a = wartosc;
    this.b = wartosc; // kwadrat
  }
}

const p = new Prostokat(3, 4);
console.log(p.pole); // 12 – bez nawiasów!
p.bok = 5; // uruchamia setter
console.log(p.pole); // 25
console.log(typeof p.pole); // number – getter zwraca liczbę, nie funkcję

class KontoBankowe {
  // pola publiczne z wartością domyślną
  waluta = 'PLN';
  historia = [];

  // pole prywatne – TYLKO kod wewnątrz klasy ma do niego dostęp
  #saldo = 0;

  constructor(wlasciciel) {
    this.wlasciciel = wlasciciel;
  }

  wplac(kwota) {
    this.#sprawdzKwote(kwota);
    this.#saldo += kwota;
    this.historia.push(`+${kwota}`);
  }

  wyplac(kwota) {
    this.#sprawdzKwote(kwota);
    if (kwota > this.#saldo) throw new Error('Brak środków');
    this.#saldo -= kwota;
    this.historia.push(`-${kwota}`);
  }

  get saldo() {
    return this.#saldo; // odczyt jest dozwolony, ale tylko przez getter
  }

  // metoda prywatna
  #sprawdzKwote(kwota) {
    if (typeof kwota !== 'number' || kwota <= 0) throw new RangeError('Kwota musi być dodatnia');
  }
}

const konto = new KontoBankowe('Ola');
konto.wplac(200);
konto.wyplac(50);
console.log(konto.saldo); // 150
console.log(konto.historia); // ["+200", "-50"]
konto.saldo = 1000000; // getter bez settera: przypisanie jest ignorowane (w trybie ścisłym: TypeError)
console.log(konto.saldo); // 150 – dalej 150
console.log(Object.keys(konto)); // ["waluta", "historia", "wlasciciel"] – #saldo niewidoczne
console.log(JSON.stringify(konto)); // {"waluta":"PLN","historia":["+200","-50"],"wlasciciel":"Ola"}

class Sejf {
  #kod = '1234';
}
const s = new Sejf();
console.log(s.#kod); // SyntaxError: Private field '#kod' must be declared in an enclosing class

class Temperatura {
  static ileUtworzono = 0; // pole statyczne – jedno dla całej klasy
  static JEDNOSTKA = '°C';

  constructor(stopnie) {
    this.stopnie = stopnie;
    Temperatura.ileUtworzono++; // uwaga: przez nazwę klasy, nie this
  }

  // metoda statyczna – alternatywny „konstruktor”
  static zFahrenheita(f) {
    return new Temperatura(((f - 32) * 5) / 9);
  }

  // porównanie dwu instancji – nie należy do żadnej z nich
  static porownaj(a, b) {
    return a.stopnie - b.stopnie;
  }

  toString() {
    return `${this.stopnie.toFixed(1)}${Temperatura.JEDNOSTKA}`;
  }
}

const t1 = new Temperatura(21.5);
const t2 = Temperatura.zFahrenheita(100);
console.log(String(t2)); // 37.8°C
console.log(Temperatura.ileUtworzono); // 2
console.log([t2, t1].sort(Temperatura.porownaj).map(String)); // ["21.5°C", "37.8°C"]
console.log(t1.ileUtworzono); // undefined – statyczne nie ma na instancji

class Pracownik {
  constructor(imie, stawka) {
    this.imie = imie;
    this.stawka = stawka; // zł za godzinę
  }
  wynagrodzenie(godziny) {
    return this.stawka * godziny;
  }
  opis() {
    return `${this.imie} (${this.constructor.name})`;
  }
}

class Kierownik extends Pracownik {
  constructor(imie, stawka, premia) {
    super(imie, stawka); // 1. NAJPIERW konstruktor rodzica – tworzy this
    this.premia = premia; // 2. potem własne pola
  }

  // nadpisanie metody (override) z wykorzystaniem wersji rodzica
  wynagrodzenie(godziny) {
    return super.wynagrodzenie(godziny) + this.premia;
  }

  // nowa metoda, której Pracownik nie ma
  deleguj(zadanie) {
    return `${this.imie} deleguje: ${zadanie}`;
  }
}

const ania = new Pracownik('Ania', 40);
const marek = new Kierownik('Marek', 60, 1500);

console.log(ania.wynagrodzenie(160)); // 6400
console.log(marek.wynagrodzenie(160)); // 11100 = 9600 + 1500
console.log(marek.opis()); // Marek (Kierownik) – odziedziczone, this.constructor.name = klasa dziecka
console.log(marek.deleguj('raport')); // Marek deleguje: raport

console.log(marek instanceof Kierownik); // true
console.log(marek instanceof Pracownik); // true – dziecko „jest też” rodzicem
console.log(ania instanceof Kierownik); // false
console.log(Object.getPrototypeOf(Kierownik.prototype) === Pracownik.prototype); // true – dłuższy łańcuch

class Zwierze {
  constructor(imie) {
    this.imie = imie;
  }
}
class Pies extends Zwierze {
  constructor(imie, rasa) {
    this.rasa = rasa; // ReferenceError: Must call super constructor in derived class before accessing 'this'
    super(imie);
  }
}
new Pies('Reksio', 'kundel');

class Figura {
  constructor(nazwa) {
    this.nazwa = nazwa;
  }
  pole() {
    throw new Error(`${this.constructor.name} musi zaimplementować pole()`);
  }
  opis() {
    return `${this.nazwa}: ${this.pole().toFixed(2)} cm²`;
  }
}

class Kolo extends Figura {
  constructor(r) {
    super('koło');
    this.r = r;
  }
  pole() {
    return Math.PI * this.r ** 2;
  }
}

class Prostokat extends Figura {
  constructor(a, b) {
    super('prostokąt');
    this.a = a;
    this.b = b;
  }
  pole() {
    return this.a * this.b;
  }
}

const figury = [new Kolo(1), new Prostokat(2, 3), new Kolo(2)];
// ta pętla nie wie, z jaką figurą ma do czynienia – i nie musi
for (const f of figury) console.log(f.opis());
// koło: 3.14 cm²
// prostokąt: 6.00 cm²
// koło: 12.57 cm²
const suma = figury.reduce((acc, f) => acc + f.pole(), 0);
console.log(suma.toFixed(2)); // 21.71

class Licznik {
  constructor() {
    this.n = 0;
  }
  zwieksz() {
    this.n++;
    console.log('n =', this.n);
  }
}
const l = new Licznik();
l.zwieksz(); // n = 1 – wywołanie przez kropkę: this = l

const oderwana = l.zwieksz; // sama funkcja, bez obiektu
oderwana(); // TypeError: Cannot read properties of undefined (reading 'n')

class Licznik {
  n = 0;

  // ROZWIĄZANIE 3: pole klasy z funkcją strzałkową – strzałka bierze this z miejsca definicji,
  // czyli z instancji. Każdy obiekt ma własną kopię tej funkcji (koszt jak w fabryce), ale this nie ginie.
  zwiekszStrzalka = () => {
    this.n++;
  };

  zwieksz() {
    this.n++;
  }
}
const l = new Licznik();

// ROZWIĄZANIE 1: opakuj w strzałkę w miejscu przekazania
const przezStrzalke = () => l.zwieksz();
przezStrzalke();

// ROZWIĄZANIE 2: bind tworzy kopię funkcji z przypiętym this
const przypieta = l.zwieksz.bind(l);
przypieta();

const oderwana = l.zwiekszStrzalka;
oderwana(); // działa dzięki rozwiązaniu 3

console.log(l.n); // 3