Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Implementacja interfejsów
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:
- Zdefiniowaliśmy interfejs
PracownikParkuokreślający, jakie właściwości i metody musi mieć każdy pracownik - Utworzyliśmy dwie różne klasy implementujące ten interfejs - każda na swój sposób
- Obie klasy muszą dostarczyć wszystkie wymagane właściwości i metody, ale mogą implementować je różnie
- 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:
- Zdefiniowaliśmy właściwość
readonly, której nie można modyfikować po inicjalizacji - Dodaliśmy opcjonalną właściwość
opcjeZaawansowane(oznaczoną przez?) - 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:
Zwierzę- podstawowy interfejs dla wszystkich zwierzątDinozaur- rozszerzaZwierzęo właściwości specyficzne dla dinozaurówDrapieżnyDinozaur- rozszerzaDinozauro 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:
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; // };Łączenie:
- Interfejsy używają
extends - Typy używają operatora przecięcia
&
- Interfejsy używają
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łaniaJak 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:
- Definiują kształt obiektów - określają, jakie właściwości i metody muszą posiadać obiekty danego typu
- Wsparcie dla polimorfizmu - różne klasy mogą implementować ten sam interfejs na różne sposoby
- Luźne powiązanie - skupiają się na tym, co obiekty robią, a nie jak są zaimplementowane
- Elastyczność - właściwości opcjonalne, tylko do odczytu, indeksy, itp.
- 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. Co robi słowo kluczowe implements w TypeScript?
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: