Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Rozszerzanie interfejsów

18 min czytania ·
W tej lekcji9

Witaj ponownie w Parku Jurajskim! Dziś Dr. Henry Wu poprowadzi nas przez zaawansowaną technikę TypeScript, która jest podstawą tworzenia skalowalnych i elastycznych systemów - rozszerzanie interfejsów. Podobnie jak naukowcy w parku rozszerzają podstawowe cechy dinozaurów o nowe właściwości genetyczne, tak w TypeScript możemy rozszerzać podstawowe interfejsy o nowe funkcjonalności.

Podstawowy mechanizm rozszerzania interfejsów

Rozszerzanie interfejsów w TypeScript pozwala nam tworzyć nowe interfejsy na bazie istniejących, dodając do nich nowe właściwości lub metody. Używamy do tego słowa kluczowego extends:

// Bazowy interfejs dla wszystkich stworzeń w parku
interface Stworzenie {
  id: string;
  nazwa: string;
  gatunek: string;
  wiek: number;
  waga: number;
}

// Rozszerzenie bazowego interfejsu o dodatkowe właściwości dla dinozaurów
interface Dinozaur extends Stworzenie {
  eraPochodzenia: string; // np. "Jura", "Kreda"
  dieta: "roślinożerca" | "mięsożerca" | "wszystkożerca";
  niebezpieczny: boolean;
}

// Teraz interfejs Dinozaur zawiera wszystkie pola z Stworzenie plus swoje własne
const trex: Dinozaur = {
  id: "TREX-01",
  nazwa: "Rex",
  gatunek: "Tyrannosaurus Rex",
  wiek: 7,
  waga: 7000,
  eraPochodzenia: "Kreda",
  dieta: "mięsożerca",
  niebezpieczny: true
};

Rozszerzanie wielu interfejsów

Interfejs może rozszerzać wiele innych interfejsów jednocześnie, co pozwala na komponowanie złożonych typów z mniejszych, wyspecjalizowanych części - podobnie jak naukowcy łączą DNA różnych gatunków, aby stworzyć hybrydy:

// Interfejs definiujący zdolności drapieżnika
interface ZdolnościDrapieżnika {
  siłaUgryzienia: number; // w PSI
  prędkośćBiegu: number; // w km/h
  stylPolowania: "zasadzka" | "pościg" | "stadny";
}

// Interfejs definiujący cechy zwierzęcia wodnego
interface ZwierzęWodne {
  zdolnośćPływania: number; // od 1 do 10
  maksGłębokość: number; // w metrach
  odpornośćNaSłonąWodę: boolean;
}

// Interfejs dla morskiego drapieżnika łączący oba powyższe interfejsy
interface MorskiDrapieżnik extends ZdolnościDrapieżnika, ZwierzęWodne {
  nazwaNaukowa: string;
}

// Tworzenie dinozaura, który jest morskim drapieżnikiem
const mosasaurus: MorskiDrapieżnik & Dinozaur = {
  // Właściwości z Stworzenie
  id: "MOSA-01",
  nazwa: "Mosa",
  gatunek: "Mosasaurus",
  wiek: 15,
  waga: 15000,

  // Właściwości z Dinozaur
  eraPochodzenia: "Kreda",
  dieta: "mięsożerca",
  niebezpieczny: true,

  // Właściwości z ZdolnościDrapieżnika
  siłaUgryzienia: 18000,
  prędkośćBiegu: 0, // nie biega, pływa
  stylPolowania: "zasadzka",

  // Właściwości z ZwierzęWodne
  zdolnośćPływania: 9,
  maksGłębokość: 500,
  odpornośćNaSłonąWodę: true,

  // Właściwości z MorskiDrapieżnik
  nazwaNaukowa: "Mosasaurus hoffmannii"
};

// Demonstracja dostępu do różnych właściwości
function analizujMorskiegoDrapieżnika(dino: MorskiDrapieżnik & Dinozaur): void {
  console.log(`Analizuję: ${dino.nazwa} (${dino.gatunek})`);
  console.log(`Siła ugryzienia: ${dino.siłaUgryzienia} PSI`);
  console.log(`Może nurkować do głębokości: ${dino.maksGłębokość} metrów`);
  console.log(`Zagrożenie dla zwiedzających: ${dino.niebezpieczny ? "WYSOKIE" : "NISKIE"}`);
}

analizujMorskiegoDrapieżnika(mosasaurus);

Rozszerzanie interfejsów a dziedziczenie klas

Rozszerzanie interfejsów jest podobne do dziedziczenia klas, ale ma kilka kluczowych różnic. W Parku Jurajskim, można to porównać do różnicy między "opisem idealnego dinozaura" (interfejs) a "rzeczywistym dinozaurem" (klasa):

// Interfejs dla systemów bezpieczeństwa
interface SystemBezpieczeństwa {
  nazwa: string;
  poziomBezpieczeństwa: number;
  czyAktywny: boolean;

  aktywuj(): void;
  dezaktywuj(): void;
  testuj(): boolean;
}

// Klasa implementująca interfejs
class ElektroniczneOgrodzenie implements SystemBezpieczeństwa {
  nazwa: string;
  poziomBezpieczeństwa: number;
  czyAktywny: boolean;
  napięcie: number; // dodatkowa właściwość specyficzna dla tej klasy

  constructor(nazwa: string, poziomBezpieczeństwa: number, napięcie: number) {
    this.nazwa = nazwa;
    this.poziomBezpieczeństwa = poziomBezpieczeństwa;
    this.czyAktywny = false;
    this.napięcie = napięcie;
  }

  aktywuj(): void {
    this.czyAktywny = true;
    console.log(`System ${this.nazwa} został aktywowany z napięciem ${this.napięcie}V`);
  }

  dezaktywuj(): void {
    this.czyAktywny = false;
    console.log(`System ${this.nazwa} został dezaktywowany`);
  }

  testuj(): boolean {
    console.log(`Testowanie systemu ${this.nazwa}...`);
    return Math.random() > 0.1; // 90% szans na pomyślny test
  }

  // Metoda specyficzna dla tej klasy
  zwiększNapięcie(o: number): void {
    this.napięcie += o;
    console.log(`Napięcie zwiększone do ${this.napięcie}V`);
  }
}

// Rozszerzona wersja SystemBezpieczeństwa dla bardziej zaawansowanych systemów
interface ZaawansowanySystemBezpieczeństwa extends SystemBezpieczeństwa {
  backupZasilanie: boolean;
  monitoringWideo: boolean;
  powiadomieniaAlarmowe: boolean;

  uruchomProcedurębezpieczeństwa(poziomZagrożenia: number): void;
}

// Klasa implementująca rozszerzony interfejs
class ZintegrowanySstemBezpieczeństwa implements ZaawansowanySystemBezpieczeństwa {
  nazwa: string;
  poziomBezpieczeństwa: number;
  czyAktywny: boolean;
  backupZasilanie: boolean;
  monitoringWideo: boolean;
  powiadomieniaAlarmowe: boolean;

  constructor(nazwa: string, poziomBezpieczeństwa: number) {
    this.nazwa = nazwa;
    this.poziomBezpieczeństwa = poziomBezpieczeństwa;
    this.czyAktywny = false;
    this.backupZasilanie = true;
    this.monitoringWideo = true;
    this.powiadomieniaAlarmowe = true;
  }

  aktywuj(): void {
    this.czyAktywny = true;
    console.log(`Zintegrowany system ${this.nazwa} został aktywowany`);
  }

  dezaktywuj(): void {
    this.czyAktywny = false;
    console.log(`Zintegrowany system ${this.nazwa} został dezaktywowany`);
  }

  testuj(): boolean {
    console.log(`Testowanie zintegrowanego systemu ${this.nazwa}...`);
    const testZasilania = Math.random() > 0.05;
    const testMonitoringu = Math.random() > 0.05;
    const testPowiadomień = Math.random() > 0.05;

    return testZasilania && testMonitoringu && testPowiadomień;
  }

  uruchomProcedurębezpieczeństwa(poziomZagrożenia: number): void {
    console.log(`Uruchamianie procedury bezpieczeństwa poziomu ${poziomZagrożenia} dla systemu ${this.nazwa}`);
    this.aktywuj();

    if (poziomZagrożenia >= 4) {
      console.log("UWAGA: Wysoki poziom zagrożenia! Uruchamianie wszystkich zabezpieczeń!");
      // Tutaj dodatkowe działania dla wysokiego poziomu zagrożenia
    }
  }
}

// Demonstracja użycia
const ogrodzenieTRex = new ElektroniczneOgrodzenie("Wybieg T-Rex", 5, 10000);
ogrodzenieTRex.aktywuj();
ogrodzenieTRex.zwiększNapięcie(2000);

const zintegrowanySstemPark = new ZintegrowanySstemBezpieczeństwa("System Główny", 5);
zintegrowanySstemPark.uruchomProcedurębezpieczeństwa(4);

Rozszerzanie i implementacja generycznych interfejsów

Generyczne interfejsy są szczególnie potężne przy modelowaniu złożonych systemów, takich jak monitoring różnych typów danych w parku:

// Generyczny interfejs dla systemu monitoringu
interface SystemMonitoringu<T> {
  identyfikator: string;
  typDanych: string;
  aktualneDane: T;
  historyczneDane: T[];

  zapisz(dane: T): void;
  pobierzOstatnie(n: number): T[];
  analizujTrend(): string;
}

// Przykładowy typ danych dla monitoringu warunków środowiskowych
interface DaneŚrodowiskowe {
  temperatura: number;
  wilgotność: number;
  poziomCO2: number;
  nasłonecznienie: number;
  ciśnienie: number;
  czasPomiaru: Date;
}

// Implementacja systemu monitoringu dla konkretnego typu danych
class MonitoringŚrodowiskowy implements SystemMonitoringu<DaneŚrodowiskowe> {
  identyfikator: string;
  typDanych: string;
  aktualneDane: DaneŚrodowiskowe;
  historyczneDane: DaneŚrodowiskowe[];

  constructor(identyfikator: string) {
    this.identyfikator = identyfikator;
    this.typDanych = "środowiskowe";
    this.aktualneDane = {
      temperatura: 0,
      wilgotność: 0,
      poziomCO2: 0,
      nasłonecznienie: 0,
      ciśnienie: 0,
      czasPomiaru: new Date()
    };
    this.historyczneDane = [];
  }

  zapisz(dane: DaneŚrodowiskowe): void {
    this.aktualneDane = dane;
    this.historyczneDane.push(dane);
    console.log(`Zapisano nowe dane dla monitora ${this.identyfikator} o czasie ${dane.czasPomiaru.toISOString()}`);
  }

  pobierzOstatnie(n: number): DaneŚrodowiskowe[] {
    return this.historyczneDane.slice(-n);
  }

  analizujTrend(): string {
    if (this.historyczneDane.length < 2) {
      return "Za mało danych do analizy trendu";
    }

    const ostatnie = this.historyczneDane[this.historyczneDane.length - 1];
    const przedostatnie = this.historyczneDane[this.historyczneDane.length - 2];

    let trendy = [];

    if (ostatnie.temperatura > przedostatnie.temperatura) {
      trendy.push("Temperatura: WZROST");
    } else if (ostatnie.temperatura < przedostatnie.temperatura) {
      trendy.push("Temperatura: SPADEK");
    } else {
      trendy.push("Temperatura: STABILNA");
    }

    if (ostatnie.wilgotność > przedostatnie.wilgotność) {
      trendy.push("Wilgotność: WZROST");
    } else if (ostatnie.wilgotność < przedostatnie.wilgotność) {
      trendy.push("Wilgotność: SPADEK");
    } else {
      trendy.push("Wilgotność: STABILNA");
    }

    // Podobne analizy dla pozostałych parametrów

    return trendy.join(", ");
  }

  // Metoda specyficzna dla monitoringu środowiskowego
  ostrzeżenieTemperaturowe(): boolean {
    return this.aktualneDane.temperatura > 35 || this.aktualneDane.temperatura < 15;
  }
}

// Rozszerzenie bazowego interfejsu o specyficzne funkcje dla monitoringu dinozaurów
interface SystemMonitoringuDinozaurów<T> extends SystemMonitoringu<T> {
  idDinozaura: string;
  gatunek: string;
  progiAlarmowe: Partial<T>;

  sprawdźProgiAlarmowe(): boolean;
  wyslijAlertJeśliPotrzebny(): void;
}

// Typ danych dla monitoringu zdrowia dinozaurów
interface DaneZdrowiaDinozaura {
  temperaturaCiała: number;
  tętno: number;
  ciśnienieKrwi: [number, number]; // [skurczowe, rozkurczowe]
  poziomStresu: number; // 1-10
  poziomAktywności: number; // 1-10
  czasPomiaru: Date;
}

// Implementacja specyficznego systemu monitoringu dla dinozaurów
class MonitoringZdrowiaDinozaura implements SystemMonitoringuDinozaurów<DaneZdrowiaDinozaura> {
  identyfikator: string;
  typDanych: string;
  aktualneDane: DaneZdrowiaDinozaura;
  historyczneDane: DaneZdrowiaDinozaura[];
  idDinozaura: string;
  gatunek: string;
  progiAlarmowe: Partial<DaneZdrowiaDinozaura>;

  constructor(identyfikator: string, idDinozaura: string, gatunek: string) {
    this.identyfikator = identyfikator;
    this.typDanych = "zdrowia";
    this.aktualneDane = {
      temperaturaCiała: 0,
      tętno: 0,
      ciśnienieKrwi: [0, 0],
      poziomStresu: 0,
      poziomAktywności: 0,
      czasPomiaru: new Date()
    };
    this.historyczneDane = [];
    this.idDinozaura = idDinozaura;
    this.gatunek = gatunek;

    // Ustawienie progów alarmowych w zależności od gatunku
    if (gatunek === "Tyrannosaurus") {
      this.progiAlarmowe = {
        temperaturaCiała: 39, // Powyżej tej temperatury - alarm
        tętno: 95, // Powyżej tego tętna - alarm
        poziomStresu: 7 // Powyżej tego poziomu stresu - alarm
      };
    } else if (gatunek === "Velociraptor") {
      this.progiAlarmowe = {
        temperaturaCiała: 40,
        tętno: 120,
        poziomStresu: 8
      };
    } else {
      // Domyślne progi dla innych gatunków
      this.progiAlarmowe = {
        temperaturaCiała: 38,
        tętno: 100,
        poziomStresu: 7
      };
    }
  }

  zapisz(dane: DaneZdrowiaDinozaura): void {
    this.aktualneDane = dane;
    this.historyczneDane.push(dane);
    console.log(`Zapisano nowe dane zdrowia dla dinozaura ${this.idDinozaura} (${this.gatunek})`);

    // Sprawdzamy czy wartości nie przekraczają progów
    this.wyslijAlertJeśliPotrzebny();
  }

  pobierzOstatnie(n: number): DaneZdrowiaDinozaura[] {
    return this.historyczneDane.slice(-n);
  }

  analizujTrend(): string {
    if (this.historyczneDane.length < 2) {
      return "Za mało danych do analizy trendu";
    }

    // Podobna analiza trendu jak w klasie MonitoringŚrodowiskowy
    //
    return "Analiza trendu zdrowia (przykładowa implementacja)";
  }

  sprawdźProgiAlarmowe(): boolean {
    let przekroczonyPróg = false;

    if (this.progiAlarmowe.temperaturaCiała &&
        this.aktualneDane.temperaturaCiała > this.progiAlarmowe.temperaturaCiała) {
      console.log(`ALARM: Temperatura ciała dinozaura ${this.idDinozaura} przekracza próg!`);
      przekroczonyPróg = true;
    }

    if (this.progiAlarmowe.tętno &&
        this.aktualneDane.tętno > this.progiAlarmowe.tętno) {
      console.log(`ALARM: Tętno dinozaura ${this.idDinozaura} przekracza próg!`);
      przekroczonyPróg = true;
    }

    if (this.progiAlarmowe.poziomStresu &&
        this.aktualneDane.poziomStresu > this.progiAlarmowe.poziomStresu) {
      console.log(`ALARM: Poziom stresu dinozaura ${this.idDinozaura} przekracza próg!`);
      przekroczonyPróg = true;
    }

    return przekroczonyPróg;
  }

  wyslijAlertJeśliPotrzebny(): void {
    if (this.sprawdźProgiAlarmowe()) {
      console.log(`Wysyłanie alertu do zespołu weterynaryjnego dla dinozaura ${this.idDinozaura}!`);
      // W rzeczywistym systemie wysłalibyśmy tu powiadomienie
    }
  }

  // Metoda specyficzna dla monitoringu zdrowia dinozaurów
  rekomendujInterwencję(): string {
    let rekomendacje = [];

    if (this.aktualneDane.temperaturaCiała > this.progiAlarmowe.temperaturaCiała!) {
      rekomendacje.push("Obniżenie temperatury ciała");
    }

    if (this.aktualneDane.poziomStresu > this.progiAlarmowe.poziomStresu!) {
      rekomendacje.push("Podanie środków uspokajających");
    }

    if (this.aktualneDane.poziomAktywności < 3) {
      rekomendacje.push("Sprawdzenie poziomu energii i ewentualne zwiększenie dawki pokarmowej");
    }

    return rekomendacje.length > 0
      ? `Rekomendowane działania: ${rekomendacje.join(", ")}`
      : "Brak rekomendacji - parametry w normie";
  }
}

// Przykład użycia
const monitorPaddockTRex = new MonitoringŚrodowiskowy("ENV-TREX-01");
monitorPaddockTRex.zapisz({
  temperatura: 28.5,
  wilgotność: 75,
  poziomCO2: 420,
  nasłonecznienie: 80,
  ciśnienie: 1013,
  czasPomiaru: new Date()
});

const monitorRexy = new MonitoringZdrowiaDinozaura("HEALTH-TREX-01", "TREX-01", "Tyrannosaurus");
monitorRexy.zapisz({
  temperaturaCiała: 38.2,
  tętno: 72,
  ciśnienieKrwi: [135, 85],
  poziomStresu: 3,
  poziomAktywności: 4,
  czasPomiaru: new Date()
});

// Symulacja problemu zdrowotnego
monitorRexy.zapisz({
  temperaturaCiała: 40.1, // Gorączka!
  tętno: 98, // Przyspieszone tętno
  ciśnienieKrwi: [155, 95], // Podwyższone ciśnienie
  poziomStresu: 8, // Wysoki poziom stresu
  poziomAktywności: 2, // Niska aktywność
  czasPomiaru: new Date()
});

console.log(monitorRexy.rekomendujInterwencję());

Łączenie deklaracji interfejsów

Jedną z unikalnych cech TypeScript jest możliwość łączenia wielu deklaracji tego samego interfejsu - podobnie jak naukowcy z Parku Jurajskiego mogą aktualizować swoje protokoły postępowania w miarę zdobywania nowych informacji:

// Początkowa definicja protokołu bezpieczeństwa
interface ProtokółBezpieczeństwa {
  id: string;
  nazwa: string;
  poziomZagrożenia: 1 | 2 | 3 | 4 | 5;
  proceduraEwakuacji: string;
}

// Późniejsze rozszerzenie tego samego interfejsu o dodatkowe informacje
interface ProtokółBezpieczeństwa {
  personelOdpowiedzialny: string[];
  czasReakcji: number; // w minutach
}

// Jeszcze późniejsze rozszerzenie o procedury komunikacji
interface ProtokółBezpieczeństwa {
  kanałyKomunikacji: string[];
  wiadomośćAlarmowa: string;
}

// Teraz ProtokółBezpieczeństwa ma wszystkie pola ze wszystkich trzech deklaracji
const protokółAlfa: ProtokółBezpieczeństwa = {
  id: "PROTO-ALFA",
  nazwa: "Protokół Alfa - Ucieczka drapieżnika",
  poziomZagrożenia: 5,
  proceduraEwakuacji: "Natychmiastowa ewakuacja wszystkich obszarów publicznych do bunkrów bezpieczeństwa",
  personelOdpowiedzialny: ["Kierownik bezpieczeństwa", "Kierownik parku", "Główny treser"],
  czasReakcji: 5,
  kanałyKomunikacji: ["Radio", "System PA", "Alarm dźwiękowy", "Powiadomienia SMS"],
  wiadomośćAlarmowa: "UWAGA! PROTOKÓŁ ALFA! To nie jest ćwiczenie. Proszę natychmiast udać się do najbliższego schronu."
};

// Funkcja do wyświetlania protokołu
function wyświetlProtokół(protokół: ProtokółBezpieczeństwa): void {
  console.log(`=== ${protokół.nazwa.toUpperCase()} ===`);
  console.log(`ID: ${protokół.id}`);
  console.log(`Poziom zagrożenia: ${protokół.poziomZagrożenia}`);
  console.log(`Czas reakcji: ${protokół.czasReakcji} minut`);
  console.log(`\nProcedura ewakuacji:\n${protokół.proceduraEwakuacji}`);
  console.log(`\nPersonel odpowiedzialny:`);
  protokół.personelOdpowiedzialny.forEach(osoba => console.log(`- ${osoba}`));
  console.log(`\nKanały komunikacji: ${protokół.kanałyKomunikacji.join(", ")}`);
  console.log(`\nWiadomość alarmowa: "${protokół.wiadomośćAlarmowa}"`);
}

wyświetlProtokół(protokółAlfa);

Kompatybilność strukturalna interfejsów

TypeScript używa kompatybilności strukturalnej, co oznacza, że typy są kompatybilne, jeśli mają tę samą strukturę, niezależnie od ich nazw. To jak w Parku Jurajskim - jeśli dinozaur zachowuje się jak T-Rex i wygląda jak T-Rex, to z perspektywy systemu bezpieczeństwa powinien być traktowany jak T-Rex:

// Definicja interfejsu dinozaura drapieżnego
interface DrapieżnyDinozaur {
  id: string;
  nazwa: string;
  siłaUgryzienia: number;
  prędkośćBiegu: number;
  poziomAgresji: number;
}

// Całkowicie osobna definicja, bez żadnego formalnego związku z powyższym interfejsem
interface NiebezpiecznyStwór {
  id: string;
  nazwa: string;
  siłaUgryzienia: number;
  prędkośćBiegu: number;
  poziomAgresji: number;
  // Dodatkowe pole, które nie przeszkadza w kompatybilności
  pochodzenie?: string;
}

function ocenZagrożenie(dino: DrapieżnyDinozaur): number {
  return (dino.siłaUgryzienia / 1000) + (dino.prędkośćBiegu / 10) + dino.poziomAgresji;
}

// Tworzymy obiekt zgodny z NiebezpiecznyStwór
const indominus: NiebezpiecznyStwór = {
  id: "IND-01",
  nazwa: "Indominus Rex",
  siłaUgryzienia: 15000,
  prędkośćBiegu: 48,
  poziomAgresji: 10,
  pochodzenie: "Laboratorium"
};

// Mimo że indominus jest typu NiebezpiecznyStwór, można go użyć tam,
// gdzie oczekiwany jest DrapieżnyDinozaur, dzięki kompatybilności strukturalnej
const poziomZagrożenia = ocenZagrożenie(indominus);
console.log(`Poziom zagrożenia dla ${indominus.nazwa}: ${poziomZagrożenia}`);

// Funkcja oczekująca obiektu zgodnego z NiebezpiecznyStwór
function opisZagrożenie(stwór: NiebezpiecznyStwór): string {
  let opis = `${stwór.nazwa} to niezwykle niebezpieczne stworzenie.\n`;
  opis += `Siła ugryzienia: ${stwór.siłaUgryzienia} PSI\n`;
  opis += `Prędkość biegu: ${stwór.prędkośćBiegu} km/h\n`;
  opis += `Poziom agresji: ${stwór.poziomAgresji}/10\n`;

  if (stwór.pochodzenie) {
    opis += `Stworzony w: ${stwór.pochodzenie}`;
  }

  return opis;
}

// Tworzymy obiekt zgodny z DrapieżnyDinozaur
const velociraptor: DrapieżnyDinozaur = {
  id: "VEL-01",
  nazwa: "Blue",
  siłaUgryzienia: 4000,
  prędkośćBiegu: 65,
  poziomAgresji: 7
};

// Możemy użyć obiektu typu DrapieżnyDinozaur w funkcji oczekującej NiebezpiecznyStwór
// Działa, ponieważ velociraptor ma wszystkie wymagane właściwości
const opisRaptora = opisZagrożenie(velociraptor);
console.log(opisRaptora);

Interfejsy vs. typy abstrakcyjne

Porównajmy interfejsy z typami abstrakcyjnymi (abstract classes) w kontekście Parku Jurajskiego:

// Interfejs dla systemów bezpieczeństwa
interface SystemBezpieczeństwaInterface {
  nazwa: string;
  aktywuj(): void;
  dezaktywuj(): void;
  testuj(): boolean;
}

// Abstrakcyjna klasa dla systemów bezpieczeństwa
abstract class SystemBezpieczeństwaAbstractClass {
  constructor(public nazwa: string, protected poziomBezpieczeństwa: number) {}

  abstract aktywuj(): void;
  abstract dezaktywuj(): void;

  // Wspólna implementacja dla wszystkich klas pochodnych
  testuj(): boolean {
    console.log(`Testowanie systemu ${this.nazwa}...`);
    return Math.random() > 0.1; // 90% szans na sukces testu
  }

  // Metoda dostępna dla wszystkich klas pochodnych
  pobierzPoziom(): number {
    return this.poziomBezpieczeństwa;
  }
}

// Implementacja interfejsu
class SkaneryRuchu implements SystemBezpieczeństwaInterface {
  constructor(public nazwa: string) {}

  aktywuj(): void {
    console.log(`Skanery ruchu ${this.nazwa} zostały aktywowane`);
  }

  dezaktywuj(): void {
    console.log(`Skanery ruchu ${this.nazwa} zostały dezaktywowane`);
  }

  testuj(): boolean {
    console.log(`Testowanie skanerów ruchu ${this.nazwa}...`);
    return true;
  }
}

// Rozszerzenie klasy abstrakcyjnej
class ElektroniczneOgrodzenie extends SystemBezpieczeństwaAbstractClass {
  private napięcie: number;

  constructor(nazwa: string, poziomBezpieczeństwa: number, napięcie: number) {
    super(nazwa, poziomBezpieczeństwa);
    this.napięcie = napięcie;
  }

  aktywuj(): void {
    console.log(`Ogrodzenie elektryczne ${this.nazwa} aktywowane z napięciem ${this.napięcie}V`);
  }

  dezaktywuj(): void {
    console.log(`Ogrodzenie elektryczne ${this.nazwa} dezaktywowane`);
  }

  zwiększNapięcie(o: number): void {
    this.napięcie += o;
    console.log(`Zwiększono napięcie ogrodzenia ${this.nazwa} do ${this.napięcie}V`);
  }
}

// Użycie obu podejść
const skanery = new SkaneryRuchu("Strefa T-Rex");
skanery.aktywuj();
skanery.testuj();

const ogrodzenie = new ElektroniczneOgrodzenie("Padok wschodni", 4, 10000);
ogrodzenie.aktywuj();
ogrodzenie.zwiększNapięcie(2000);
console.log(`Poziom bezpieczeństwa ogrodzenia: ${ogrodzenie.pobierzPoziom()}`);

Główne różnice:

CechaInterfejsKlasa abstrakcyjna
ImplementacjaTylko definicja, bez implementacjiMoże zawierać implementację metod
DziedziczenieKlasa może implementować wiele interfejsówKlasa może dziedziczyć tylko z jednej klasy abstrakcyjnej
KonstruktorNie ma konstruktoraMoże mieć konstruktor
Kod w runtimeInterfejsy nie generują kodu JavaScriptKlasy abstrakcyjne generują kod JavaScript
Modyfikatory dostępuNie można używać modyfikatorów (private, protected)Można używać modyfikatorów dostępu
UżycieDefinicja kontraktuDefinicja bazowej funkcjonalności z częściową implementacją

Praktyczne zastosowanie rozszerzania interfejsów

Zobaczmy teraz kompleksowy przykład ilustrujący, jak rozszerzanie interfejsów może być wykorzystane w systemie zarządzania Parkiem Jurajskim:

// Bazowy interfejs dla wszystkich bytów w parku
interface BazaParkuJurajskiego {
  id: string;
  nazwa: string;
  dataDodania: Date;
  ostatniaAktualizacja: Date;
}

// Rozszerzenie dla żywych stworzeń
interface ŻyweStworzeniaParku extends BazaParkuJurajskiego {
  wiek: number;
  płeć: "samiec" | "samica";
  statusZdrowia: "doskonały" | "dobry" | "wymaga uwagi" | "chory" | "krytyczny";
  historiaZdrowia: {
    data: Date;
    opis: string;
    procedura?: string;
  }[];
}

// Rozszerzenie dla dinozaurów
interface DinozaurParku extends ŻyweStworzeniaParku {
  gatunek: string;
  eraPochodzenia: string;
  dieta: "roślinożerca" | "mięsożerca" | "wszystkożerca";
  poziomNiebezpieczeństwa: 1 | 2 | 3 | 4 | 5;
  lokalizacja: string; // ID wybiegu
  cechy: {
    wysokość: number;
    długość: number;
    waga: number;
    prędkośćMaksymalna: number;
    siłaUgryzienia?: number; // Tylko dla drapieżników
  };
}

// Rozszerzenie dla pracowników
interface PracownikParku extends ŻyweStworzeniaParku {
  imię: string;
  nazwisko: string;
  stanowisko: string;
  poziomDostępu: 1 | 2 | 3 | 4 | 5;
  działy: string[];
  adres: {
    ulica: string;
    miasto: string;
    kodPocztowy: string;
    kraj: string;
  };
  kontakt: {
    telefon: string;
    email: string;
  };
}

// Interfejs dla lokalizacji w parku
interface LokalizacjaParku extends BazaParkuJurajskiego {
  typ: "wybieg" | "budynek" | "atrakcja" | "laboratorium" | "strefa publiczna";
  współrzędne: {
    szerokość: number;
    długość: number;
  };
  powierzchnia: number; // w metrach kwadratowych
  pojemność: number;
  poziomDostępu: 1 | 2 | 3 | 4 | 5;
  systemyBezpieczeństwa: string[]; // Lista ID systemów bezpieczeństwa
  status: "aktywny" | "nieaktywny" | "w konserwacji" | "w budowie";
}

// Interfejs dla wybiegu dinozaurów
interface WybiegDinozaurów extends LokalizacjaParku {
  mieszkańcy: string[]; // Lista ID dinozaurów
  typŚrodowiska: "las" | "sawanna" | "bagno" | "góry" | "wybrzeże" | "akwen";
  specjalneWymagania?: string[];
  cechy: {
    wysokośćOgrodzenia: number;
    napięcieOgrodzenia?: number; // Dla drapieżników
    liczbaSkanerów: number;
    liczbaKamer: number;
  };
}

// Interfejs dla laboratoriów
interface LaboratoriumParku extends LokalizacjaParku {
  specjalizacja: "genetyka" | "behawioralna" | "weterynaria" | "mikrobiologia";
  wyposażenie: string[];
  personel: string[]; // Lista ID pracowników
  projektyBadawcze: {
    id: string;
    nazwa: string;
    start: Date;
    koniec?: Date;
    status: "planowany" | "w trakcie" | "zakończony" | "wstrzymany";
  }[];
}

// System zarządzania parkiem
class ParkJurajskiSystem {
  private dinozaury: Map<string, DinozaurParku> = new Map();
  private pracownicy: Map<string, PracownikParku> = new Map();
  private lokalizacje: Map<string, LokalizacjaParku> = new Map();
  private laboratorium: Map<string, LaboratoriumParku> = new Map();
  private wybiegi: Map<string, WybiegDinozaurów> = new Map();

  // Metody dla dinozaurów
  dodajDinozaura(dino: DinozaurParku): void {
    this.dinozaury.set(dino.id, dino);
    console.log(`Dodano dinozaura: ${dino.nazwa} (${dino.gatunek})`);

    // Aktualizacja wybiegu
    if (dino.lokalizacja && this.wybiegi.has(dino.lokalizacja)) {
      const wybieg = this.wybiegi.get(dino.lokalizacja)!;
      wybieg.mieszkańcy.push(dino.id);
      this.wybiegi.set(wybieg.id, wybieg);
    }
  }

  aktualizujStatusZdrowiaDinozaura(id: string, nowyStatus: DinozaurParku["statusZdrowia"], opis: string): void {
    if (!this.dinozaury.has(id)) {
      console.error(`Dinozaur o ID ${id} nie istnieje`);
      return;
    }

    const dino = this.dinozaury.get(id)!;
    const staryStatus = dino.statusZdrowia;
    dino.statusZdrowia = nowyStatus;
    dino.ostatniaAktualizacja = new Date();

    // Dodanie wpisu do historii zdrowia
    dino.historiaZdrowia.push({
      data: new Date(),
      opis: `Zmiana statusu zdrowia z "${staryStatus}" na "${nowyStatus}". ${opis}`
    });

    this.dinozaury.set(id, dino);
    console.log(`Zaktualizowano status zdrowia dinozaura ${dino.nazwa} na: ${nowyStatus}`);
  }

  // Metody dla pracowników
  dodajPracownika(pracownik: PracownikParku): void {
    this.pracownicy.set(pracownik.id, pracownik);
    console.log(`Dodano pracownika: ${pracownik.imię} ${pracownik.nazwisko} (${pracownik.stanowisko})`);
  }

  // Metody dla lokalizacji
  dodajWybieg(wybieg: WybiegDinozaurów): void {
    this.wybiegi.set(wybieg.id, wybieg);
    this.lokalizacje.set(wybieg.id, wybieg); // Wybieg jest również lokalizacją
    console.log(`Dodano wybieg: ${wybieg.nazwa}`);
  }

  dodajLaboratorium(lab: LaboratoriumParku): void {
    this.laboratorium.set(lab.id, lab);
    this.lokalizacje.set(lab.id, lab); // Laboratorium jest również lokalizacją
    console.log(`Dodano laboratorium: ${lab.nazwa} (${lab.specjalizacja})`);
  }

  // Metody raportowania
  generujRaportParkuJurajskiego(): string {
    const raport = [];
    raport.push("=== RAPORT STANU PARKU JURAJSKIEGO ===");
    raport.push(`Data raportu: ${new Date().toLocaleString()}`);
    raport.push(`\nStatystyki ogólne:`);
    raport.push(`- Liczba dinozaurów: ${this.dinozaury.size}`);
    raport.push(`- Liczba pracowników: ${this.pracownicy.size}`);
    raport.push(`- Liczba lokalizacji: ${this.lokalizacje.size}`);
    raport.push(`  - Wybiegi: ${this.wybiegi.size}`);
    raport.push(`  - Laboratoria: ${this.laboratorium.size}`);

    // Statystyki dinozaurów
    const statystykiZdrowia = {
      "doskonały": 0,
      "dobry": 0,
      "wymaga uwagi": 0,
      "chory": 0,
      "krytyczny": 0
    };

    let liczbaDrapieżników = 0;

    for (const dino of this.dinozaury.values()) {
      statystykiZdrowia[dino.statusZdrowia]++;
      if (dino.dieta === "mięsożerca") {
        liczbaDrapieżników++;
      }
    }

    raport.push(`\nStatystyki zdrowia dinozaurów:`);
    for (const [status, liczba] of Object.entries(statystykiZdrowia)) {
      raport.push(`- ${status}: ${liczba}`);
    }

    raport.push(`Drapieżniki: ${liczbaDrapieżników}`);
    raport.push(`Roślinożercy: ${this.dinozaury.size - liczbaDrapieżników}`);

    // Statystyki wybiegów
    const wybiegiZeStatusem = {
      "aktywny": 0,
      "nieaktywny": 0,
      "w konserwacji": 0,
      "w budowie": 0
    };

    for (const wybieg of this.wybiegi.values()) {
      wybiegiZeStatusem[wybieg.status]++;
    }

    raport.push(`\nStatystyki wybiegów:`);
    for (const [status, liczba] of Object.entries(wybiegiZeStatusem)) {
      raport.push(`- ${status}: ${liczba}`);
    }

    return raport.join("\n");
  }
}

// Przykład użycia
const park = new ParkJurajskiSystem();

// Dodanie wybiegu
park.dodajWybieg({
  id: "WYB-001",
  nazwa: "Padok T-Rex",
  dataDodania: new Date(2020, 0, 15),
  ostatniaAktualizacja: new Date(),
  typ: "wybieg",
  współrzędne: {
    szerokość: 20.123,
    długość: -75.456
  },
  powierzchnia: 50000, // 5 hektarów
  pojemność: 2,
  poziomDostępu: 5,
  systemyBezpieczeństwa: ["SEC-001", "SEC-002", "SEC-003"],
  status: "aktywny",
  mieszkańcy: [],
  typŚrodowiska: "las",
  cechy: {
    wysokośćOgrodzenia: 8,
    napięcieOgrodzenia: 10000,
    liczbaSkanerów: 24,
    liczbaKamer: 36
  }
});

// Dodanie laboratorium
park.dodajLaboratorium({
  id: "LAB-001",
  nazwa: "Laboratorium Genetyczne im. Dr. Wu",
  dataDodania: new Date(2018, 5, 10),
  ostatniaAktualizacja: new Date(),
  typ: "laboratorium",
  współrzędne: {
    szerokość: 20.124,
    długość: -75.458
  },
  powierzchnia: 2000,
  pojemność: 30,
  poziomDostępu: 4,
  systemyBezpieczeństwa: ["SEC-101", "SEC-102"],
  status: "aktywny",
  specjalizacja: "genetyka",
  wyposażenie: ["Sekwencer DNA", "Izolatory próbek", "Komora kriogeniczna"],
  personel: [],
  projektyBadawcze: [
    {
      id: "PROJ-001",
      nazwa: "Wzmacnianie genów odporności u Triceratopsów",
      start: new Date(2022, 3, 15),
      status: "w trakcie"
    }
  ]
});

// Dodanie dinozaura
park.dodajDinozaura({
  id: "DINO-001",
  nazwa: "Rexy",
  dataDodania: new Date(2020, 5, 20),
  ostatniaAktualizacja: new Date(),
  wiek: 7,
  płeć: "samica",
  statusZdrowia: "dobry",
  historiaZdrowia: [
    {
      data: new Date(2020, 5, 20),
      opis: "Badanie początkowe. Wszystkie parametry w normie."
    },
    {
      data: new Date(2021, 2, 15),
      opis: "Rutynowe badanie. Niewielkie podniesienie poziomu trójglicerydów.",
      procedura: "Zmiana diety na bogatszą w kwasy Omega-3"
    }
  ],
  gatunek: "Tyrannosaurus Rex",
  eraPochodzenia: "Kreda późna",
  dieta: "mięsożerca",
  poziomNiebezpieczeństwa: 5,
  lokalizacja: "WYB-001",
  cechy: {
    wysokość: 4.5,
    długość: 12,
    waga: 7200,
    prędkośćMaksymalna: 32,
    siłaUgryzienia: 12800
  }
});

// Dodanie pracownika
park.dodajPracownika({
  id: "EMP-001",
  nazwa: "Pracownik",
  dataDodania: new Date(2019, 1, 10),
  ostatniaAktualizacja: new Date(),
  wiek: 42,
  płeć: "mężczyzna",
  statusZdrowia: "doskonały",
  historiaZdrowia: [
    {
      data: new Date(2022, 1, 5),
      opis: "Rutynowe badanie okresowe. Wszystkie parametry w normie."
    }
  ],
  imię: "Owen",
  nazwisko: "Grady",
  stanowisko: "Treser Raptorów",
  poziomDostępu: 4,
  działy: ["Badania Behawioralne", "Opieka nad Zwierzętami"],
  adres: {
    ulica: "Bungalow 12",
    miasto: "Isla Nublar",
    kodPocztowy: "00000",
    kraj: "Kostaryka"
  },
  kontakt: {
    telefon: "+1-555-123-4567",
    email: "owen.grady@jurassicworld.com"
  }
});

// Aktualizacja statusu zdrowia dinozaura
park.aktualizujStatusZdrowiaDinozaura(
  "DINO-001",
  "wymaga uwagi",
  "Zauważono zmniejszony apetyt i lekką gorączkę."
);

// Generowanie raportu
console.log(park.generujRaportParkuJurajskiego());

Podsumowanie

Rozszerzanie interfejsów w TypeScript to potężna technika, która pozwala na modelowanie złożonych hierarchii typów i relacji między nimi. W kontekście Parku Jurajskiego, umożliwia nam to precyzyjne modelowanie różnorodnych bytów i systemów, od dinozaurów, przez pracowników, aż po zaawansowane systemy monitoringu i bezpieczeństwa.

TechnikaZastosowanie w Parku Jurajskim
Podstawowe rozszerzanie interfejsówHierarchia stworzeń od bazowych do specyficznych gatunków
Rozszerzanie wielu interfejsówTworzenie hybrydowych typów, jak morskie drapieżniki
Generyczne rozszerzenia interfejsówSystemy monitoringu różnych typów danych
Łączenie deklaracji interfejsówAktualizowanie protokołów bezpieczeństwa
Kompatybilność strukturalnaJednolite traktowanie różnych typów dinozaurów przez systemy bezpieczeństwa

Dr. Wu podsumowuje: "Rozszerzanie interfejsów w TypeScript przypomina naszą pracę nad nowymi gatunkami dinozaurów. Zaczynamy od podstawowej struktury i rozszerzamy ją o nowe cechy i funkcjonalności, tworząc coraz bardziej wyspecjalizowane i złożone byty. Ta elastyczność i możliwość ponownego wykorzystania istniejących definicji sprawia, że możemy tworzyć spójne, ale jednocześnie wysoce zróżnicowane systemy - kluczowe zarówno w genetyce jak i w programowaniu."

Kod do tej lekcji: index.ts
// Rozszerzanie interfejsów w Parku Jurajskim
console.log("Rozszerzanie interfejsów TypeScript\n");

// ===========================================
// 1. Podstawowe rozszerzanie
// ===========================================
console.log("=== PODSTAWOWE ROZSZERZANIE ===");

// Bazowy interfejs
interface Animal {
  name: string;
  age: number;
  weight: number;
}

// Rozszerzenie interfejsu
interface Dinosaur extends Animal {
  species: string;
  period: "Triassic" | "Jurassic" | "Cretaceous";
  diet: "carnivore" | "herbivore" | "omnivore";
}

const trex: Dinosaur = {
  name: "Rexy",
  age: 5,
  weight: 8000,
  species: "Tyrannosaurus Rex",
  period: "Cretaceous",
  diet: "carnivore"
};

console.log("T-Rex:", trex);

// ===========================================
// 2. Wielokrotne rozszerzanie
// ===========================================
console.log("\n=== WIELOKROTNE ROZSZERZANIE ===");

interface HasName {
  name: string;
}

interface HasWeight {
  weight: number;
}

interface HasDiet {
  diet: "carnivore" | "herbivore" | "omnivore";
}

// Rozszerzenie wielu interfejsów
interface CompleteDinosaur extends HasName, HasWeight, HasDiet {
  species: string;
  dangerLevel: number;
}

const velociraptor: CompleteDinosaur = {
  name: "Blue",
  weight: 350,
  diet: "carnivore",
  species: "Velociraptor",
  dangerLevel: 8
};

console.log("Velociraptor:", velociraptor);

// ===========================================
// 3. Nadpisywanie właściwości
// ===========================================
console.log("\n=== NADPISYWANIE WŁAŚCIWOŚCI ===");

interface BasicDinosaur {
  id: string | number;
  name: string;
}

// Zawężenie typu przy rozszerzaniu
interface SpecificDinosaur extends BasicDinosaur {
  id: string; // zawęzi type z string | number do string
  trackingCode: string;
}

const trackedDino: SpecificDinosaur = {
  id: "DINO-001", // musi być string
  name: "Rex",
  trackingCode: "TR-XYZ-123"
};

console.log("Tracked dinosaur:", trackedDino);

// ===========================================
// 4. Rozszerzanie z dodatkowymi metodami
// ===========================================
console.log("\n=== ROZSZERZANIE Z METODAMI ===");

interface LivingBeing {
  name: string;
  eat(amount: number): void;
  sleep(hours: number): void;
}

interface Predator extends LivingBeing {
  hunt(prey: string): string;
  roar(): string;
  attackPower: number;
}

class TyrannosaurusRex implements Predator {
  name: string;
  attackPower: number;
  energy: number = 100;

  constructor(name: string) {
    this.name = name;
    this.attackPower = 95;
  }

  eat(amount: number): void {
    this.energy += amount * 2;
    if (this.energy > 100) this.energy = 100;
    console.log(`${this.name} ate ${amount}kg. Energy: ${this.energy}`);
  }

  sleep(hours: number): void {
    this.energy += hours * 10;
    if (this.energy > 100) this.energy = 100;
    console.log(`${this.name} slept ${hours}h. Energy: ${this.energy}`);
  }

  hunt(prey: string): string {
    this.energy -= 20;
    return `${this.name} hunts ${prey}! Energy: ${this.energy}`;
  }

  roar(): string {
    this.energy -= 5;
    return `${this.name} roars: ROAAAAAR! (${this.attackPower} power)`;
  }
}

const rexy = new TyrannosaurusRex("Rexy");
console.log(rexy.roar());
console.log(rexy.hunt("Triceratops"));
rexy.eat(50);

// ===========================================
// 5. Łańcuchowe rozszerzanie
// ===========================================
console.log("\n=== ŁAŃCUCHOWE ROZSZERZANIE ===");

interface Entity {
  id: string;
}

interface LivingEntity extends Entity {
  isAlive: boolean;
}

interface BreathingEntity extends LivingEntity {
  oxygenLevel: number;
}

interface IntelligentEntity extends BreathingEntity {
  intelligenceLevel: number;
  canCommunicate: boolean;
}

const velociRaptor: IntelligentEntity = {
  id: "VR-001",
  isAlive: true,
  oxygenLevel: 98,
  intelligenceLevel: 85,
  canCommunicate: true
};

console.log("Intelligent entity:", velociRaptor);

// ===========================================
// 6. Generics z rozszerzaniem
// ===========================================
console.log("\n=== GENERICS Z ROZSZERZANIEM ===");

interface Trackable {
  trackingId: string;
  lastSeen: Date;
}

interface DataEntry extends Trackable {
  data: any;
}

interface DinosaurEntry<T> extends DataEntry {
  dinosaurData: T;
}

interface TRexData {
  species: "Tyrannosaurus Rex";
  teethCount: number;
  biteForce: number;
}

const trexEntry: DinosaurEntry<TRexData> = {
  trackingId: "TRK-001",
  lastSeen: new Date(),
  data: { notes: "Healthy specimen" },
  dinosaurData: {
    species: "Tyrannosaurus Rex",
    teethCount: 60,
    biteForce: 12800
  }
};

console.log("T-Rex entry:", trexEntry);

// ===========================================
// 7. Rozszerzanie z Index Signatures
// ===========================================
console.log("\n=== INDEX SIGNATURES ===");

interface BaseConfig {
  version: string;
  enabled: boolean;
}

interface ExtendedConfig extends BaseConfig {
  [key: string]: any; // dodatkowe dynamiczne właściwości
}

const parkConfig: ExtendedConfig = {
  version: "2.0",
  enabled: true,
  maxCapacity: 10000,
  securityLevel: "high",
  maintenanceMode: false
};

console.log("Park config:", parkConfig);

// ===========================================
// 8. Rozszerzanie vs Intersection
// ===========================================
console.log("\n=== EXTENDS VS INTERSECTION ===");

// Extends (interfejsy)
interface A {
  a: string;
}

interface B extends A {
  b: number;
}

const objB: B = {
  a: "value",
  b: 123
};

// Intersection (typy)
type C = {
  c: boolean;
};

type D = C & {
  d: string[];
};

const objD: D = {
  c: true,
  d: ["item1", "item2"]
};

console.log("Interface extension:", objB);
console.log("Type intersection:", objD);

// ===========================================
// 9. Praktyczny przykład - System Parku
// ===========================================
console.log("\n=== SYSTEM PARKU ===");

interface Identifiable {
  id: string;
}

interface Timestamped {
  createdAt: Date;
  updatedAt: Date;
}

interface Locatable {
  latitude: number;
  longitude: number;
}

interface ParkEntity extends Identifiable, Timestamped, Locatable {
  name: string;
  status: "active" | "inactive" | "maintenance";
}

interface Paddock extends ParkEntity {
  capacity: number;
  currentOccupancy: number;
  securityLevel: "low" | "medium" | "high" | "critical";
}

interface DinosaurPark extends ParkEntity {
  paddocks: Paddock[];
  totalDinosaurs: number;
  isOpen: boolean;
}

const jurassicPark: DinosaurPark = {
  id: "PARK-001",
  createdAt: new Date("1993-06-11"),
  updatedAt: new Date(),
  latitude: 22.3964,
  longitude: -159.5261,
  name: "Jurassic Park",
  status: "active",
  paddocks: [],
  totalDinosaurs: 0,
  isOpen: false
};

console.log("Jurassic Park:", jurassicPark);

// ===========================================
// 10. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("extends - rozszerzanie interfejsów");
console.log("Wielokrotne rozszerzanie - dziedziczenie wielu interfejsów");
console.log("Nadpisywanie - zawężanie typów");
console.log("Metody - dodawanie funkcjonalności");
console.log("Łańcuchowe - budowanie hierarchii");
console.log("Generics - parametryczne rozszerzanie");

console.log("\nRozszerzanie interfejsów opanowane!");

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 dzieje się, gdy interfejs B extends interfejs A?

  2. 2. Czy interfejs w TypeScript może rozszerzać wiele interfejsów jednocześnie?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz interfejs bazowy Animal i rozszerz go do Dinosaur z dodatkowymi polami era i diet.

  • Układanie w poziomie

    Ułóż elementy rozszerzania interfejsu w TypeScript:

  1. PytanieRozszerzanie interfejsów
  2. PytanieRozszerzanie wielu interfejsów
  3. Zadanie z kodemPraktyka: Interfejs z extends
  4. Ułóż w kolejnościSkładnia extends interfejsu

Przydatne artykuły