Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript

Implementacja interfejsów

24 min czytania ·
W tej lekcji10

"W Parku Jurajskim wszystko musi działać według ścisłych protokołów," wyjaśnia Claire Dearing, dyrektor operacyjna. "Każdy pracownik ma jasno określony zakres obowiązków, a każdy system musi spełniać określone wymagania. Nie interesuje nas, jak dokładnie ochroniarz pilnuje wybiegu z raptorami - ważne, że wykonuje swoją pracę zgodnie z procedurami bezpieczeństwa."

W świecie TypeScript, interfejsy pełnią podobną rolę - definiują "kontrakt", który klasy muszą spełnić, bez określania, jak dokładnie mają to zrobić. W tym ćwiczeniu dowiesz się, jak projektować i implementować interfejsy, tworząc zaawansowany system zarządzania Parkiem Jurajskim.

Podstawy interfejsów

Interfejs w TypeScript to struktura, która definiuje kształt obiektu - jakie właściwości i metody powinien posiadać, bez określania ich implementacji. Możesz myśleć o interfejsie jak o kontrakcie lub protokole, który klasa musi przestrzegać.

Przyjrzyjmy się podstawowej składni interfejsu:

// Definicja interfejsu
interface PracownikParku {
  // Właściwości
  id: string;
  imię: string;
  nazwisko: string;
  poziomDostępu: number;

  // Metody
  zaloguj(): void;
  wyloguj(): void;
  sprawdźUprawnienia(wymaganyPoziom: number): boolean;
}

// Klasa implementująca interfejs
class OchroniarzParku implements PracownikParku {
  // Implementacja wszystkich wymaganych właściwości
  id: string;
  imię: string;
  nazwisko: string;
  poziomDostępu: number;
  private aktywnyStatus: boolean = false;

  constructor(id: string, imię: string, nazwisko: string) {
    this.id = id;
    this.imię = imię;
    this.nazwisko = nazwisko;
    this.poziomDostępu = 2; // Standardowy poziom dla ochroniarzy
  }

  // Implementacja wszystkich wymaganych metod
  zaloguj(): void {
    console.log(`Ochroniarz ${this.imię} ${this.nazwisko} zalogował się do systemu.`);
    this.aktywnyStatus = true;
  }

  wyloguj(): void {
    console.log(`Ochroniarz ${this.imię} ${this.nazwisko} wylogował się z systemu.`);
    this.aktywnyStatus = false;
  }

  sprawdźUprawnienia(wymaganyPoziom: number): boolean {
    return this.poziomDostępu >= wymaganyPoziom;
  }

  // Dodatkowe metody specyficzne dla ochroniarza
  patrolujSektor(sektorId: string): void {
    if (!this.aktywnyStatus) {
      console.log("Błąd: Ochroniarz musi być zalogowany, aby patrolować sektor.");
      return;
    }

    console.log(`Ochroniarz ${this.imię} ${this.nazwisko} patroluje sektor ${sektorId}.`);
  }
}

// Inna klasa implementująca ten sam interfejs
class NaukowiecParku implements PracownikParku {
  id: string;
  imię: string;
  nazwisko: string;
  poziomDostępu: number;
  private specjalizacja: string;

  constructor(id: string, imię: string, nazwisko: string, specjalizacja: string) {
    this.id = id;
    this.imię = imię;
    this.nazwisko = nazwisko;
    this.poziomDostępu = 4; // Wyższy poziom dostępu dla naukowców
    this.specjalizacja = specjalizacja;
  }

  zaloguj(): void {
    console.log(`Dr ${this.imię} ${this.nazwisko} zalogował się do systemu laboratorium.`);
  }

  wyloguj(): void {
    console.log(`Dr ${this.imię} ${this.nazwisko} wylogował się z systemu laboratorium.`);
  }

  sprawdźUprawnienia(wymaganyPoziom: number): boolean {
    // Naukowcy mają specjalne uprawnienia w laboratoriach
    if (wymaganyPoziom === 3 && this.specjalizacja === "genetyka") {
      return true;
    }
    return this.poziomDostępu >= wymaganyPoziom;
  }

  // Metoda specyficzna dla naukowca
  przeprowadźBadanie(obiektBadań: string): void {
    console.log(`Dr ${this.imię} ${this.nazwisko} prowadzi badania nad: ${obiektBadań}.`);
  }
}

// Użycie klas implementujących interfejs
const ochroniarz = new OchroniarzParku("SEC-001", "John", "Smith");
const naukowiec = new NaukowiecParku("SCI-042", "Henry", "Wu", "genetyka");

// Obie klasy implementują ten sam interfejs, więc możemy użyć tych samych metod
ochroniarz.zaloguj();
naukowiec.zaloguj();

// Sprawdzenie uprawnień
console.log(`Ochroniarz ma dostęp do strefy 2: ${ochroniarz.sprawdźUprawnienia(2)}`);
console.log(`Naukowiec ma dostęp do strefy 3: ${naukowiec.sprawdźUprawnienia(3)}`);

// Wywołanie metod specyficznych dla konkretnych klas
ochroniarz.patrolujSektor("B-5");
naukowiec.przeprowadźBadanie("DNA Velociraptora");

W powyższym przykładzie:

  1. Zdefiniowaliśmy interfejs PracownikParku określający, jakie właściwości i metody musi mieć każdy pracownik
  2. Utworzyliśmy dwie różne klasy implementujące ten interfejs - każda na swój sposób
  3. Obie klasy muszą dostarczyć wszystkie wymagane właściwości i metody, ale mogą implementować je różnie
  4. Klasy mogą również dodawać własne, dodatkowe metody i właściwości

Właściwości opcjonalne i tylko do odczytu

Interfejsy TypeScript pozwalają na bardziej zaawansowane definiowanie właściwości:

interface SystemBezpieczeństwa {
  // Wymagana właściwość
  id: string;

  // Właściwość tylko do odczytu - nie można jej modyfikować po inicjalizacji
  readonly typSystemu: "monitoring" | "ogrodzenie" | "czujnikRuchu" | "alarm";

  // Właściwość opcjonalna - może istnieć lub nie
  opcjeZaawansowane?: Record<string, any>;

  // Metody
  aktywuj(): void;
  deaktywuj(): void;
  sprawdźStatus(): string;
}

class SystemOgrodzenia implements SystemBezpieczeństwa {
  id: string;
  readonly typSystemu: "monitoring" | "ogrodzenie" | "czujnikRuchu" | "alarm" = "ogrodzenie";
  opcjeZaawansowane?: Record<string, any>; // Opcjonalna właściwość

  private napięcie: number = 0;
  private aktywny: boolean = false;

  constructor(id: string, opcjeZaawansowane?: Record<string, any>) {
    this.id = id;
    if (opcjeZaawansowane) {
      this.opcjeZaawansowane = opcjeZaawansowane;
    }
  }

  aktywuj(): void {
    this.aktywny = true;
    this.napięcie = this.opcjeZaawansowane?.napięcieStartowe || 10000; // Użycie opcjonalnej właściwości
    console.log(`System ogrodzenia ${this.id} aktywowany. Napięcie: ${this.napięcie}V`);
  }

  deaktywuj(): void {
    this.aktywny = false;
    this.napięcie = 0;
    console.log(`System ogrodzenia ${this.id} deaktywowany.`);
  }

  sprawdźStatus(): string {
    return `System ogrodzenia ${this.id}: ${this.aktywny ? "AKTYWNY" : "NIEAKTYWNY"}, Napięcie: ${this.napięcie}V`;
  }

  // Własna metoda, niewymagana przez interfejs
  zwiększNapięcie(przyrost: number): void {
    if (!this.aktywny) {
      console.log("Nie można zmienić napięcia - system nieaktywny.");
      return;
    }

    this.napięcie += przyrost;
    console.log(`Zwiększono napięcie do ${this.napięcie}V.`);
  }
}

// Użycie z opcjonalnymi właściwościami
const ogrodzenieTRex = new SystemOgrodzenia("FNC-TR1", {
  napięcieStartowe: 20000,
  automatyczneRestarty: true
});

const ogrodzenieStandardowe = new SystemOgrodzenia("FNC-ST1");

ogrodzenieTRex.aktywuj();   // Używa niestandardowego napięcia startowego
ogrodzenieStandardowe.aktywuj();  // Używa domyślnego napięcia startowego

// Error: Nie można przypisać do 'typSystemu' ponieważ jest to właściwość tylko do odczytu
// ogrodzenieTRex.typSystemu = "alarm";

W tym przykładzie:

  1. Zdefiniowaliśmy właściwość readonly, której nie można modyfikować po inicjalizacji
  2. Dodaliśmy opcjonalną właściwość opcjeZaawansowane (oznaczoną przez ?)
  3. Implementacja sprawdza, czy opcjonalna właściwość istnieje, zanim jej użyje

Rozszerzanie interfejsów

Interfejsy, podobnie jak klasy, mogą rozszerzać inne interfejsy, dziedzicząc ich właściwości i metody:

// Podstawowy interfejs dla wszystkich zwierząt
interface Zwierzę {
  id: string;
  gatunek: string;
  waga: number;
  karma(): void;
  monitoruj(): string;
}

// Rozszerzony interfejs specyficzny dla dinozaurów
interface Dinozaur extends Zwierzę {
  poziomNiebezpieczeństwa: number;
  eraDinozaura: "trias" | "jura" | "kreda";
  podajSpecjalnąDietę(): string;
}

// Jeszcze bardziej wyspecjalizowany interfejs
interface DrapieżnyDinozaur extends Dinozaur {
  siłaUgryzienia: number;
  prędkość: number;
  poluj(): void;
}

// Implementacja
class TyranozaurRex implements DrapieżnyDinozaur {
  // Właściwości z interfejsu Zwierzę
  id: string;
  gatunek: string = "Tyrannosaurus Rex";
  waga: number;

  // Właściwości z interfejsu Dinozaur
  poziomNiebezpieczeństwa: number = 10;
  eraDinozaura: "trias" | "jura" | "kreda" = "kreda";

  // Właściwości z interfejsu DrapieżnyDinozaur
  siłaUgryzienia: number;
  prędkość: number;

  // Własne właściwości
  private wiek: number;
  private ostatnieKarmienie: Date | null = null;

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

  // Implementacja metod z interfejsu Zwierzę
  karma(): void {
    this.ostatnieKarmienie = new Date();
    console.log(`T-Rex ${this.id} został nakarmiony.`);
  }

  monitoruj(): string {
    const statusKarmienia = this.ostatnieKarmienie
      ? `Ostatnie karmienie: ${this.ostatnieKarmienie.toLocaleString()}`
      : "Brak informacji o karmieniu";

    return `T-Rex ${this.id}: Waga: ${this.waga}kg, Wiek: ${this.wiek} lat. ${statusKarmienia}`;
  }

  // Implementacja metody z interfejsu Dinozaur
  podajSpecjalnąDietę(): string {
    return "Świeże mięso ssaków, preferowana wołowina, 250kg dziennie.";
  }

  // Implementacja metody z interfejsu DrapieżnyDinozaur
  poluj(): void {
    console.log(`T-Rex ${this.id} poluje z prędkością ${this.prędkość} km/h i siłą ugryzienia ${this.siłaUgryzienia} PSI!`);
  }
}

// Użycie
const rex = new TyranozaurRex("TREX-01", 8000, 12, 12800, 30);
rex.karma();
console.log(rex.monitoruj());
console.log(`Specjalna dieta: ${rex.podajSpecjalnąDietę()}`);
rex.poluj();

W tym przykładzie stworzyliśmy hierarchię interfejsów:

  1. Zwierzę - podstawowy interfejs dla wszystkich zwierząt
  2. Dinozaur - rozszerza Zwierzę o właściwości specyficzne dla dinozaurów
  3. DrapieżnyDinozaur - rozszerza Dinozaur o właściwości specyficzne dla drapieżników

Klasa TyranozaurRex implementuje najbardziej wyspecjalizowany interfejs DrapieżnyDinozaur, co oznacza, że musi dostarczyć wszystkie właściwości i metody ze wszystkich trzech interfejsów.

Interfejsy vs Typy

TypeScript oferuje również aliasy typów (type), które mają podobne możliwości co interfejsy, ale istnieją między nimi pewne różnice:

// Interfejs
interface PomiarWybieg {
  szerokość: number;
  długość: number;
  obliczPowierzchnię(): number;
}

// Typ (Type alias)
type PomiarKlatka = {
  szerokość: number;
  wysokość: number;
  głębokość: number;
  obliczObjętość(): number;
};

// Rozszerzanie interfejsu
interface PomiarWybiegZOgrodzeniem extends PomiarWybieg {
  wysokośćOgrodzenia: number;
  materiałOgrodzenia: string;
}

// "Rozszerzanie" typu poprzez przecięcie (intersection)
type PomiarKlatkaWzmocniona = PomiarKlatka & {
  materiałWzmocnienia: string;
  maksymalneObciążenie: number;
};

// Implementacja interfejsu
class WybiegRaptorów implements PomiarWybiegZOgrodzeniem {
  szerokość: number;
  długość: number;
  wysokośćOgrodzenia: number;
  materiałOgrodzenia: string;

  constructor(szerokość: number, długość: number, wysokośćOgrodzenia: number) {
    this.szerokość = szerokość;
    this.długość = długość;
    this.wysokośćOgrodzenia = wysokośćOgrodzenia;
    this.materiałOgrodzenia = "Stal wzmocniona";
  }

  obliczPowierzchnię(): number {
    return this.szerokość * this.długość;
  }
}

// Implementacja typu (działa tak samo jak interfejs)
class KlatkaTransportowa implements PomiarKlatkaWzmocniona {
  szerokość: number;
  wysokość: number;
  głębokość: number;
  materiałWzmocnienia: string;
  maksymalneObciążenie: number;

  constructor(
    szerokość: number,
    wysokość: number,
    głębokość: number,
    maksymalneObciążenie: number
  ) {
    this.szerokość = szerokość;
    this.wysokość = wysokość;
    this.głębokość = głębokość;
    this.materiałWzmocnienia = "Kompozyt węglowy";
    this.maksymalneObciążenie = maksymalneObciążenie;
  }

  obliczObjętość(): number {
    return this.szerokość * this.wysokość * this.głębokość;
  }
}

Główne różnice między interfejsami a typami:

  1. Rozszerzalność:

    • Interfejsy można rozszerzyć później (deklaracja fuzji)
    • Typy są zamknięte po zdefiniowaniu
    // Interfejs można rozszerzyć dodatkowymi deklaracjami
    interface DiagnozaDinozaura {
      wynikBadania: string;
    }
    
    // Dodawanie nowych właściwości do istniejącego interfejsu
    interface DiagnozaDinozaura {
      dataWykonania: Date;
    }
    
    // Teraz DiagnozaDinozaura ma obie właściwości!
    
    // Dla typów to nie zadziała:
    type OpisWybieg = {
      id: string;
    };
    
    // Error: Duplicate identifier 'OpisWybieg'
    // type OpisWybieg = {
    //   nazwa: string;
    // };
  2. Łączenie:

    • Interfejsy używają extends
    • Typy używają operatora przecięcia &
  3. Zaawansowane konstrukcje:

    • Typy mogą reprezentować unie, przecięcia i inne złożone typy
    • Interfejsy są ograniczone do opisywania kształtu obiektów
// Zaawansowane typy, których nie można wyrazić interfejsami
type StatusDinozaura = "zdrowy" | "chory" | "w trakcie leczenia" | "poddany kwarantannie";

type IDDinozaura = string | number;

type ZwierzęLubRoślina = Zwierzę | { rodzaj: string, wysokość: number };

// Mapowane typy
type Opcjonalny<T> = {
  [P in keyof T]?: T[P];
};

// Użycie mapowanego typu z interfejsem
type OpcjonalnyDinozaur = Opcjonalny<Dinozaur>;

Interfejsy dla funkcji i metod

Interfejsy mogą również definiować kształt funkcji i konstrukcji klas:

// Interfejs dla funkcji
interface ProcesowanieZdjęcia {
  (ścieżka: string, opcje?: { rozdzielczość?: number, filtr?: string }): Promise<string>;
}

// Implementacja funkcji zgodnej z interfejsem
const procesorZdjęćDinozaurów: ProcesowanieZdjęcia = async (ścieżka, opcje) => {
  console.log(`Przetwarzanie zdjęcia: ${ścieżka}`);
  console.log(`Opcje: ${JSON.stringify(opcje || {})}`);

  // Symulacja przetwarzania
  await new Promise(resolve => setTimeout(resolve, 1000));

  return `zoptymalizowane_${ścieżka}`;
};

// Wywołanie funkcji
procesorZdjęćDinozaurów("trex.jpg", { rozdzielczość: 1200 })
  .then(wynik => console.log(`Przetworzono: ${wynik}`));

// Interfejs dla konstruktora klasy
interface KonstruktorDinozaura {
  new (id: string, gatunek: string, wiek: number): Zwierzę;
}

// Funkcja używająca konstruktora
function utworzDinozaura(Konstruktor: KonstruktorDinozaura, id: string, gatunek: string, wiek: number): Zwierzę {
  return new Konstruktor(id, gatunek, wiek);
}

// Klasa zgodna z interfejsem konstruktora
class PrototypDinozaura implements Zwierzę {
  id: string;
  gatunek: string;
  waga: number = 0;
  private _wiek: number;

  constructor(id: string, gatunek: string, wiek: number) {
    this.id = id;
    this.gatunek = gatunek;
    this._wiek = wiek;

    // Kalkulacja wagi na podstawie wieku
    this.waga = wiek * 100; // Uproszczona kalkulacja
  }

  karma(): void {
    console.log(`Karmienie prototypu ${this.gatunek}.`);
  }

  monitoruj(): string {
    return `Monitoring prototypu ${this.gatunek} (ID: ${this.id}).`;
  }
}

// Użycie funkcji fabrycznej
const nowyDinozaur = utworzDinozaura(PrototypDinozaura, "PROTO-1", "Testosaurus", 5);
console.log(nowyDinozaur.monitoruj());

Indeksy w interfejsach

Interfejsy mogą również definiować typy indeksowane, które pozwalają na dynamiczny dostęp do właściwości:

// Interfejs z indeksami
interface BazaDanychZwierząt {
  // Indeks typu string, wartości typu Zwierzę
  [id: string]: Zwierzę;

  // Możemy również dodać konkretne właściwości
  liczbaZwierząt: number;
  ostatniaAktualizacja: Date;
}

// Implementacja
class RepositoryZwierząt implements BazaDanychZwierząt {
  // Implementacja indeksu
  [id: string]: Zwierzę | number | Date | Function;

  liczbaZwierząt: number = 0;
  ostatniaAktualizacja: Date = new Date();

  // Musimy obsłużyć metody, ponieważ również są właściwościami
  dodajZwierzę(zwierzę: Zwierzę): void {
    this[zwierzę.id] = zwierzę;
    this.liczbaZwierząt++;
    this.ostatniaAktualizacja = new Date();
  }

  pobierzZwierzę(id: string): Zwierzę | undefined {
    const zwierzę = this[id];
    if (zwierzę && typeof zwierzę !== 'number' && !(zwierzę instanceof Date) && typeof zwierzę !== 'function') {
      return zwierzę;
    }
    return undefined;
  }
}

// Użycie
const repoZwierząt = new RepositoryZwierząt();

// Dodanie kilku zwierząt
const triceratops = {
  id: "TRIC-01",
  gatunek: "Triceratops",
  waga: 6000,
  karma(): void { console.log("Karmienie Triceratopsa"); },
  monitoruj(): string { return "Monitoring Triceratopsa"; }
};

const stegozaur = {
  id: "STEG-01",
  gatunek: "Stegosaurus",
  waga: 5000,
  karma(): void { console.log("Karmienie Stegozaura"); },
  monitoruj(): string { return "Monitoring Stegozaura"; }
};

repoZwierząt.dodajZwierzę(triceratops);
repoZwierząt.dodajZwierzę(stegozaur);

// Dostęp przez indeksy
const zwierzę = repoZwierząt.pobierzZwierzę("TRIC-01");
if (zwierzę) {
  console.log(`Znaleziono: ${zwierzę.gatunek}`);
  zwierzę.karma();
}

console.log(`Liczba zwierząt w repozytorium: ${repoZwierząt.liczbaZwierząt}`);
console.log(`Ostatnia aktualizacja: ${repoZwierząt.ostatniaAktualizacja.toLocaleString()}`);

Implementacja wielu interfejsów

Klasa może implementować wiele interfejsów jednocześnie:

// Interfejs dla możliwości monitorowania
interface Monitorowalny {
  rozpocznijMonitoring(): void;
  zakończMonitoring(): void;
  pobierzStatusMonitoringu(): string;
}

// Interfejs dla systemów alarmowych
interface SystemAlarmowy {
  uruchomAlarm(): void;
  wyłączAlarm(): void;
  czyAlarmAktywny: boolean;
}

// Interfejs dla systemów kontroli dostępu
interface KontrolaDostępu {
  sprawdźDostęp(poziomUprawnień: number): boolean;
  zablokujDostęp(): void;
  odblokujDostęp(): void;
}

// Klasa implementująca wszystkie trzy interfejsy
class ZaawansowanySystemBezpieczeństwa implements Monitorowalny, SystemAlarmowy, KontrolaDostępu {
  private id: string;
  private aktywnyMonitoring: boolean = false;
  czyAlarmAktywny: boolean = false;
  private dostępZablokowany: boolean = false;
  private minimalnyPoziomUprawnień: number;

  constructor(id: string, minimalnyPoziomUprawnień: number = 3) {
    this.id = id;
    this.minimalnyPoziomUprawnień = minimalnyPoziomUprawnień;
  }

  // Implementacja Monitorowalny
  rozpocznijMonitoring(): void {
    this.aktywnyMonitoring = true;
    console.log(`System ${this.id}: Rozpoczęto monitoring.`);
  }

  zakończMonitoring(): void {
    this.aktywnyMonitoring = false;
    console.log(`System ${this.id}: Zakończono monitoring.`);
  }

  pobierzStatusMonitoringu(): string {
    return `System ${this.id}: Monitoring ${this.aktywnyMonitoring ? "aktywny" : "nieaktywny"}`;
  }

  // Implementacja SystemAlarmowy
  uruchomAlarm(): void {
    this.czyAlarmAktywny = true;
    this.zablokujDostęp(); // Automatyczna blokada dostępu
    console.log(`System ${this.id}: !!! ALARM URUCHOMIONY !!!`);
  }

  wyłączAlarm(): void {
    this.czyAlarmAktywny = false;
    console.log(`System ${this.id}: Alarm wyłączony.`);
  }

  // Implementacja KontrolaDostępu
  sprawdźDostęp(poziomUprawnień: number): boolean {
    if (this.dostępZablokowany) {
      console.log(`System ${this.id}: Dostęp zablokowany dla wszystkich poziomów uprawnień.`);
      return false;
    }

    const dostępPrzyznany = poziomUprawnień >= this.minimalnyPoziomUprawnień;
    console.log(`System ${this.id}: Sprawdzanie dostępu dla poziomu ${poziomUprawnień}: ${dostępPrzyznany ? "PRZYZNANY" : "ODMOWA"}`);
    return dostępPrzyznany;
  }

  zablokujDostęp(): void {
    this.dostępZablokowany = true;
    console.log(`System ${this.id}: Dostęp zablokowany.`);
  }

  odblokujDostęp(): void {
    if (this.czyAlarmAktywny) {
      console.log(`System ${this.id}: Nie można odblokować dostępu - alarm aktywny!`);
      return;
    }

    this.dostępZablokowany = false;
    console.log(`System ${this.id}: Dostęp odblokowany.`);
  }

  // Własna metoda łącząca funkcjonalności z różnych interfejsów
  reagujNaWłamanie(): void {
    console.log(`System ${this.id}: Wykryto próbę włamania!`);
    this.rozpocznijMonitoring();
    this.uruchomAlarm();
    // Dostęp jest już zablokowany przez uruchomAlarm()
  }
}

// Użycie klasy implementującej wiele interfejsów
const systemZabezpieczeńLab = new ZaawansowanySystemBezpieczeństwa("SEC-LAB-01", 4);

// Możemy użyć metod z różnych interfejsów
systemZabezpieczeńLab.rozpocznijMonitoring();
console.log(systemZabezpieczeńLab.pobierzStatusMonitoringu());

// Sprawdzenie dostępu
console.log(systemZabezpieczeńLab.sprawdźDostęp(3)); // Odmowa - wymagany poziom 4
console.log(systemZabezpieczeńLab.sprawdźDostęp(5)); // Dostęp przyznany

// Reakcja na włamanie
systemZabezpieczeńLab.reagujNaWłamanie();

// Próba odblokowania dostępu podczas alarmu
systemZabezpieczeńLab.odblokujDostęp(); // Nie pozwoli odblokować

// Wyłączenie alarmu i odblokowanie
systemZabezpieczeńLab.wyłączAlarm();
systemZabezpieczeńLab.odblokujDostęp();

Implementacja interfejsów z konfliktami nazw

Co się stanie, gdy implementujemy dwa interfejsy z właściwościami o tych samych nazwach?

// Dwa interfejsy z właściwościami o tej samej nazwie
interface SystemA {
  id: string;
  status: string;
  aktywuj(): void;
}

interface SystemB {
  id: number; // Konflikt typu - string vs number
  status: string; // Taki sam typ, brak konfliktu
  aktywuj(kod: string): boolean; // Konflikt sygnatury
}

// Próba implementacji obu interfejsów
// Ta implementacja spowoduje błąd kompilacji
/*
class ProblemowaSytuacja implements SystemA, SystemB {
  id: string; // Nie może być jednocześnie string i number
  status: string; // OK, ten sam typ w obu interfejsach

  // Próba implementacji obu sygnatur aktywuj
  aktywuj(kod?: string): boolean | void {
    if (kod) {
      console.log(`Aktywacja z kodem: ${kod}`);
      return true;
    } else {
      console.log("Aktywacja bez kodu");
    }
  }
}
*/

// Poprawna implementacja:
// Musimy stworzyć typ, który jest kompatybilny z oboma interfejsami
interface SystemKombinowany extends SystemA, SystemB {
  // Rozwiązanie konfliktu id
  id: string & number; // Musi być zarówno string jak i number (niemożliwe w praktyce)

  // Status bez konfliktu
  status: string;

  // Rozwiązanie konfliktu metody
  aktywuj(kod?: string): boolean | void;
}

// W praktyce, często niemożliwe jest zaimplementowanie obu interfejsów jednocześnie
// W takim przypadku lepiej zmodyfikować jeden z interfejsów lub
// stworzyć adapter, który przekierowuje wywołania

Jak rozwiązać problem niekompatybilnych interfejsów:

// Lepsze podejście: Używanie kompozycji zamiast dziedziczenia
class SystemDostępu {
  private systemA: SystemAImplementacja;
  private systemB: SystemBImplementacja;

  constructor() {
    this.systemA = new SystemAImplementacja("SYS-A");
    this.systemB = new SystemBImplementacja(1001);
  }

  // Metody delegujące do odpowiednich implementacji
  aktywujA(): void {
    this.systemA.aktywuj();
  }

  aktywujB(kod: string): boolean {
    return this.systemB.aktywuj(kod);
  }

  pobierzStatusA(): string {
    return this.systemA.status;
  }

  pobierzStatusB(): string {
    return this.systemB.status;
  }
}

// Implementacje pojedynczych interfejsów
class SystemAImplementacja implements SystemA {
  id: string;
  status: string = "nieaktywny";

  constructor(id: string) {
    this.id = id;
  }

  aktywuj(): void {
    this.status = "aktywny";
    console.log(`System A (${this.id}) aktywowany`);
  }
}

class SystemBImplementacja implements SystemB {
  id: number;
  status: string = "offline";

  constructor(id: number) {
    this.id = id;
  }

  aktywuj(kod: string): boolean {
    if (kod === "tajne-hasło") {
      this.status = "online";
      console.log(`System B (${this.id}) aktywowany z kodem`);
      return true;
    }
    console.log(`System B (${this.id}) - błędny kod aktywacji`);
    return false;
  }
}

Praktyczny przykład: System zarządzania Parkiem Jurajskim

Poniżej znajduje się kompleksowy przykład wykorzystujący interfejsy do stworzenia systemu zarządzania dla Parku Jurajskiego:

// Interfejs dla podstawowego bytu zarządzalnego
interface PozycjaInwentarza {
  readonly id: string;
  nazwa: string;
  kategoria: string;
  dataDodania: Date;
  ostatniaAktualizacja: Date;
  status: "aktywny" | "nieaktywny" | "w naprawie" | "wycofany";

  aktualizujStatus(nowyStatus: "aktywny" | "nieaktywny" | "w naprawie" | "wycofany"): void;
  pobierzInformacje(): Record<string, any>;
}

// Interfejs dla obiektów, które mogą być śledzone
interface Śledzone {
  lokalizacjaBieżąca: { x: number, y: number } | null;
  historiaLokalizacji: Array<{ czas: Date, x: number, y: number }>;

  aktualizujLokalizację(x: number, y: number): void;
  pobierzOstatniaLokalizację(): { czas: Date, x: number, y: number } | null;
  pobierzTraséRuchu(odCzas: Date, doCzas?: Date): Array<{ czas: Date, x: number, y: number }>;
}

// Interfejs dla obiektów, które mogą być monitorowane
interface Monitorowane {
  parametryMonitorowane: Map<string, number | string | boolean>;
  historiaPomiarów: Array<{ czas: Date, parametr: string, wartość: number | string | boolean }>;
  statusMonitoringu: "włączony" | "wyłączony" | "ograniczony";

  rozpocznijMonitoring(): void;
  zakończMonitoring(): void;
  dodajPomiar(parametr: string, wartość: number | string | boolean): void;
  pobierzOstatniePomiary(liczba?: number): Array<{ czas: Date, parametr: string, wartość: number | string | boolean }>;
}

// Interfejs dla obiektów wymagających regularnej konserwacji
interface Konserwowalny {
  wymaganyPoziomKonserwacji: number; // 1-5
  ostatniaKonserwacja: Date | null;
  planowanaKonserwacja: Date | null;
  historiaKonserwacji: Array<{ data: Date, opis: string, wykonawca: string }>;

  zaplanujKonserwację(data: Date): void;
  wykonajKonserwację(opis: string, wykonawca: string): void;
  sprawdźStatusKonserwacji(): "wymagana" | "zaplanowana" | "aktualna";
}

// Interfejs dla systemów bezpieczeństwa
interface SystemBezpieczeństwa {
  poziomZagrożenia: 1 | 2 | 3 | 4 | 5;
  strefaBezpieczeństwa: string;
  osobyUprawnione: string[];

  podnieśPoziomZagrożenia(): void;
  obniżPoziomZagrożenia(): void;
  sprawdźUprawnienia(idPracownika: string): boolean;
  reagujNaZagrożenie(opis: string): void;
}

// Implementacja urządzenia monitorującego dinozaury
class UrządzenieŚledząceT3000 implements PozycjaInwentarza, Śledzone, Monitorowane, Konserwowalny {
  // PozycjaInwentarza
  readonly id: string;
  nazwa: string;
  kategoria: string = "Urządzenie Śledzące";
  dataDodania: Date;
  ostatniaAktualizacja: Date;
  status: "aktywny" | "nieaktywny" | "w naprawie" | "wycofany";

  // Śledzone
  lokalizacjaBieżąca: { x: number, y: number } | null = null;
  historiaLokalizacji: Array<{ czas: Date, x: number, y: number }> = [];

  // Monitorowane
  parametryMonitorowane: Map<string, number | string | boolean> = new Map();
  historiaPomiarów: Array<{ czas: Date, parametr: string, wartość: number | string | boolean }> = [];
  statusMonitoringu: "włączony" | "wyłączony" | "ograniczony" = "wyłączony";

  // Konserwowalny
  wymaganyPoziomKonserwacji: number = 3;
  ostatniaKonserwacja: Date | null = null;
  planowanaKonserwacja: Date | null = null;
  historiaKonserwacji: Array<{ data: Date, opis: string, wykonawca: string }> = [];

  // Własne właściwości
  private bateriaPoziom: number = 100; // w procentach
  private przypisanyDinozaur: string | null = null;

  constructor(id: string, nazwa: string) {
    this.id = id;
    this.nazwa = nazwa;
    this.dataDodania = new Date();
    this.ostatniaAktualizacja = new Date();
    this.status = "nieaktywny";

    // Inicjalizacja parametrów monitorowania
    this.parametryMonitorowane.set("bateria", this.bateriaPoziom);
    this.parametryMonitorowane.set("aktywny", false);
    this.parametryMonitorowane.set("temperatura", 25.0);
  }

  // Implementacja metod PozycjaInwentarza
  aktualizujStatus(nowyStatus: "aktywny" | "nieaktywny" | "w naprawie" | "wycofany"): void {
    this.status = nowyStatus;
    this.ostatniaAktualizacja = new Date();
    console.log(`Urządzenie ${this.id}: Zmieniono status na ${nowyStatus}`);
  }

  pobierzInformacje(): Record<string, any> {
    return {
      id: this.id,
      nazwa: this.nazwa,
      kategoria: this.kategoria,
      status: this.status,
      dataDodania: this.dataDodania,
      ostatniaAktualizacja: this.ostatniaAktualizacja,
      bateriaPoziom: this.bateriaPoziom,
      przypisanyDinozaur: this.przypisanyDinozaur
    };
  }

  // Implementacja metod Śledzone
  aktualizujLokalizację(x: number, y: number): void {
    const czas = new Date();

    // Aktualizacja bieżącej lokalizacji
    this.lokalizacjaBieżąca = { x, y };

    // Dodanie do historii
    this.historiaLokalizacji.push({ czas, x, y });

    // Symulacja zużycia baterii
    this.zmniejszBaterię(0.1);

    console.log(`Urządzenie ${this.id}: Zaktualizowano lokalizację na [x: ${x}, y: ${y}]`);
  }

  pobierzOstatniaLokalizację(): { czas: Date, x: number, y: number } | null {
    if (this.historiaLokalizacji.length === 0) {
      return null;
    }

    return this.historiaLokalizacji[this.historiaLokalizacji.length - 1];
  }

  pobierzTraséRuchu(odCzas: Date, doCzas: Date = new Date()): Array<{ czas: Date, x: number, y: number }> {
    return this.historiaLokalizacji.filter(lok =>
      lok.czas >= odCzas && lok.czas <= doCzas
    );
  }

  // Implementacja metod Monitorowane
  rozpocznijMonitoring(): void {
    if (this.statusMonitoringu !== "włączony") {
      this.statusMonitoringu = "włączony";
      console.log(`Urządzenie ${this.id}: Rozpoczęto monitoring`);

      // Symulacja pomiaru przy włączeniu monitoringu
      this.dodajPomiar("aktywny", true);
    }
  }

  zakończMonitoring(): void {
    if (this.statusMonitoringu !== "wyłączony") {
      this.statusMonitoringu = "wyłączony";
      console.log(`Urządzenie ${this.id}: Zakończono monitoring`);

      // Aktualizacja parametru aktywności
      this.parametryMonitorowane.set("aktywny", false);
      this.dodajPomiar("aktywny", false);
    }
  }

  dodajPomiar(parametr: string, wartość: number | string | boolean): void {
    const czas = new Date();

    // Aktualizacja bieżącej wartości parametru
    this.parametryMonitorowane.set(parametr, wartość);

    // Dodanie do historii pomiarów
    this.historiaPomiarów.push({ czas, parametr, wartość });

    // Aktualizacja czasu ostatniej aktualizacji
    this.ostatniaAktualizacja = czas;

    console.log(`Urządzenie ${this.id}: Dodano pomiar ${parametr} = ${wartość}`);
  }

  pobierzOstatniePomiary(liczba: number = 10): Array<{ czas: Date, parametr: string, wartość: number | string | boolean }> {
    // Zwraca określoną liczbę ostatnich pomiarów
    return this.historiaPomiarów.slice(-liczba);
  }

  // Implementacja metod Konserwowalny
  zaplanujKonserwację(data: Date): void {
    this.planowanaKonserwacja = data;
    console.log(`Urządzenie ${this.id}: Zaplanowano konserwację na ${data.toLocaleDateString()}`);
  }

  wykonajKonserwację(opis: string, wykonawca: string): void {
    const data = new Date();

    // Dodanie do historii konserwacji
    this.historiaKonserwacji.push({ data, opis, wykonawca });

    // Aktualizacja daty ostatniej konserwacji
    this.ostatniaKonserwacja = data;

    // Resetowanie planowanej konserwacji
    this.planowanaKonserwacja = null;

    // Aktualizacja statusu i baterii po konserwacji
    this.aktualizujStatus("aktywny");
    this.bateriaPoziom = 100;
    this.parametryMonitorowane.set("bateria", this.bateriaPoziom);
    this.dodajPomiar("bateria", this.bateriaPoziom);

    console.log(`Urządzenie ${this.id}: Wykonano konserwację przez ${wykonawca}: ${opis}`);
  }

  sprawdźStatusKonserwacji(): "wymagana" | "zaplanowana" | "aktualna" {
    // Brak wcześniejszej konserwacji - wymagana
    if (!this.ostatniaKonserwacja) {
      return "wymagana";
    }

    // Zaplanowana konserwacja w przyszłości
    if (this.planowanaKonserwacja && this.planowanaKonserwacja > new Date()) {
      return "zaplanowana";
    }

    // Sprawdzenie, czy minęło więcej niż 90 dni od ostatniej konserwacji
    const dzisiaj = new Date();
    const różnicaMilisekundy = dzisiaj.getTime() - this.ostatniaKonserwacja.getTime();
    const różnicaDni = różnicaMilisekundy / (1000 * 60 * 60 * 24);

    if (różnicaDni > 90 || this.bateriaPoziom < 20) {
      return "wymagana";
    }

    return "aktualna";
  }

  // Własne metody
  przypiszDinozaura(idDinozaura: string): void {
    this.przypisanyDinozaur = idDinozaura;
    this.dodajPomiar("przypisanyDinozaur", idDinozaura);
    console.log(`Urządzenie ${this.id}: Przypisano do dinozaura ${idDinozaura}`);
  }

  private zmniejszBaterię(wartość: number): void {
    this.bateriaPoziom = Math.max(0, this.bateriaPoziom - wartość);
    this.parametryMonitorowane.set("bateria", this.bateriaPoziom);

    // Jeśli bateria jest krytycznie niska - zmień status
    if (this.bateriaPoziom < 5 && this.status === "aktywny") {
      this.aktualizujStatus("nieaktywny");
      console.log(`Urządzenie ${this.id}: Krytyczny poziom baterii! Urządzenie wyłączone.`);
    }
  }
}

// Implementacja systemu zabezpieczeń wybiegu dinozaurów
class OgrodzenieElektryczne implements PozycjaInwentarza, SystemBezpieczeństwa, Konserwowalny {
  // PozycjaInwentarza
  readonly id: string;
  nazwa: string;
  kategoria: string = "Ogrodzenie Elektryczne";
  dataDodania: Date;
  ostatniaAktualizacja: Date;
  status: "aktywny" | "nieaktywny" | "w naprawie" | "wycofany";

  // SystemBezpieczeństwa
  poziomZagrożenia: 1 | 2 | 3 | 4 | 5 = 1;
  strefaBezpieczeństwa: string;
  osobyUprawnione: string[] = [];

  // Konserwowalny
  wymaganyPoziomKonserwacji: number = 5; // Najwyższy poziom - kluczowe dla bezpieczeństwa
  ostatniaKonserwacja: Date | null = null;
  planowanaKonserwacja: Date | null = null;
  historiaKonserwacji: Array<{ data: Date, opis: string, wykonawca: string }> = [];

  // Własne właściwości
  private napięcie: number; // w woltach
  private długośćOgrodzenia: number; // w metrach
  private czujnikiRuchu: boolean;

  constructor(
    id: string,
    nazwa: string,
    strefaBezpieczeństwa: string,
    długośćOgrodzenia: number,
    napięcie: number = 10000,
    czujnikiRuchu: boolean = true
  ) {
    this.id = id;
    this.nazwa = nazwa;
    this.strefaBezpieczeństwa = strefaBezpieczeństwa;
    this.długośćOgrodzenia = długośćOgrodzenia;
    this.napięcie = napięcie;
    this.czujnikiRuchu = czujnikiRuchu;

    this.dataDodania = new Date();
    this.ostatniaAktualizacja = new Date();
    this.status = "nieaktywny";

    // Dodanie administratorów systemu jako osób uprawnionych
    this.osobyUprawnione.push("ADMIN-001", "SEC-CHIEF", "TECH-HEAD");
  }

  // Implementacja PozycjaInwentarza
  aktualizujStatus(nowyStatus: "aktywny" | "nieaktywny" | "w naprawie" | "wycofany"): void {
    // Jeśli przełączamy z nieaktywnego na aktywny
    if (this.status !== "aktywny" && nowyStatus === "aktywny") {
      // Sprawdź, czy konserwacja jest wymagana
      if (this.sprawdźStatusKonserwacji() === "wymagana") {
        console.log(`Ogrodzenie ${this.id}: OSTRZEŻENIE - Aktywacja bez wymaganej konserwacji!`);
      }
    }

    this.status = nowyStatus;
    this.ostatniaAktualizacja = new Date();

    // Automatycznie dostosuj napięcie w zależności od statusu
    if (nowyStatus === "aktywny") {
      console.log(`Ogrodzenie ${this.id}: Aktywowano z napięciem ${this.napięcie}V`);
    } else if (nowyStatus === "nieaktywny" || nowyStatus === "w naprawie") {
      this.napięcie = 0;
      console.log(`Ogrodzenie ${this.id}: Dezaktywowano - napięcie 0V`);
    }
  }

  pobierzInformacje(): Record<string, any> {
    return {
      id: this.id,
      nazwa: this.nazwa,
      kategoria: this.kategoria,
      status: this.status,
      strefaBezpieczeństwa: this.strefaBezpieczeństwa,
      długośćOgrodzenia: this.długośćOgrodzenia,
      napięcie: this.napięcie,
      czujnikiRuchu: this.czujnikiRuchu,
      poziomZagrożenia: this.poziomZagrożenia
    };
  }

  // Implementacja SystemBezpieczeństwa
  podnieśPoziomZagrożenia(): void {
    if (this.poziomZagrożenia < 5) {
      this.poziomZagrożenia = (this.poziomZagrożenia + 1) as 1 | 2 | 3 | 4 | 5;

      // Automatyczne zwiększenie napięcia
      this.zwiększNapięcie(2000 * this.poziomZagrożenia);

      console.log(`Ogrodzenie ${this.id}: Podniesiono poziom zagrożenia do ${this.poziomZagrożenia}. Nowe napięcie: ${this.napięcie}V`);
    } else {
      console.log(`Ogrodzenie ${this.id}: Poziom zagrożenia już na maksymalnym poziomie 5`);
    }
  }

  obniżPoziomZagrożenia(): void {
    if (this.poziomZagrożenia > 1) {
      this.poziomZagrożenia = (this.poziomZagrożenia - 1) as 1 | 2 | 3 | 4 | 5;

      // Automatyczne zmniejszenie napięcia (ale nadal aktywne)
      const noweNapięcie = 10000 + (2000 * (this.poziomZagrożenia - 1));
      this.napięcie = noweNapięcie;

      console.log(`Ogrodzenie ${this.id}: Obniżono poziom zagrożenia do ${this.poziomZagrożenia}. Nowe napięcie: ${this.napięcie}V`);
    } else {
      console.log(`Ogrodzenie ${this.id}: Poziom zagrożenia już na minimalnym poziomie 1`);
    }
  }

  sprawdźUprawnienia(idPracownika: string): boolean {
    return this.osobyUprawnione.includes(idPracownika);
  }

  reagujNaZagrożenie(opis: string): void {
    console.log(`Ogrodzenie ${this.id}: ALERT! ${opis}`);

    // Maksymalny poziom zagrożenia
    this.poziomZagrożenia = 5;

    // Maksymalne napięcie
    this.napięcie = 30000;

    console.log(`Ogrodzenie ${this.id}: Poziom zagrożenia 5. Napięcie maksymalne: ${this.napięcie}V`);
  }

  // Implementacja Konserwowalny
  zaplanujKonserwację(data: Date): void {
    this.planowanaKonserwacja = data;
    console.log(`Ogrodzenie ${this.id}: Zaplanowano konserwację na ${data.toLocaleDateString()}`);
  }

  wykonajKonserwację(opis: string, wykonawca: string): void {
    const data = new Date();

    // Zabezpieczenie - tymczasowa dezaktywacja ogrodzenia podczas konserwacji
    const poprzedniStatus = this.status;
    this.aktualizujStatus("w naprawie");

    // Dodanie do historii konserwacji
    this.historiaKonserwacji.push({ data, opis, wykonawca });

    // Aktualizacja daty ostatniej konserwacji
    this.ostatniaKonserwacja = data;

    // Resetowanie planowanej konserwacji
    this.planowanaKonserwacja = null;

    console.log(`Ogrodzenie ${this.id}: Wykonano konserwację przez ${wykonawca}: ${opis}`);

    // Przywrócenie poprzedniego statusu
    this.aktualizujStatus(poprzedniStatus);
  }

  sprawdźStatusKonserwacji(): "wymagana" | "zaplanowana" | "aktualna" {
    // Brak wcześniejszej konserwacji - wymagana
    if (!this.ostatniaKonserwacja) {
      return "wymagana";
    }

    // Zaplanowana konserwacja w przyszłości
    if (this.planowanaKonserwacja && this.planowanaKonserwacja > new Date()) {
      return "zaplanowana";
    }

    // Sprawdzenie, czy minęło więcej niż 30 dni od ostatniej konserwacji (krótszy okres dla ogrodzeń)
    const dzisiaj = new Date();
    const różnicaMilisekundy = dzisiaj.getTime() - this.ostatniaKonserwacja.getTime();
    const różnicaDni = różnicaMilisekundy / (1000 * 60 * 60 * 24);

    if (różnicaDni > 30) {
      return "wymagana";
    }

    return "aktualna";
  }

  // Własne metody
  dodajOsobęUprawnioną(idPracownika: string): void {
    if (!this.osobyUprawnione.includes(idPracownika)) {
      this.osobyUprawnione.push(idPracownika);
      console.log(`Ogrodzenie ${this.id}: Dodano uprawnienia dla pracownika ${idPracownika}`);
    }
  }

  usuńOsobęUprawnioną(idPracownika: string): void {
    const indeks = this.osobyUprawnione.indexOf(idPracownika);
    if (indeks !== -1) {
      this.osobyUprawnione.splice(indeks, 1);
      console.log(`Ogrodzenie ${this.id}: Usunięto uprawnienia dla pracownika ${idPracownika}`);
    }
  }

  zwiększNapięcie(wartość: number): void {
    if (this.status !== "aktywny") {
      console.log(`Ogrodzenie ${this.id}: Nie można zmienić napięcia - ogrodzenie nie jest aktywne`);
      return;
    }

    this.napięcie += wartość;
    console.log(`Ogrodzenie ${this.id}: Zwiększono napięcie do ${this.napięcie}V`);
  }

  zmniejszNapięcie(wartość: number): void {
    if (this.status !== "aktywny") {
      console.log(`Ogrodzenie ${this.id}: Nie można zmienić napięcia - ogrodzenie nie jest aktywne`);
      return;
    }

    this.napięcie = Math.max(0, this.napięcie - wartość);
    console.log(`Ogrodzenie ${this.id}: Zmniejszono napięcie do ${this.napięcie}V`);
  }
}

// Demonstrujemy użycie naszych implementacji
function demonstrujSystemParku() {
  console.log("=== DEMONSTRACJA SYSTEMU ZARZĄDZANIA PARKIEM JURAJSKIM ===");

  // Utworzenie urządzenia śledzącego
  console.log("\n--- Inicjalizacja urządzenia śledzącego ---");
  const urządzenieŚledzące = new UrządzenieŚledząceT3000("TRACK-001", "Lokalizator T-Rex #1");
  urządzenieŚledzące.aktualizujStatus("aktywny");
  urządzenieŚledzące.rozpocznijMonitoring();
  urządzenieŚledzące.przypiszDinozaura("TREX-001");

  // Symulacja śledzenia lokalizacji
  urządzenieŚledzące.aktualizujLokalizację(135.42, 86.21);
  urządzenieŚledzące.aktualizujLokalizację(135.50, 86.35);
  urządzenieŚledzące.aktualizujLokalizację(135.62, 86.40);

  // Utworzenie ogrodzenia
  console.log("\n--- Inicjalizacja ogrodzenia ---");
  const ogrodzenie = new OgrodzenieElektryczne(
    "FENCE-002",
    "Ogrodzenie wybiegu T-Rex",
    "T-REX-A",
    1200, // 1200 metrów długości
    15000, // 15000V
    true // z czujnikami ruchu
  );

  // Dodanie uprawnień dla pracownika
  ogrodzenie.dodajOsobęUprawnioną("EMP-047"); // Owen Grady

  // Aktywacja ogrodzenia
  ogrodzenie.aktualizujStatus("aktywny");

  // Przeprowadzenie konserwacji urządzenia
  console.log("\n--- Konserwacja urządzenia ---");
  urządzenieŚledzące.zaplanujKonserwację(new Date("2023-06-15"));
  urządzenieŚledzące.wykonajKonserwację("Wymiana baterii i kalibracja GPS", "Tech Ivan");

  // Symulacja alarmu
  console.log("\n--- Symulacja incydentu ---");
  console.log("T-Rex próbuje przedostać się przez ogrodzenie!");

  // Urządzenie śledzące rejestruje gwałtowny ruch
  urządzenieŚledzące.aktualizujLokalizację(135.90, 86.70);
  urządzenieŚledzące.aktualizujLokalizację(136.10, 86.90);
  urządzenieŚledzące.dodajPomiar("przyspieszenie", 12.5);

  // Ogrodzenie reaguje na zagrożenie
  ogrodzenie.reagujNaZagrożenie("Wykryto próbę ucieczki T-Rexa");

  // Sprawdzenia statusu po incydencie
  console.log("\n--- Raport po incydencie ---");
  console.log("Ostatnia lokalizacja dinozaura:", urządzenieŚledzące.pobierzOstatniaLokalizację());
  console.log("Status ogrodzenia:", ogrodzenie.pobierzInformacje());

  // Powrót do normalnego trybu
  console.log("\n--- Normalizacja sytuacji ---");
  ogrodzenie.obniżPoziomZagrożenia();
  ogrodzenie.obniżPoziomZagrożenia();

  console.log("\n=== KONIEC DEMONSTRACJI ===");
}

// Uruchomienie demonstracji
demonstrujSystemParku();

Podsumowanie

W tym ćwiczeniu poznaliśmy interfejsy TypeScript - potężne narzędzie do definiowania kontraktów i tworzenia spójnych struktur w kodzie.

Najważniejsze cechy interfejsów:

  1. Definiują kształt obiektów - określają, jakie właściwości i metody muszą posiadać obiekty danego typu
  2. Wsparcie dla polimorfizmu - różne klasy mogą implementować ten sam interfejs na różne sposoby
  3. Luźne powiązanie - skupiają się na tym, co obiekty robią, a nie jak są zaimplementowane
  4. Elastyczność - właściwości opcjonalne, tylko do odczytu, indeksy, itp.
  5. Rozszerzalność - interfejsy mogą dziedziczyć po innych interfejsach

Jak Claire Dearing podsumowałaby: "W Parku Jurajskim, podobnie jak w dobrej architekturze oprogramowania, każdy ma swoją rolę i obowiązki. Interfejsy pozwalają nam jasno zdefiniować te role, zapewniając, że wszystkie systemy dobrze ze sobą współpracują - bez niespodzianek. A uwierzcie mi, niespodzianki w parku pełnym dinozaurów to ostatnia rzecz, jakiej potrzebujemy."

Kod do tej lekcji: index.ts
// Implementacja interfejsow - Park Jurajski
console.log("=== IMPLEMENTACJA INTERFEJSOW ===\n");

// ===========================================
// 1. Definicja interfejsow
// ===========================================

interface ITrackable {
  readonly trackingId: string;
  location: { x: number; y: number };
  getLocation(): string;
  updateLocation(x: number, y: number): void;
}

interface IFeedable {
  diet: "carnivore" | "herbivore" | "omnivore";
  lastFedAt: Date;
  feed(food: string): string;
  isHungry(): boolean;
}

interface IContainable {
  enclosureId: string;
  isContained: boolean;
  checkContainment(): string;
}

// ===========================================
// 2. Klasa implementujaca wiele interfejsow
// ===========================================

class ParkDinosaur implements ITrackable, IFeedable, IContainable {
  readonly trackingId: string;
  location: { x: number; y: number };
  diet: "carnivore" | "herbivore" | "omnivore";
  lastFedAt: Date;
  enclosureId: string;
  isContained: boolean;
  name: string;

  constructor(
    name: string,
    diet: "carnivore" | "herbivore" | "omnivore",
    enclosureId: string
  ) {
    this.name = name;
    this.trackingId = `TRK-${Math.random().toString(36).substring(2, 8).toUpperCase()}`;
    this.location = { x: 0, y: 0 };
    this.diet = diet;
    this.lastFedAt = new Date();
    this.enclosureId = enclosureId;
    this.isContained = true;
  }

  // ITrackable
  getLocation(): string {
    return `(${this.location.x}, ${this.location.y})`;
  }

  updateLocation(x: number, y: number): void {
    this.location = { x, y };
    console.log(`  ${this.name} przemieszczono do ${this.getLocation()}`);
  }

  // IFeedable
  feed(food: string): string {
    this.lastFedAt = new Date();
    return `${this.name} zjadl: ${food}`;
  }

  isHungry(): boolean {
    const hoursSinceFed = (Date.now() - this.lastFedAt.getTime()) / 3600000;
    return hoursSinceFed > 4;
  }

  // IContainable
  checkContainment(): string {
    return this.isContained
      ? `${this.name} jest bezpiecznie w zagrodzeniu ${this.enclosureId}`
      : `ALARM! ${this.name} wydostal sie z zagodzenia ${this.enclosureId}!`;
  }
}

// ===========================================
// 3. Funkcje operujace na interfejsach
// ===========================================

function trackEntity(entity: ITrackable): void {
  console.log(`Sledzenie: ${entity.trackingId} na pozycji ${entity.getLocation()}`);
}

function feedEntity(entity: IFeedable): void {
  console.log(`Dieta: ${entity.diet}`);
  console.log(`Glodny: ${entity.isHungry() ? "TAK" : "NIE"}`);
}

function checkSafety(entities: IContainable[]): void {
  console.log("\n--- Raport bezpieczenstwa ---");
  entities.forEach(e => console.log(e.checkContainment()));
}

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

const velociraptor = new ParkDinosaur("Blue", "carnivore", "ENC-A7");
const brachio = new ParkDinosaur("Patty", "herbivore", "ENC-B3");

console.log("--- Sledzenie ---");
trackEntity(velociraptor);
velociraptor.updateLocation(45, 120);
trackEntity(velociraptor);

console.log("\n--- Karmienie ---");
console.log(velociraptor.feed("Koza"));
console.log(brachio.feed("Liscie palmowe"));
feedEntity(brachio);

brachio.isContained = false; // Ucieczka!
checkSafety([velociraptor, brachio]);

console.log("\nInterfejsy pozwalaja na polimorfizm i luźne powiazanie!");

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. Co robi słowo kluczowe implements w TypeScript?

  2. 2. Jak zdefiniować interfejs generyczny w TypeScript?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj interfejsy ITrackable i IFeedable dla encji parku

  • Układanie w poziomie

    Ułóż elementy generycznego interfejsu:

  1. PytanieImplementacja interfejsu
  2. Zadanie z kodemImplementacja interfejsów
  3. Ułóż w kolejnościSkładnia generycznego interfejsu
  4. PytanieInterfejs generyczny

Przydatne artykuły