Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript

Właściwości statyczne i abstrakcyjne

22 min czytania ·
W tej lekcji4

"W Parku Jurajskim mamy protokoły i standardy, które obowiązują wszystkie obiekty danej klasy," wyjaśnia Dr. Henry Wu, główny genetyk parku. "Na przykład, wszystkie nasze wybiegi dla dinozaurów mają tę samą procedurę bezpieczeństwa, niezależnie od tego, który konkretny wybieg rozpatrujemy. Z drugiej strony, każdy gatunek dinozaura ma swój własny, unikalny wzór DNA, ale wszyscy wiemy, że DNA musi istnieć - nawet jeśli szczegóły różnią się między gatunkami."

W programowaniu obiektowym TypeScript oferuje dwie potężne koncepcje, które odzwierciedlają te idee:

  • Właściwości i metody statyczne - współdzielone przez wszystkie instancje klasy
  • Właściwości i metody abstrakcyjne - muszą być zaimplementowane przez klasy dziedziczące

W tym ćwiczeniu zagłębimy się w te koncepcje, tworząc zaawansowany system zarządzania genetyką i protokołami bezpieczeństwa Parku Jurajskiego.

Właściwości i metody statyczne

Elementy statyczne w klasie należą do samej klasy, a nie do jej instancji. Oznacza to, że:

  • Istnieje tylko jedna kopia każdej właściwości statycznej, niezależnie od liczby utworzonych instancji
  • Dostęp do właściwości statycznych uzyskuje się poprzez nazwę klasy, a nie przez instancję
  • Metody statyczne mogą być wywoływane bezpośrednio na klasie

Podstawowe użycie elementów statycznych

Przyjrzyjmy się, jak można wykorzystać elementy statyczne w kontekście Parku Jurajskiego:

class ProtokółBezpieczeństwa {
  // Właściwość statyczna - współdzielona przez wszystkie instancje
  static readonly POZIOM_KRYTYCZNY: number = 5;
  static readonly POZIOM_WYSOKI: number = 4;
  static readonly POZIOM_ŚREDNI: number = 3;
  static readonly POZIOM_NISKI: number = 2;
  static readonly POZIOM_MINIMALNY: number = 1;

  // Statyczna właściwość przechowująca aktualny globalny poziom zagrożenia parku
  private static _aktualnyPoziomZagrożenia: number = ProtokółBezpieczeństwa.POZIOM_NISKI;

  // Właściwości instancji
  private readonly obszar: string;
  private lokalnyPoziomZagrożenia: number;

  constructor(obszar: string) {
    this.obszar = obszar;
    this.lokalnyPoziomZagrożenia = ProtokółBezpieczeństwa._aktualnyPoziomZagrożenia;
    console.log(`Utworzono protokół bezpieczeństwa dla obszaru: ${obszar}`);
  }

  // Metoda statyczna dostępna bezpośrednio na klasie
  static podnieśGlobalnyPoziomZagrożenia(): void {
    if (this._aktualnyPoziomZagrożenia < this.POZIOM_KRYTYCZNY) {
      this._aktualnyPoziomZagrożenia++;
      console.log(`UWAGA: Podniesiono globalny poziom zagrożenia do ${this._aktualnyPoziomZagrożenia}`);

      // Wywołanie innej metody statycznej
      this.powiadomOpoziomieZagrożenia();
    } else {
      console.log("UWAGA: Osiągnięto już maksymalny poziom zagrożenia!");
    }
  }

  // Inna metoda statyczna
  static obniżGlobalnyPoziomZagrożenia(): void {
    if (this._aktualnyPoziomZagrożenia > this.POZIOM_MINIMALNY) {
      this._aktualnyPoziomZagrożenia--;
      console.log(`Obniżono globalny poziom zagrożenia do ${this._aktualnyPoziomZagrożenia}`);
    } else {
      console.log("Poziom zagrożenia jest już minimalny.");
    }
  }

  // Statyczny getter
  static get aktualnyPoziomZagrożenia(): number {
    return this._aktualnyPoziomZagrożenia;
  }

  // Prywatna metoda statyczna
  private static powiadomOpoziomieZagrożenia(): void {
    console.log(`Powiadomienie: Aktualny poziom zagrożenia parku: ${this._aktualnyPoziomZagrożenia}`);
  }

  // Metoda instancji korzystająca z właściwości statycznych
  aktualizujLokalnyPoziomZagrożenia(): void {
    // Aktualizacja lokalnego poziomu na podstawie globalnego
    this.lokalnyPoziomZagrożenia = ProtokółBezpieczeństwa._aktualnyPoziomZagrożenia;
    console.log(`Obszar ${this.obszar}: zaktualizowano poziom zagrożenia do ${this.lokalnyPoziomZagrożenia}`);
  }

  get statusBezpieczeństwa(): string {
    const poziomy = [
      "NIEZNANY",
      "MINIMALNY",
      "NISKI",
      "ŚREDNI",
      "WYSOKI",
      "KRYTYCZNY"
    ];

    return `Obszar: ${this.obszar}, Poziom zagrożenia: ${poziomy[this.lokalnyPoziomZagrożenia]}`;
  }
}

// Użycie właściwości i metod statycznych - bez tworzenia instancji!
console.log("Domyślny poziom zagrożenia:", ProtokółBezpieczeństwa.aktualnyPoziomZagrożenia);

// Wywołanie metody statycznej bezpośrednio na klasie
ProtokółBezpieczeństwa.podnieśGlobalnyPoziomZagrożenia();
ProtokółBezpieczeństwa.podnieśGlobalnyPoziomZagrożenia();

// Tworzenie instancji klasy
const protokółCentralny = new ProtokółBezpieczeństwa("Centrum Operacyjne");
const protokółWybieg = new ProtokółBezpieczeństwa("Wybieg T-Rex");

// Wyświetlenie statusu bezpieczeństwa
console.log(protokółCentralny.statusBezpieczeństwa);
console.log(protokółWybieg.statusBezpieczeństwa);

// Ponowne podniesienie globalnego poziomu zagrożenia
ProtokółBezpieczeństwa.podnieśGlobalnyPoziomZagrożenia();

// Aktualizacja lokalnych poziomów zagrożenia
protokółCentralny.aktualizujLokalnyPoziomZagrożenia();
protokółWybieg.aktualizujLokalnyPoziomZagrożenia();

// Sprawdzenie zaktualizowanych statusów
console.log(protokółCentralny.statusBezpieczeństwa);
console.log(protokółWybieg.statusBezpieczeństwa);

W powyższym przykładzie:

  1. Stałe poziomów zagrożenia są właściwościami statycznymi, dostępnymi bezpośrednio przez klasę
  2. Statyczna właściwość _aktualnyPoziomZagrożenia jest współdzielona przez wszystkie instancje
  3. Metody statyczne mogą modyfikować statyczne właściwości i wywoływać inne metody statyczne
  4. Instancje klasy mogą aktualizować swoje wewnętrzne stany na podstawie statycznych właściwości

Kiedy używać elementów statycznych

Elementy statyczne są szczególnie przydatne w następujących przypadkach:

  1. Stałe i konfiguracja - Wartości, które pozostają niezmienne dla wszystkich instancji klasy
  2. Stan globalny - Kiedy potrzebujemy wartości współdzielonej przez wszystkie instancje
  3. Metody narzędziowe - Funkcje pomocnicze, które nie wymagają stanu instancji
  4. Metody fabryczne - Alternatywne sposoby tworzenia instancji klasy

Oto bardziej rozbudowany przykład pokazujący różne zastosowania elementów statycznych:

class GenetycznyRejestr {
  // Stałe statyczne
  static readonly BAZA_NUKLEOTYDÓW = ["A", "C", "G", "T"];
  static readonly MIN_DŁUGOŚĆ_DNA = 1000000;

  // Stan globalny
  private static _liczbaZarejestrowanychGatunków: number = 0;
  private static _rejestracjeGatunków: Map<string, string> = new Map();

  // Właściwości instancji
  private id: string;
  private sekwencjaDNA: string;
  private nazwa: string;

  constructor(nazwa: string, sekwencjaDNA: string) {
    if (sekwencjaDNA.length < GenetycznyRejestr.MIN_DŁUGOŚĆ_DNA) {
      throw new Error(`Sekwencja DNA jest za krótka. Wymagane minimum: ${GenetycznyRejestr.MIN_DŁUGOŚĆ_DNA} par zasad.`);
    }

    this.nazwa = nazwa;
    this.sekwencjaDNA = sekwencjaDNA;
    this.id = GenetycznyRejestr.wygenerujId(nazwa);

    // Rejestracja nowego gatunku
    GenetycznyRejestr._rejestracjeGatunków.set(this.id, nazwa);
    GenetycznyRejestr._liczbaZarejestrowanychGatunków++;
  }

  // Metoda narzędziowa - tworzy ID na podstawie nazwy
  private static wygenerujId(nazwa: string): string {
    const timestamp = Date.now();
    const cleanName = nazwa.toLowerCase().replace(/[^a-z0-9]/g, "");
    return `DNO-${cleanName}-${timestamp}`;
  }

  // Metoda fabryczna - tworzy instancję z losowym DNA
  static utwórzTestowyGatunek(nazwa: string): GenetycznyRejestr {
    const długośćDNA = this.MIN_DŁUGOŚĆ_DNA + Math.floor(Math.random() * 500000);
    let sekwencja = "";

    for (let i = 0; i < długośćDNA; i++) {
      const randomIndex = Math.floor(Math.random() * this.BAZA_NUKLEOTYDÓW.length);
      sekwencja += this.BAZA_NUKLEOTYDÓW[randomIndex];
    }

    return new GenetycznyRejestr(nazwa, sekwencja);
  }

  // Metoda narzędziowa - weryfikuje poprawność sekwencji DNA
  static weryfikujSekwencję(sekwencja: string): boolean {
    if (sekwencja.length < this.MIN_DŁUGOŚĆ_DNA) return false;

    // Sprawdza, czy sekwencja zawiera tylko dozwolone nukleotydy
    for (const nukleotyd of sekwencja) {
      if (!this.BAZA_NUKLEOTYDÓW.includes(nukleotyd)) {
        return false;
      }
    }

    return true;
  }

  // Getter dla statycznej właściwości
  static get liczbaZarejestrowanychGatunków(): number {
    return this._liczbaZarejestrowanychGatunków;
  }

  // Statyczna metoda zwracająca wszystkie zarejestrowane gatunki
  static pobierzWszystkieGatunki(): string[] {
    return Array.from(this._rejestracjeGatunków.values());
  }

  // Instancyjna metoda używająca statycznych pól
  analizujSekwencję(): { proporcje: Record<string, number>, długość: number } {
    const proporcje: Record<string, number> = {};

    // Inicjalizacja liczników dla każdego nukleotydu
    GenetycznyRejestr.BAZA_NUKLEOTYDÓW.forEach(n => {
      proporcje[n] = 0;
    });

    // Zliczanie nukleotydów
    for (const nukleotyd of this.sekwencjaDNA) {
      proporcje[nukleotyd]++;
    }

    // Konwersja na procenty
    GenetycznyRejestr.BAZA_NUKLEOTYDÓW.forEach(n => {
      proporcje[n] = Number((proporcje[n] / this.sekwencjaDNA.length * 100).toFixed(2));
    });

    return {
      proporcje,
      długość: this.sekwencjaDNA.length
    };
  }

  // Gettery instancji
  get identyfikator(): string {
    return this.id;
  }

  get gatunekNazwa(): string {
    return this.nazwa;
  }
}

// Korzystanie z metod i właściwości statycznych
console.log("Minimalna długość DNA:", GenetycznyRejestr.MIN_DŁUGOŚĆ_DNA);
console.log("Dostępne nukleotydy:", GenetycznyRejestr.BAZA_NUKLEOTYDÓW.join(", "));

// Weryfikacja przykładowej sekwencji
const przykładowaSekwencja = "ACGTACGTACGT".repeat(100000); // Powielenie, aby osiągnąć min. długość
console.log("Weryfikacja sekwencji:", GenetycznyRejestr.weryfikujSekwencję(przykładowaSekwencja));

// Tworzenie instancji za pomocą metody fabrycznej
const trex = GenetycznyRejestr.utwórzTestowyGatunek("Tyrannosaurus Rex");
const raptor = GenetycznyRejestr.utwórzTestowyGatunek("Velociraptor");
const trike = GenetycznyRejestr.utwórzTestowyGatunek("Triceratops");

// Sprawdzenie, ile gatunków zostało zarejestrowanych
console.log("Liczba zarejestrowanych gatunków:", GenetycznyRejestr.liczbaZarejestrowanychGatunków);
console.log("Lista gatunków:", GenetycznyRejestr.pobierzWszystkieGatunki());

// Użycie metod instancji
const analizaTrex = trex.analizujSekwencję();
console.log(`Analiza ${trex.gatunekNazwa} (ID: ${trex.identyfikator}):`);
console.log(`Długość sekwencji: ${analizaTrex.długość} par zasad`);
console.log("Proporcje nukleotydów:", analizaTrex.proporcje);

Ten przykład pokazuje:

  1. Użycie stałych statycznych (BAZA_NUKLEOTYDÓW, MIN_DŁUGOŚĆ_DNA)
  2. Globalny stan śledzący liczbę i rejestrację gatunków
  3. Statyczne metody narzędziowe jak weryfikujSekwencję i wygenerujId
  4. Metodę fabryczną utwórzTestowyGatunek tworzącą instancje z losowymi danymi
  5. Jak metody instancji mogą korzystać z właściwości statycznych

Klasy i metody abstrakcyjne

Klasy abstrakcyjne w TypeScript definiują szablon, który musi być zaimplementowany przez klasy dziedziczące. Nie można tworzyć instancji klasy abstrakcyjnej bezpośrednio - służy ona jako bazowy "wzorzec" dla innych klas.

Metody abstrakcyjne, określone w klasie abstrakcyjnej, muszą być zaimplementowane przez klasy dziedziczące. Definiują one kontrakt, określający, jakie metody muszą być dostępne, ale nie zawierają własnej implementacji.

Podstawy klas abstrakcyjnych

Zobaczmy, jak wykorzystać klasy abstrakcyjne w kontekście Parku Jurajskiego:

// Abstrakcyjna klasa bazowa dla wszystkich dinozaurów
abstract class Dinozaur {
  // Właściwości wspólne dla wszystkich dinozaurów
  private _id: string;
  protected _nazwa: string;
  protected _gatunek: string;
  protected _wiek: number;
  protected _waga: number;

  constructor(id: string, nazwa: string, gatunek: string, wiek: number, waga: number) {
    this._id = id;
    this._nazwa = nazwa;
    this._gatunek = gatunek;
    this._wiek = wiek;
    this._waga = waga;
  }

  // Gettery
  get id(): string { return this._id; }
  get nazwa(): string { return this._nazwa; }
  get gatunek(): string { return this._gatunek; }
  get wiek(): number { return this._wiek; }
  get waga(): number { return this._waga; }

  // Metody implementowane we wszystkich klasach pochodnych
  abstract obliczZapotrzebowanieKaloryczne(): number;
  abstract określPoziomZagrożenia(): number;

  // Abstrakcyjna właściwość - musi być zaimplementowana w klasach pochodnych
  abstract get typDiety(): string;

  // Konkretna metoda (nie abstrakcyjna) - dostępna we wszystkich klasach pochodnych
  pobierzPodstawoweDane(): string {
    return `${this._nazwa} (${this._gatunek}) - ID: ${this._id}, Wiek: ${this._wiek} lat, Waga: ${this._waga} kg`;
  }

  // Metoda korzystająca z metod abstrakcyjnych
  wygenerujRaportDinozaura(): string {
    const kalorie = this.obliczZapotrzebowanieKaloryczne();
    const poziomZagrożenia = this.określPoziomZagrożenia();

    return `
=== RAPORT DINOZAURA ===
${this.pobierzPodstawoweDane()}
Typ diety: ${this.typDiety}
Dzienne zapotrzebowanie kaloryczne: ${kalorie} kcal
Poziom zagrożenia: ${poziomZagrożenia}/10
======================
    `;
  }
}

// Klasa dziedzicząca po klasie abstrakcyjnej
class DrapieżnyDinozaur extends Dinozaur {
  private _siłaUgryzienia: number;
  private _prędkośćBiegu: number;

  constructor(
    id: string,
    nazwa: string,
    gatunek: string,
    wiek: number,
    waga: number,
    siłaUgryzienia: number,
    prędkośćBiegu: number
  ) {
    super(id, nazwa, gatunek, wiek, waga);
    this._siłaUgryzienia = siłaUgryzienia;
    this._prędkośćBiegu = prędkośćBiegu;
  }

  // Gettery
  get siłaUgryzienia(): number { return this._siłaUgryzienia; }
  get prędkośćBiegu(): number { return this._prędkośćBiegu; }

  // Implementacja abstrakcyjnej właściwości
  get typDiety(): string {
    return "mięsożerny";
  }

  // Implementacje metod abstrakcyjnych
  obliczZapotrzebowanieKaloryczne(): number {
    // Dla drapieżników używamy złożonego wzoru
    return Math.round(this._waga * 0.6 * (this._prędkośćBiegu * 0.2));
  }

  określPoziomZagrożenia(): number {
    // Poziom zagrożenia zależy od siły ugryzienia, prędkości i wagi
    const bazowy = (this._siłaUgryzienia * 0.7 + this._prędkośćBiegu * 0.3) / 100;
    return Math.min(10, Math.max(1, Math.round(bazowy)));
  }

  // Metoda specyficzna dla drapieżników
  poluj(): string {
    return `${this._nazwa} poluje z prędkością ${this._prędkośćBiegu} km/h i siłą ugryzienia ${this._siłaUgryzienia} PSI`;
  }
}

// Inna klasa dziedzicząca
class RoślinożernyDinozaur extends Dinozaur {
  private _długośćSzyi: number;
  private _typPancerza: "brak" | "lekki" | "średni" | "ciężki";

  constructor(
    id: string,
    nazwa: string,
    gatunek: string,
    wiek: number,
    waga: number,
    długośćSzyi: number,
    typPancerza: "brak" | "lekki" | "średni" | "ciężki"
  ) {
    super(id, nazwa, gatunek, wiek, waga);
    this._długośćSzyi = długośćSzyi;
    this._typPancerza = typPancerza;
  }

  // Gettery
  get długośćSzyi(): number { return this._długośćSzyi; }
  get typPancerza(): string { return this._typPancerza; }

  // Implementacja abstrakcyjnej właściwości
  get typDiety(): string {
    return "roślinożerny";
  }

  // Implementacje metod abstrakcyjnych
  obliczZapotrzebowanieKaloryczne(): number {
    // Dla roślinożerców używamy prostszego wzoru - potrzebują więcej kalorii na kilogram
    return Math.round(this._waga * 0.8);
  }

  określPoziomZagrożenia(): number {
    // Poziom zagrożenia jest niższy dla roślinożerców, ale zależy od wagi i typu pancerza
    let bazowy = this._waga / 1000;

    // Modyfikator zależny od pancerza
    const modyfikatoryPancerza = {
      "brak": 0,
      "lekki": 1,
      "średni": 2,
      "ciężki": 3
    };

    bazowy += modyfikatoryPancerza[this._typPancerza];

    return Math.min(7, Math.max(1, Math.round(bazowy))); // Maks. 7 dla roślinożerców
  }

  // Metoda specyficzna dla roślinożerców
  pasięSię(): string {
    const wysokośćSięgania = this._długośćSzyi > 2 ? "wysokich" : "niskich";
    return `${this._nazwa} pasie się, zjadając rośliny z ${wysokośćSięgania} partii drzew`;
  }
}

// Nie możemy utworzyć instancji klasy abstrakcyjnej
// const nieprawidłowy = new Dinozaur("ID", "Nazwa", "Gatunek", 1, 100); // Błąd!

// Tworzenie instancji klas pochodnych
const trex = new DrapieżnyDinozaur("T-REX-1", "Rex", "Tyrannosaurus", 8, 7000, 12800, 32);
const stegozaur = new RoślinożernyDinozaur("STEG-1", "Spike", "Stegosaurus", 12, 5000, 1.2, "ciężki");
const diplodok = new RoślinożernyDinozaur("DIPL-1", "Dippy", "Diplodocus", 15, 16000, 6.5, "brak");

// Korzystanie z metod zaimplementowanych w klasach pochodnych
console.log(trex.wygenerujRaportDinozaura());
console.log(stegozaur.wygenerujRaportDinozaura());
console.log(diplodok.wygenerujRaportDinozaura());

// Korzystanie z metod specyficznych dla danej klasy
console.log(trex.poluj());
console.log(stegozaur.pasięSię());

// Dla obu typów dinozaurów możemy korzystać z metod klasy bazowej
console.log(trex.pobierzPodstawoweDane());
console.log(diplodok.pobierzPodstawoweDane());

W powyższym przykładzie:

  1. Dinozaur to klasa abstrakcyjna zawierająca wspólne właściwości i metody
  2. Abstrakcyjne metody obliczZapotrzebowanieKaloryczne() i określPoziomZagrożenia() muszą być zaimplementowane przez klasy dziedziczące
  3. Abstrakcyjna właściwość typDiety musi być zdefiniowana w klasach pochodnych
  4. Klasy DrapieżnyDinozaur i RoślinożernyDinozaur implementują abstrakcyjne metody i właściwości
  5. Nie można utworzyć instancji klasy Dinozaur bezpośrednio

Zastosowanie abstrakcyjnych klas i metod

Klasy abstrakcyjne są szczególnie przydatne w następujących przypadkach:

  1. Definiowanie wspólnego interfejsu - Określenie spójnego zestawu metod dla grupy powiązanych klas
  2. Współdzielenie kodu - Zapewnienie wspólnej implementacji dla grup klas
  3. Wymuszanie kontraktu - Gwarancja, że wszystkie klasy pochodne zaimplementują wymagane metody
  4. Tworzenie hierarchii typów - Budowanie złożonych relacji między typami

Zobaczmy bardziej zaawansowany przykład, łączący abstrakcyjne klasy i metody z elementami statycznymi w systemie zarządzania protokołami bezpieczeństwa Parku Jurajskiego:

// Typy pomocnicze
type PoziomAlertów = "normalny" | "podwyższony" | "wysoki" | "krytyczny";
type StatusSystem = "aktywny" | "nieaktywny" | "w_konserwacji" | "awaria";

// Interfejs dla systemów monitorujących
interface SystemMonitorujący {
  rozpocznijMonitorowanie(): void;
  zakończMonitorowanie(): void;
  pobierzAktualnyStatus(): StatusSystem;
}

// Abstrakcyjna klasa bazowa dla wszystkich systemów bezpieczeństwa
abstract class SystemBezpieczeństwa implements SystemMonitorujący {
  // Statyczne właściwości - dla wszystkich systemów bezpieczeństwa
  private static _poziomAlertówParku: PoziomAlertów = "normalny";
  private static _aktywneSystemy: Set<string> = new Set();
  private static _incydenty: Array<{data: Date, typSystemu: string, lokalizacja: string, opis: string}> = [];

  // Zwykłe właściwości
  protected _id: string;
  protected _lokalizacja: string;
  protected _status: StatusSystem;
  protected _czyMonitorowany: boolean;
  protected _dataPrzeglądu: Date;

  constructor(id: string, lokalizacja: string) {
    this._id = id;
    this._lokalizacja = lokalizacja;
    this._status = "nieaktywny";
    this._czyMonitorowany = false;
    this._dataPrzeglądu = new Date();

    // Rejestracja systemu
    SystemBezpieczeństwa.zarejestrujSystem(id, this.constructor.name);
  }

  // Statyczne metody
  static zarejestrujSystem(id: string, typSystemu: string): void {
    console.log(`Zarejestrowano nowy system bezpieczeństwa: ${typSystemu} (ID: ${id})`);
  }

  static zgłośIncydent(typSystemu: string, lokalizacja: string, opis: string): void {
    const incydent = {
      data: new Date(),
      typSystemu,
      lokalizacja,
      opis
    };

    this._incydenty.push(incydent);
    console.log(`ALERT: Zgłoszono incydent w lokalizacji ${lokalizacja}: ${opis}`);

    // Automatycznie podnosimy poziom alertów
    if (this._poziomAlertówParku === "normalny") {
      this.zmieńPoziomAlertów("podwyższony");
    } else if (this._poziomAlertówParku === "podwyższony") {
      this.zmieńPoziomAlertów("wysoki");
    } else if (this._poziomAlertówParku === "wysoki") {
      this.zmieńPoziomAlertów("krytyczny");
    }
  }

  static zmieńPoziomAlertów(nowyPoziom: PoziomAlertów): void {
    this._poziomAlertówParku = nowyPoziom;
    console.log(`UWAGA: Zmieniono poziom alertów parku na: ${nowyPoziom.toUpperCase()}`);
  }

  static get poziomAlertów(): PoziomAlertów {
    return this._poziomAlertówParku;
  }

  static get ostatnieIncydenty(): Array<{data: Date, typSystemu: string, lokalizacja: string, opis: string}> {
    // Zwracamy 5 ostatnich incydentów
    return [...this._incydenty].slice(-5);
  }

  // Gettery instancji
  get id(): string { return this._id; }
  get lokalizacja(): string { return this._lokalizacja; }
  get status(): StatusSystem { return this._status; }

  // Implementacja interfejsu SystemMonitorujący
  rozpocznijMonitorowanie(): void {
    this._czyMonitorowany = true;
    SystemBezpieczeństwa._aktywneSystemy.add(this._id);
    console.log(`Rozpoczęto monitorowanie systemu ${this.constructor.name} w lokalizacji ${this._lokalizacja}`);
  }

  zakończMonitorowanie(): void {
    this._czyMonitorowany = false;
    SystemBezpieczeństwa._aktywneSystemy.delete(this._id);
    console.log(`Zakończono monitorowanie systemu ${this.constructor.name} w lokalizacji ${this._lokalizacja}`);
  }

  pobierzAktualnyStatus(): StatusSystem {
    return this._status;
  }

  // Abstrakcyjne metody, które muszą być zaimplementowane
  abstract uruchom(): void;
  abstract zatrzymaj(): void;
  abstract wykonajPrzegląd(): void;

  // Abstrakcyjne właściwości
  abstract get typSystemu(): string;
  abstract get poziomPriorytetuAlarmowego(): number; // 1-10

  // Metoda wykorzystująca abstrakcyjne właściwości i metody
  wygenerujRaportStatusu(): string {
    return `
=== RAPORT SYSTEMU BEZPIECZEŃSTWA ===
ID: ${this._id}
Typ: ${this.typSystemu}
Lokalizacja: ${this._lokalizacja}
Status: ${this._status}
Monitorowany: ${this._czyMonitorowany ? "TAK" : "NIE"}
Priorytet alarmowy: ${this.poziomPriorytetuAlarmowego}/10
Ostatni przegląd: ${this._dataPrzeglądu.toLocaleDateString()}
Globalny poziom alertów: ${SystemBezpieczeństwa._poziomAlertówParku.toUpperCase()}
=================================
    `;
  }
}

// Klasa pochodna - System Ogrodzenia Elektrycznego
class SystemOgrodzeniaElektrycznego extends SystemBezpieczeństwa {
  private _napięcie: number; // w woltach
  private _długośćOgrodzenia: number; // w metrach
  private _typZabezpieczenia: "standardowe" | "wzmocnione" | "ultrawzmocnione";

  constructor(
    id: string,
    lokalizacja: string,
    długośćOgrodzenia: number,
    typZabezpieczenia: "standardowe" | "wzmocnione" | "ultrawzmocnione"
  ) {
    super(id, lokalizacja);
    this._napięcie = 0;
    this._długośćOgrodzenia = długośćOgrodzenia;
    this._typZabezpieczenia = typZabezpieczenia;
  }

  // Implementacja abstrakcyjnych właściwości
  get typSystemu(): string {
    return "Ogrodzenie Elektryczne";
  }

  get poziomPriorytetuAlarmowego(): number {
    // Priorytet zależy od typu zabezpieczenia
    const bazowy = this._typZabezpieczenia === "standardowe" ? 7 :
                  this._typZabezpieczenia === "wzmocnione" ? 8 : 10;

    // Uwzględniamy długość ogrodzenia - dłuższe mają wyższy priorytet
    const modyfikator = Math.min(2, Math.floor(this._długośćOgrodzenia / 1000));

    return Math.min(10, bazowy + modyfikator);
  }

  // Implementacja abstrakcyjnych metod
  uruchom(): void {
    if (this._status === "w_konserwacji") {
      console.log(`BŁĄD: Nie można uruchomić systemu ${this._id} - jest w trakcie konserwacji`);
      return;
    }

    this._status = "aktywny";

    // Napięcie zależy od typu zabezpieczenia
    this._napięcie = this._typZabezpieczenia === "standardowe" ? 10000 :
                   this._typZabezpieczenia === "wzmocnione" ? 20000 : 30000;

    console.log(`Uruchomiono system ogrodzenia ${this._id} w lokalizacji ${this._lokalizacja}`);
    console.log(`Napięcie: ${this._napięcie}V, Długość: ${this._długośćOgrodzenia}m`);
  }

  zatrzymaj(): void {
    this._status = "nieaktywny";
    this._napięcie = 0;
    console.log(`Zatrzymano system ogrodzenia ${this._id} w lokalizacji ${this._lokalizacja}`);

    // Zgłoszenie incydentu przy wysokim poziomie alertów
    if (SystemBezpieczeństwa.poziomAlertów === "wysoki" || SystemBezpieczeństwa.poziomAlertów === "krytyczny") {
      SystemBezpieczeństwa.zgłośIncydent(
        this.typSystemu,
        this._lokalizacja,
        `Wyłączenie ogrodzenia przy wysokim poziomie alertów!`
      );
    }
  }

  wykonajPrzegląd(): void {
    const poprzedniStatus = this._status;
    this._status = "w_konserwacji";
    console.log(`Rozpoczęto przegląd systemu ogrodzenia ${this._id}`);

    // Symulacja przeglądu
    setTimeout(() => {
      this._dataPrzeglądu = new Date();
      this._status = poprzedniStatus;
      console.log(`Zakończono przegląd systemu ogrodzenia ${this._id}`);
    }, 2000);
  }

  // Metody specyficzne dla tego typu systemu
  zmieńNapięcie(noweNapięcie: number): void {
    if (this._status !== "aktywny") {
      console.log(`BŁĄD: Nie można zmienić napięcia - system nie jest aktywny`);
      return;
    }

    this._napięcie = noweNapięcie;
    console.log(`Zmieniono napięcie ogrodzenia ${this._id} na ${noweNapięcie}V`);
  }

  zgłośPrzerwęWOgrodzeniu(): void {
    this._status = "awaria";
    SystemBezpieczeństwa.zgłośIncydent(
      this.typSystemu,
      this._lokalizacja,
      `Wykryto przerwę w ogrodzeniu elektrycznym!`
    );
  }
}

// Inna klasa pochodna - System Monitoringu Wideo
class SystemMonitoringuWideo extends SystemBezpieczeństwa {
  private _liczbaKamer: number;
  private _rozdzielczość: "SD" | "HD" | "4K";
  private _trybNocny: boolean;

  constructor(
    id: string,
    lokalizacja: string,
    liczbaKamer: number,
    rozdzielczość: "SD" | "HD" | "4K"
  ) {
    super(id, lokalizacja);
    this._liczbaKamer = liczbaKamer;
    this._rozdzielczość = rozdzielczość;
    this._trybNocny = false;
  }

  // Implementacja abstrakcyjnych właściwości
  get typSystemu(): string {
    return "Monitoring Wideo";
  }

  get poziomPriorytetuAlarmowego(): number {
    // Priorytet zależy od liczby kamer i rozdzielczości
    const bazowy = 5;

    // Modyfikator rozdzielczości
    const modyfikatorRozdzielczości =
      this._rozdzielczość === "SD" ? 0 :
      this._rozdzielczość === "HD" ? 1 : 2;

    // Modyfikator liczby kamer
    const modyfikatorKamer = Math.min(2, Math.floor(this._liczbaKamer / 10));

    return Math.min(10, bazowy + modyfikatorRozdzielczości + modyfikatorKamer);
  }

  // Implementacja abstrakcyjnych metod
  uruchom(): void {
    this._status = "aktywny";
    console.log(`Uruchomiono system monitoringu ${this._id} w lokalizacji ${this._lokalizacja}`);
    console.log(`Liczba kamer: ${this._liczbaKamer}, Rozdzielczość: ${this._rozdzielczość}`);
  }

  zatrzymaj(): void {
    this._status = "nieaktywny";
    console.log(`Zatrzymano system monitoringu ${this._id} w lokalizacji ${this._lokalizacja}`);
  }

  wykonajPrzegląd(): void {
    this._status = "w_konserwacji";
    console.log(`Rozpoczęto przegląd systemu monitoringu ${this._id}`);

    // W tym przypadku przegląd kończy się natychmiast
    this._dataPrzeglądu = new Date();
    this._status = "aktywny";
    console.log(`Zakończono przegląd systemu monitoringu ${this._id}`);
  }

  // Metody specyficzne dla tego typu systemu
  włączTrybNocny(): void {
    this._trybNocny = true;
    console.log(`Włączono tryb nocny w systemie monitoringu ${this._id}`);
  }

  wyłączTrybNocny(): void {
    this._trybNocny = false;
    console.log(`Wyłączono tryb nocny w systemie monitoringu ${this._id}`);
  }

  wykryjRuch(obszar: string): void {
    console.log(`System ${this._id}: Wykryto ruch w obszarze ${obszar}`);

    if (SystemBezpieczeństwa.poziomAlertów !== "normalny") {
      SystemBezpieczeństwa.zgłośIncydent(
        this.typSystemu,
        `${this._lokalizacja} - obszar ${obszar}`,
        `Wykryto nieautoryzowany ruch!`
      );
    }
  }
}

// Demonstracja systemu bezpieczeństwa Parku Jurajskiego
function testSystemuBezpieczeństwa() {
  console.log("=== INICJALIZACJA SYSTEMÓW BEZPIECZEŃSTWA PARKU JURAJSKIEGO ===");

  // Tworzenie systemów ogrodzenia
  const ogrodzenieGłówne = new SystemOgrodzeniaElektrycznego("FNC-001", "Sektor A - Wejście główne", 2500, "ultrawzmocnione");
  const ogrodzenieTRex = new SystemOgrodzeniaElektrycznego("FNC-002", "Sektor B - Wybieg T-Rex", 1200, "ultrawzmocnione");
  const ogrodzenieRaptory = new SystemOgrodzeniaElektrycznego("FNC-003", "Sektor C - Wybieg Raptorów", 800, "wzmocnione");

  // Tworzenie systemów monitoringu
  const monitoringGłówny = new SystemMonitoringuWideo("CAM-001", "Centrum kontroli", 20, "4K");
  const monitoringTRex = new SystemMonitoringuWideo("CAM-002", "Sektor B - Wybieg T-Rex", 12, "HD");
  const monitoringRaptory = new SystemMonitoringuWideo("CAM-003", "Sektor C - Wybieg Raptorów", 8, "HD");

  // Uruchamianie wszystkich systemów
  console.log("\n=== URUCHAMIANIE SYSTEMÓW ===");
  ogrodzenieGłówne.uruchom();
  ogrodzenieTRex.uruchom();
  ogrodzenieRaptory.uruchom();

  monitoringGłówny.uruchom();
  monitoringTRex.uruchom();
  monitoringRaptory.uruchom();

  // Rozpoczęcie monitorowania
  console.log("\n=== AKTYWACJA MONITOROWANIA ===");
  ogrodzenieGłówne.rozpocznijMonitorowanie();
  ogrodzenieTRex.rozpocznijMonitorowanie();
  ogrodzenieRaptory.rozpocznijMonitorowanie();

  monitoringGłówny.rozpocznijMonitorowanie();
  monitoringTRex.rozpocznijMonitorowanie();
  monitoringRaptory.rozpocznijMonitorowanie();

  // Sprawdzenie statusów
  console.log("\n=== RAPORTY SYSTEMÓW ===");
  console.log(ogrodzenieGłówne.wygenerujRaportStatusu());
  console.log(monitoringTRex.wygenerujRaportStatusu());

  // Symulacja incydentu
  console.log("\n=== SYMULACJA INCYDENTU ===");
  console.log("Aktualny poziom alertów:", SystemBezpieczeństwa.poziomAlertów);

  monitoringRaptory.wykryjRuch("Południowy narożnik");
  ogrodzenieRaptory.zgłośPrzerwęWOgrodzeniu();

  // Sprawdzenie poziom alertów po incydentach
  console.log("\nAktualny poziom alertów po incydentach:", SystemBezpieczeństwa.poziomAlertów);

  // Wyświetlenie ostatnich incydentów
  console.log("\n=== OSTATNIE INCYDENTY ===");
  SystemBezpieczeństwa.ostatnieIncydenty.forEach((incydent, index) => {
    console.log(`${index + 1}. [${incydent.data.toLocaleString()}] ${incydent.typSystemu} w ${incydent.lokalizacja}: ${incydent.opis}`);
  });

  // Przeprowadzenie przeglądu
  console.log("\n=== PRZEGLĄD SYSTEMÓW ===");
  ogrodzenieTRex.wykonajPrzegląd();
  monitoringGłówny.wykonajPrzegląd();

  // Ręczna zmiana poziomu alertów
  console.log("\n=== NORMALIZACJA SYTUACJI ===");
  SystemBezpieczeństwa.zmieńPoziomAlertów("normalny");
}

// Uruchomienie testu
testSystemuBezpieczeństwa();

W tym zaawansowanym przykładzie:

  1. Używamy abstrakcyjnej klasy SystemBezpieczeństwa jako bazę dla wszystkich systemów bezpieczeństwa
  2. Klasa definiuje statyczne właściwości i metody (np. poziom alertów parku, lista incydentów)
  3. Abstrakcyjne metody i właściwości wymuszają implementację specyficznej funkcjonalności w klasach pochodnych
  4. Klasy pochodne (SystemOgrodzeniaElektrycznego i SystemMonitoringuWideo) implementują abstrakcyjne elementy
  5. Elementy statyczne pozwalają na centralną koordynację (np. zgłaszanie incydentów i zarządzanie poziomem alertów)

Łączenie elementów statycznych i abstrakcyjnych

Elementy statyczne i abstrakcyjne mogą być potężnym narzędziem, gdy są używane razem w dobrze zaprojektowanej hierarchii klas. Oto kilka wzorców i przykładów ich zastosowania:

1. Abstrakcyjna klasa bazowa ze statycznymi metodami fabrycznymi

abstract class GatunekDinozaura {
  // Właściwości statyczne
  private static _zarejestrowaneDinozaury: Map<string, GatunekDinozaura> = new Map();

  // Właściwości instancji
  private _nazwa: string;
  private _eraDominocenitryczna: string;
  protected _dietaTyp: "mięsożerny" | "roślinożerny" | "wszystkożerny";

  constructor(nazwa: string, era: string, dieta: "mięsożerny" | "roślinożerny" | "wszystkożerny") {
    this._nazwa = nazwa;
    this._eraDominocenitryczna = era;
    this._dietaTyp = dieta;

    // Dodanie do rejestru
    GatunekDinozaura._zarejestrowaneDinozaury.set(nazwa, this);
  }

  // Statyczna metoda fabryczna - tworzy odpowiedni gatunek na podstawie diety
  static stwórzGatunek(
    nazwa: string,
    era: string,
    dieta: "mięsożerny" | "roślinożerny" | "wszystkożerny",
    parametryDodatkowe: Record<string, any>
  ): GatunekDinozaura {
    if (dieta === "mięsożerny") {
      return new MięsożernyGatunek(
        nazwa,
        era,
        parametryDodatkowe.siłaUgryzienia,
        parametryDodatkowe.prędkośćBiegu
      );
    } else {
      return new RoślinożernyGatunek(
        nazwa,
        era,
        parametryDodatkowe.długośćSzyi || 0,
        parametryDodatkowe.posiadaPancerz || false
      );
    }
  }

  // Statyczna metoda do pobierania zarejestrowanych gatunków
  static pobierzGatunek(nazwa: string): GatunekDinozaura | undefined {
    return this._zarejestrowaneDinozaury.get(nazwa);
  }

  static get wszystkieGatunki(): string[] {
    return Array.from(this._zarejestrowaneDinozaury.keys());
  }

  // Gettery instancji
  get nazwa(): string { return this._nazwa; }
  get era(): string { return this._eraDominocenitryczna; }
  get typDiety(): string { return this._dietaTyp; }

  // Abstrakcyjne metody
  abstract opisZachowania(): string;
  abstract obliczSzacowanąWagę(długość: number): number;

  // Metoda wykorzystująca abstrakcyjne metody
  generujOpis(): string {
    return `${this._nazwa} - dinozaur ${this._dietaTyp} z ery ${this._eraDominocenitryczna}.
${this.opisZachowania()}`;
  }
}

// Klasy pochodne
class MięsożernyGatunek extends GatunekDinozaura {
  private _siłaUgryzienia: number; // w PSI
  private _prędkośćBiegu: number; // w km/h

  constructor(nazwa: string, era: string, siłaUgryzienia: number, prędkośćBiegu: number) {
    super(nazwa, era, "mięsożerny");
    this._siłaUgryzienia = siłaUgryzienia;
    this._prędkośćBiegu = prędkośćBiegu;
  }

  // Gettery
  get siłaUgryzienia(): number { return this._siłaUgryzienia; }
  get prędkośćBiegu(): number { return this._prędkośćBiegu; }

  // Implementacja abstrakcyjnych metod
  opisZachowania(): string {
    return `Poluje z prędkością ${this._prędkośćBiegu} km/h i siłą ugryzienia ${this._siłaUgryzienia} PSI.`;
  }

  obliczSzacowanąWagę(długość: number): number {
    // Przybliżony wzór dla drapieżników
    return długość * długość * 100;
  }
}

class RoślinożernyGatunek extends GatunekDinozaura {
  private _długośćSzyi: number; // w metrach
  private _posiadaPancerz: boolean;

  constructor(nazwa: string, era: string, długośćSzyi: number, posiadaPancerz: boolean) {
    super(nazwa, era, "roślinożerny");
    this._długośćSzyi = długośćSzyi;
    this._posiadaPancerz = posiadaPancerz;
  }

  // Gettery
  get długośćSzyi(): number { return this._długośćSzyi; }
  get posiadaPancerz(): boolean { return this._posiadaPancerz; }

  // Implementacja abstrakcyjnych metod
  opisZachowania(): string {
    const opisSzyi = this._długośćSzyi > 3
      ? `Posiada długą szyję (${this._długośćSzyi}m) umożliwiającą zjadanie wysokiej roślinności.`
      : "Żywi się niską roślinnością.";

    const opisPancerza = this._posiadaPancerz
      ? "Posiada pancerz chroniący przed drapieżnikami."
      : "Nie posiada pancerza ochronnego.";

    return `${opisSzyi} ${opisPancerza}`;
  }

  obliczSzacowanąWagę(długość: number): number {
    // Przybliżony wzór dla roślinożerców (zwykle cięższe)
    let waga = długość * długość * 150;

    // Dodatkowa waga za pancerz
    if (this._posiadaPancerz) {
      waga *= 1.3;
    }

    return waga;
  }
}

// Użycie
function testGatunkówDinozaurów() {
  // Tworzenie gatunków za pomocą metody fabrycznej
  GatunekDinozaura.stwórzGatunek(
    "Tyrannosaurus Rex",
    "późna kreda",
    "mięsożerny",
    { siłaUgryzienia: 12800, prędkośćBiegu: 32 }
  );

  GatunekDinozaura.stwórzGatunek(
    "Velociraptor",
    "późna kreda",
    "mięsożerny",
    { siłaUgryzienia: 2000, prędkośćBiegu: 64 }
  );

  GatunekDinozaura.stwórzGatunek(
    "Brachiosaurus",
    "późna jura",
    "roślinożerny",
    { długośćSzyi: 9, posiadaPancerz: false }
  );

  GatunekDinozaura.stwórzGatunek(
    "Stegosaurus",
    "późna jura",
    "roślinożerny",
    { długośćSzyi: 0.5, posiadaPancerz: true }
  );

  // Dostęp do zarejestrowanych gatunków
  console.log("Dostępne gatunki:", GatunekDinozaura.wszystkieGatunki);

  // Pobieranie informacji o gatunkach
  const trex = GatunekDinozaura.pobierzGatunek("Tyrannosaurus Rex");
  const brach = GatunekDinozaura.pobierzGatunek("Brachiosaurus");

  if (trex) {
    console.log(trex.generujOpis());
    console.log(`Szacowana waga (12m długości): ${trex.obliczSzacowanąWagę(12)} kg`);
  }

  if (brach) {
    console.log(brach.generujOpis());
    console.log(`Szacowana waga (25m długości): ${brach.obliczSzacowanąWagę(25)} kg`);
  }

  // Sprawdzanie typu
  const steg = GatunekDinozaura.pobierzGatunek("Stegosaurus") as RoślinożernyGatunek;
  if (steg && steg instanceof RoślinożernyGatunek) {
    console.log(`Stegosaurus posiada pancerz: ${steg.posiadaPancerz ? "TAK" : "NIE"}`);
  }

  const raptor = GatunekDinozaura.pobierzGatunek("Velociraptor") as MięsożernyGatunek;
  if (raptor && raptor instanceof MięsożernyGatunek) {
    console.log(`Velociraptor - prędkość biegu: ${raptor.prędkośćBiegu} km/h`);
  }
}

testGatunkówDinozaurów();

2. Abstrakcyjne metody statyczne

W TypeScript od wersji 4.0 możliwe jest definiowanie abstrakcyjnych metod statycznych. Umożliwia to tworzenie hierarchii klas, gdzie klasy pochodne muszą implementować określone metody statyczne:

abstract class SystemLokacji {
  // Właściwości instancji
  protected _id: string;
  protected _nazwa: string;

  constructor(id: string, nazwa: string) {
    this._id = id;
    this._nazwa = nazwa;
  }

  // Abstrakcyjna statyczna metoda, którą muszą zaimplementować klasy pochodne
  static abstract generujIdentyfikatorLokacji(typ: string, numer: number): string;

  // Zwykła abstrakcyjna metoda instancji
  abstract pobierzInformacjeOLokacji(): Record<string, any>;

  // Metoda instancji
  wygenerujRaport(): string {
    const info = this.pobierzInformacjeOLokacji();

    let raport = `=== RAPORT LOKACJI: ${this._nazwa} (ID: ${this._id}) ===\n`;

    for (const [klucz, wartość] of Object.entries(info)) {
      raport += `${klucz}: ${wartość}\n`;
    }

    return raport;
  }
}

class WybiegDinozaurów extends SystemLokacji {
  private _gatunek: string;
  private _powierzchnia: number; // w hektarach
  private _liczbaOsobników: number;

  constructor(numer: number, nazwa: string, gatunek: string, powierzchnia: number, liczbaOsobników: number) {
    // Generowanie ID dla wybiegu
    const id = WybiegDinozaurów.generujIdentyfikatorLokacji("wybieg", numer);
    super(id, nazwa);

    this._gatunek = gatunek;
    this._powierzchnia = powierzchnia;
    this._liczbaOsobników = liczbaOsobników;
  }

  // Implementacja abstrakcyjnej statycznej metody
  static generujIdentyfikatorLokacji(typ: string, numer: number): string {
    return `${typ.toUpperCase()}-${numer.toString().padStart(3, '0')}`;
  }

  // Implementacja abstrakcyjnej metody instancji
  pobierzInformacjeOLokacji(): Record<string, any> {
    return {
      typ: "Wybieg dinozaurów",
      gatunek: this._gatunek,
      powierzchnia: `${this._powierzchnia} ha`,
      liczbaOsobników: this._liczbaOsobników,
      gęstośćZaludnienia: `${(this._liczbaOsobników / this._powierzchnia).toFixed(2)} os./ha`
    };
  }

  // Metody specyficzne dla tej klasy
  dodajOsobnika(): void {
    this._liczbaOsobników++;
    console.log(`Dodano nowego osobnika do wybiegu ${this._nazwa}. Nowa liczba: ${this._liczbaOsobników}`);
  }

  usuńOsobnika(): boolean {
    if (this._liczbaOsobników > 0) {
      this._liczbaOsobników--;
      console.log(`Usunięto osobnika z wybiegu ${this._nazwa}. Nowa liczba: ${this._liczbaOsobników}`);
      return true;
    }

    console.log(`Błąd: Nie można usunąć osobnika z wybiegu ${this._nazwa} - brak osobników.`);
    return false;
  }
}

class AtrakcjaTurystyczna extends SystemLokacji {
  private _typAtrakcji: string;
  private _pojemność: number;
  private _czasOczekiwania: number; // w minutach

  constructor(numer: number, nazwa: string, typAtrakcji: string, pojemność: number) {
    // Generowanie ID dla atrakcji
    const id = AtrakcjaTurystyczna.generujIdentyfikatorLokacji("atrakcja", numer);
    super(id, nazwa);

    this._typAtrakcji = typAtrakcji;
    this._pojemność = pojemność;
    this._czasOczekiwania = 0;
  }

  // Implementacja abstrakcyjnej statycznej metody
  static generujIdentyfikatorLokacji(typ: string, numer: number): string {
    // Inny format ID dla atrakcji
    return `${typ.substring(0, 3).toUpperCase()}${numer.toString().padStart(4, '0')}`;
  }

  // Implementacja abstrakcyjnej metody instancji
  pobierzInformacjeOLokacji(): Record<string, any> {
    return {
      typ: "Atrakcja turystyczna",
      kategoria: this._typAtrakcji,
      pojemność: this._pojemność,
      czasOczekiwania: `${this._czasOczekiwania} min`
    };
  }

  // Metody specyficzne dla tej klasy
  aktualizujCzasOczekiwania(nowyOczekiwanieCzas: number): void {
    this._czasOczekiwania = nowyOczekiwanieCzas;
    console.log(`Zaktualizowano czas oczekiwania dla ${this._nazwa}: ${this._czasOczekiwania} min`);
  }
}

// Zastosowanie
function testSystemLokacji() {
  // Tworzenie wybiegów
  const wybiegTRex = new WybiegDinozaurów(1, "Królestwo T-Rexa", "Tyrannosaurus Rex", 5, 1);
  const wybiegRaptorów = new WybiegDinozaurów(2, "Dolina Raptorów", "Velociraptor", 3, 6);

  // Tworzenie atrakcji
  const centrumOdwiedzających = new AtrakcjaTurystyczna(101, "Centrum Genetyki", "edukacyjna", 500);
  const safariJeepem = new AtrakcjaTurystyczna(102, "Safari Jurajskie", "przejażdżka", 50);

  // Wyświetlanie raportów
  console.log(wybiegTRex.wygenerujRaport());
  console.log(wybiegRaptorów.wygenerujRaport());
  console.log(centrumOdwiedzających.wygenerujRaport());
  console.log(safariJeepem.wygenerujRaport());

  // Wykonywanie operacji
  wybiegRaptorów.dodajOsobnika();
  wybiegRaptorów.dodajOsobnika();
  safariJeepem.aktualizujCzasOczekiwania(45);

  // Sprawdzenie zaktualizowanych danych
  console.log(wybiegRaptorów.wygenerujRaport());
  console.log(safariJeepem.wygenerujRaport());

  // Demonstracja różnych formatów ID generowanych przez implementacje statycznych metod
  console.log("Format ID wybiegu:", WybiegDinozaurów.generujIdentyfikatorLokacji("wybieg", 42));
  console.log("Format ID atrakcji:", AtrakcjaTurystyczna.generujIdentyfikatorLokacji("atrakcja", 42));
}

testSystemLokacji();

Podsumowanie

W tym ćwiczeniu poznaliśmy dwa potężne mechanizmy TypeScript:

  1. Właściwości i metody statyczne:

    • Należą do klasy, a nie do instancji
    • Umożliwiają współdzielenie danych i funkcjonalności między wszystkimi instancjami
    • Idealne do definiowania stałych, globalnego stanu i metod narzędziowych
    • Dostępne bezpośrednio przez nazwę klasy, bez konieczności tworzenia instancji
  2. Klasy i metody abstrakcyjne:

    • Definiują "szablon" lub "kontrakt", który musi być zaimplementowany przez klasy dziedziczące
    • Nie można tworzyć instancji klas abstrakcyjnych bezpośrednio
    • Wymuszają implementację określonych metod w klasach pochodnych
    • Pozwalają na współdzielenie wspólnej funkcjonalności przez hierarchię klas

Łącząc te koncepcje, możemy tworzyć eleganckie, modułowe i typowo bezpieczne systemy, które idealnie nadają się do modelowania złożonych relacji i procesów, takich jak te w systemie zarządzania Parkiem Jurajskim.

Dr. Henry Wu podsumowałby to następująco: "W naturze, podobnie jak w programowaniu, istnieje piękno w strukturze i porządku. Elementy statyczne zapewniają spójność dla całego gatunku, podczas gdy abstrakcyjne koncepcje stanowią podstawowy plan, który każdy organizm musi zaimplementować na swój własny sposób. Razem tworzą doskonałą harmonię - z odpowiednimi zabezpieczeniami, oczywiście... w większości przypadków."

Kod do tej lekcji: index.ts
// Właściwości statyczne i klasy abstrakcyjne - Park Jurajski
console.log("=== WŁAŚCIWOŚCI STATYCZNE I KLASY ABSTRAKCYJNE ===\n");

// ===========================================
// 1. Klasa abstrakcyjna Dinosaur
// ===========================================

abstract class Dinosaur {
  // Statyczny licznik wszystkich dinozaurów
  static totalCount: number = 0;
  static readonly PARK_NAME: string = "Jurassic World";

  // Statyczna metoda fabrykująca
  static createId(): string {
    return `DINO-${String(++Dinosaur.totalCount).padStart(4, "0")}`;
  }

  // Pola instancji
  readonly id: string;
  name: string;
  protected weight: number;

  constructor(name: string, weight: number) {
    this.id = Dinosaur.createId();
    this.name = name;
    this.weight = weight;
  }

  // Metoda abstrakcyjna - każdy gatunek musi ją zaimplementować
  abstract makeSound(): string;
  abstract getDangerLevel(): number;

  // Wspólna metoda
  getProfile(): string {
    return `[${this.id}] ${this.name} - ${this.weight}kg`;
  }
}

// ===========================================
// 2. Implementacje klas konkretnych
// ===========================================

class TRex extends Dinosaur {
  private biteForce: number;

  constructor(name: string, weight: number, biteForce: number) {
    super(name, weight);
    this.biteForce = biteForce;
  }

  makeSound(): string {
    return "ROOOOAAAR!";
  }

  getDangerLevel(): number {
    return 10;
  }
}

class Triceratops extends Dinosaur {
  private hornLength: number;

  constructor(name: string, weight: number, hornLength: number) {
    super(name, weight);
    this.hornLength = hornLength;
  }

  makeSound(): string {
    return "BRRRRR!";
  }

  getDangerLevel(): number {
    return 4;
  }
}

// ===========================================
// 3. Statyczna metoda fabrykująca
// ===========================================

class DinosaurFactory {
  static registry: Map<string, Dinosaur> = new Map();

  static create(type: "trex" | "triceratops", name: string): Dinosaur {
    let dino: Dinosaur;
    if (type === "trex") {
      dino = new TRex(name, 8000, 12800);
    } else {
      dino = new Triceratops(name, 6000, 90);
    }
    DinosaurFactory.registry.set(dino.id, dino);
    return dino;
  }

  static getAll(): Dinosaur[] {
    return Array.from(DinosaurFactory.registry.values());
  }
}

// ===========================================
// Test
// ===========================================

const rex = DinosaurFactory.create("trex", "Rexy");
const trike = DinosaurFactory.create("triceratops", "Cera");
const rex2 = DinosaurFactory.create("trex", "Buck");

console.log("Park:", Dinosaur.PARK_NAME);
console.log("Liczba dinozaurow:", Dinosaur.totalCount);
console.log("");

DinosaurFactory.getAll().forEach(dino => {
  console.log(dino.getProfile());
  console.log("  Dzwiek:", dino.makeSound());
  console.log("  Zagrozenie:", dino.getDangerLevel(), "/10");
});

// Nie mozna stworzyc instancji klasy abstrakcyjnej:
// const dino = new Dinosaur("Test", 100); // Error!
console.log("\nKlasa abstrakcyjna nie moze byc instancjonowana bezposrednio.");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest klasa abstrakcyjna w TypeScript?

  2. 2. Czym różnią się właściwości statyczne od zwykłych w klasie?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj klasy z właściwościami statycznymi i abstrakcyjnymi.

  • Klikanie w kolejności

    Ułóż elementy deklaracji klasy abstrakcyjnej:

  • Edytor kodu

    Stwórz klasy z różnymi modyfikatorami dostępu dla systemu parku

  1. PytanieKlasy abstrakcyjne
  2. Zadanie z kodemPraktyka: Statyczne i abstrakcyjne
  3. PytanieWłaściwości statyczne
  4. Kliknij w kolejnościSortowanie: Składnia klasy abstrakcyjnej
  5. Zadanie z kodemModyfikatory dostępu - praktyka

Przydatne artykuły