Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Rozszerzanie interfejsów
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:
| Cecha | Interfejs | Klasa abstrakcyjna |
|---|---|---|
| Implementacja | Tylko definicja, bez implementacji | Może zawierać implementację metod |
| Dziedziczenie | Klasa może implementować wiele interfejsów | Klasa może dziedziczyć tylko z jednej klasy abstrakcyjnej |
| Konstruktor | Nie ma konstruktora | Może mieć konstruktor |
| Kod w runtime | Interfejsy nie generują kodu JavaScript | Klasy abstrakcyjne generują kod JavaScript |
| Modyfikatory dostępu | Nie można używać modyfikatorów (private, protected) | Można używać modyfikatorów dostępu |
| Użycie | Definicja kontraktu | Definicja 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.
| Technika | Zastosowanie w Parku Jurajskim |
|---|---|
| Podstawowe rozszerzanie interfejsów | Hierarchia stworzeń od bazowych do specyficznych gatunków |
| Rozszerzanie wielu interfejsów | Tworzenie hybrydowych typów, jak morskie drapieżniki |
| Generyczne rozszerzenia interfejsów | Systemy monitoringu różnych typów danych |
| Łączenie deklaracji interfejsów | Aktualizowanie protokołów bezpieczeństwa |
| Kompatybilność strukturalna | Jednolite 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. Co dzieje się, gdy interfejs B extends interfejs A?
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: