Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Właściwości statyczne i abstrakcyjne
W tej lekcji4
"W Parku Jurajskim mamy protokoły i standardy, które obowiązują wszystkie obiekty danej klasy," wyjaśnia Dr. Henry Wu, główny genetyk parku. "Na przykład, wszystkie nasze wybiegi dla dinozaurów mają tę samą procedurę bezpieczeństwa, niezależnie od tego, który konkretny wybieg rozpatrujemy. Z drugiej strony, każdy gatunek dinozaura ma swój własny, unikalny wzór DNA, ale wszyscy wiemy, że DNA musi istnieć - nawet jeśli szczegóły różnią się między gatunkami."
W programowaniu obiektowym TypeScript oferuje dwie potężne koncepcje, które odzwierciedlają te idee:
- Właściwości i metody statyczne - współdzielone przez wszystkie instancje klasy
- Właściwości i metody abstrakcyjne - muszą być zaimplementowane przez klasy dziedziczące
W tym ćwiczeniu zagłębimy się w te koncepcje, tworząc zaawansowany system zarządzania genetyką i protokołami bezpieczeństwa Parku Jurajskiego.
Właściwości i metody statyczne
Elementy statyczne w klasie należą do samej klasy, a nie do jej instancji. Oznacza to, że:
- Istnieje tylko jedna kopia każdej właściwości statycznej, niezależnie od liczby utworzonych instancji
- Dostęp do właściwości statycznych uzyskuje się poprzez nazwę klasy, a nie przez instancję
- Metody statyczne mogą być wywoływane bezpośrednio na klasie
Podstawowe użycie elementów statycznych
Przyjrzyjmy się, jak można wykorzystać elementy statyczne w kontekście Parku Jurajskiego:
class ProtokółBezpieczeństwa {
// Właściwość statyczna - współdzielona przez wszystkie instancje
static readonly POZIOM_KRYTYCZNY: number = 5;
static readonly POZIOM_WYSOKI: number = 4;
static readonly POZIOM_ŚREDNI: number = 3;
static readonly POZIOM_NISKI: number = 2;
static readonly POZIOM_MINIMALNY: number = 1;
// Statyczna właściwość przechowująca aktualny globalny poziom zagrożenia parku
private static _aktualnyPoziomZagrożenia: number = ProtokółBezpieczeństwa.POZIOM_NISKI;
// Właściwości instancji
private readonly obszar: string;
private lokalnyPoziomZagrożenia: number;
constructor(obszar: string) {
this.obszar = obszar;
this.lokalnyPoziomZagrożenia = ProtokółBezpieczeństwa._aktualnyPoziomZagrożenia;
console.log(`Utworzono protokół bezpieczeństwa dla obszaru: ${obszar}`);
}
// Metoda statyczna dostępna bezpośrednio na klasie
static podnieśGlobalnyPoziomZagrożenia(): void {
if (this._aktualnyPoziomZagrożenia < this.POZIOM_KRYTYCZNY) {
this._aktualnyPoziomZagrożenia++;
console.log(`UWAGA: Podniesiono globalny poziom zagrożenia do ${this._aktualnyPoziomZagrożenia}`);
// Wywołanie innej metody statycznej
this.powiadomOpoziomieZagrożenia();
} else {
console.log("UWAGA: Osiągnięto już maksymalny poziom zagrożenia!");
}
}
// Inna metoda statyczna
static obniżGlobalnyPoziomZagrożenia(): void {
if (this._aktualnyPoziomZagrożenia > this.POZIOM_MINIMALNY) {
this._aktualnyPoziomZagrożenia--;
console.log(`Obniżono globalny poziom zagrożenia do ${this._aktualnyPoziomZagrożenia}`);
} else {
console.log("Poziom zagrożenia jest już minimalny.");
}
}
// Statyczny getter
static get aktualnyPoziomZagrożenia(): number {
return this._aktualnyPoziomZagrożenia;
}
// Prywatna metoda statyczna
private static powiadomOpoziomieZagrożenia(): void {
console.log(`Powiadomienie: Aktualny poziom zagrożenia parku: ${this._aktualnyPoziomZagrożenia}`);
}
// Metoda instancji korzystająca z właściwości statycznych
aktualizujLokalnyPoziomZagrożenia(): void {
// Aktualizacja lokalnego poziomu na podstawie globalnego
this.lokalnyPoziomZagrożenia = ProtokółBezpieczeństwa._aktualnyPoziomZagrożenia;
console.log(`Obszar ${this.obszar}: zaktualizowano poziom zagrożenia do ${this.lokalnyPoziomZagrożenia}`);
}
get statusBezpieczeństwa(): string {
const poziomy = [
"NIEZNANY",
"MINIMALNY",
"NISKI",
"ŚREDNI",
"WYSOKI",
"KRYTYCZNY"
];
return `Obszar: ${this.obszar}, Poziom zagrożenia: ${poziomy[this.lokalnyPoziomZagrożenia]}`;
}
}
// Użycie właściwości i metod statycznych - bez tworzenia instancji!
console.log("Domyślny poziom zagrożenia:", ProtokółBezpieczeństwa.aktualnyPoziomZagrożenia);
// Wywołanie metody statycznej bezpośrednio na klasie
ProtokółBezpieczeństwa.podnieśGlobalnyPoziomZagrożenia();
ProtokółBezpieczeństwa.podnieśGlobalnyPoziomZagrożenia();
// Tworzenie instancji klasy
const protokółCentralny = new ProtokółBezpieczeństwa("Centrum Operacyjne");
const protokółWybieg = new ProtokółBezpieczeństwa("Wybieg T-Rex");
// Wyświetlenie statusu bezpieczeństwa
console.log(protokółCentralny.statusBezpieczeństwa);
console.log(protokółWybieg.statusBezpieczeństwa);
// Ponowne podniesienie globalnego poziomu zagrożenia
ProtokółBezpieczeństwa.podnieśGlobalnyPoziomZagrożenia();
// Aktualizacja lokalnych poziomów zagrożenia
protokółCentralny.aktualizujLokalnyPoziomZagrożenia();
protokółWybieg.aktualizujLokalnyPoziomZagrożenia();
// Sprawdzenie zaktualizowanych statusów
console.log(protokółCentralny.statusBezpieczeństwa);
console.log(protokółWybieg.statusBezpieczeństwa);W powyższym przykładzie:
- Stałe poziomów zagrożenia są właściwościami statycznymi, dostępnymi bezpośrednio przez klasę
- Statyczna właściwość
_aktualnyPoziomZagrożeniajest współdzielona przez wszystkie instancje - Metody statyczne mogą modyfikować statyczne właściwości i wywoływać inne metody statyczne
- Instancje klasy mogą aktualizować swoje wewnętrzne stany na podstawie statycznych właściwości
Kiedy używać elementów statycznych
Elementy statyczne są szczególnie przydatne w następujących przypadkach:
- Stałe i konfiguracja - Wartości, które pozostają niezmienne dla wszystkich instancji klasy
- Stan globalny - Kiedy potrzebujemy wartości współdzielonej przez wszystkie instancje
- Metody narzędziowe - Funkcje pomocnicze, które nie wymagają stanu instancji
- Metody fabryczne - Alternatywne sposoby tworzenia instancji klasy
Oto bardziej rozbudowany przykład pokazujący różne zastosowania elementów statycznych:
class GenetycznyRejestr {
// Stałe statyczne
static readonly BAZA_NUKLEOTYDÓW = ["A", "C", "G", "T"];
static readonly MIN_DŁUGOŚĆ_DNA = 1000000;
// Stan globalny
private static _liczbaZarejestrowanychGatunków: number = 0;
private static _rejestracjeGatunków: Map<string, string> = new Map();
// Właściwości instancji
private id: string;
private sekwencjaDNA: string;
private nazwa: string;
constructor(nazwa: string, sekwencjaDNA: string) {
if (sekwencjaDNA.length < GenetycznyRejestr.MIN_DŁUGOŚĆ_DNA) {
throw new Error(`Sekwencja DNA jest za krótka. Wymagane minimum: ${GenetycznyRejestr.MIN_DŁUGOŚĆ_DNA} par zasad.`);
}
this.nazwa = nazwa;
this.sekwencjaDNA = sekwencjaDNA;
this.id = GenetycznyRejestr.wygenerujId(nazwa);
// Rejestracja nowego gatunku
GenetycznyRejestr._rejestracjeGatunków.set(this.id, nazwa);
GenetycznyRejestr._liczbaZarejestrowanychGatunków++;
}
// Metoda narzędziowa - tworzy ID na podstawie nazwy
private static wygenerujId(nazwa: string): string {
const timestamp = Date.now();
const cleanName = nazwa.toLowerCase().replace(/[^a-z0-9]/g, "");
return `DNO-${cleanName}-${timestamp}`;
}
// Metoda fabryczna - tworzy instancję z losowym DNA
static utwórzTestowyGatunek(nazwa: string): GenetycznyRejestr {
const długośćDNA = this.MIN_DŁUGOŚĆ_DNA + Math.floor(Math.random() * 500000);
let sekwencja = "";
for (let i = 0; i < długośćDNA; i++) {
const randomIndex = Math.floor(Math.random() * this.BAZA_NUKLEOTYDÓW.length);
sekwencja += this.BAZA_NUKLEOTYDÓW[randomIndex];
}
return new GenetycznyRejestr(nazwa, sekwencja);
}
// Metoda narzędziowa - weryfikuje poprawność sekwencji DNA
static weryfikujSekwencję(sekwencja: string): boolean {
if (sekwencja.length < this.MIN_DŁUGOŚĆ_DNA) return false;
// Sprawdza, czy sekwencja zawiera tylko dozwolone nukleotydy
for (const nukleotyd of sekwencja) {
if (!this.BAZA_NUKLEOTYDÓW.includes(nukleotyd)) {
return false;
}
}
return true;
}
// Getter dla statycznej właściwości
static get liczbaZarejestrowanychGatunków(): number {
return this._liczbaZarejestrowanychGatunków;
}
// Statyczna metoda zwracająca wszystkie zarejestrowane gatunki
static pobierzWszystkieGatunki(): string[] {
return Array.from(this._rejestracjeGatunków.values());
}
// Instancyjna metoda używająca statycznych pól
analizujSekwencję(): { proporcje: Record<string, number>, długość: number } {
const proporcje: Record<string, number> = {};
// Inicjalizacja liczników dla każdego nukleotydu
GenetycznyRejestr.BAZA_NUKLEOTYDÓW.forEach(n => {
proporcje[n] = 0;
});
// Zliczanie nukleotydów
for (const nukleotyd of this.sekwencjaDNA) {
proporcje[nukleotyd]++;
}
// Konwersja na procenty
GenetycznyRejestr.BAZA_NUKLEOTYDÓW.forEach(n => {
proporcje[n] = Number((proporcje[n] / this.sekwencjaDNA.length * 100).toFixed(2));
});
return {
proporcje,
długość: this.sekwencjaDNA.length
};
}
// Gettery instancji
get identyfikator(): string {
return this.id;
}
get gatunekNazwa(): string {
return this.nazwa;
}
}
// Korzystanie z metod i właściwości statycznych
console.log("Minimalna długość DNA:", GenetycznyRejestr.MIN_DŁUGOŚĆ_DNA);
console.log("Dostępne nukleotydy:", GenetycznyRejestr.BAZA_NUKLEOTYDÓW.join(", "));
// Weryfikacja przykładowej sekwencji
const przykładowaSekwencja = "ACGTACGTACGT".repeat(100000); // Powielenie, aby osiągnąć min. długość
console.log("Weryfikacja sekwencji:", GenetycznyRejestr.weryfikujSekwencję(przykładowaSekwencja));
// Tworzenie instancji za pomocą metody fabrycznej
const trex = GenetycznyRejestr.utwórzTestowyGatunek("Tyrannosaurus Rex");
const raptor = GenetycznyRejestr.utwórzTestowyGatunek("Velociraptor");
const trike = GenetycznyRejestr.utwórzTestowyGatunek("Triceratops");
// Sprawdzenie, ile gatunków zostało zarejestrowanych
console.log("Liczba zarejestrowanych gatunków:", GenetycznyRejestr.liczbaZarejestrowanychGatunków);
console.log("Lista gatunków:", GenetycznyRejestr.pobierzWszystkieGatunki());
// Użycie metod instancji
const analizaTrex = trex.analizujSekwencję();
console.log(`Analiza ${trex.gatunekNazwa} (ID: ${trex.identyfikator}):`);
console.log(`Długość sekwencji: ${analizaTrex.długość} par zasad`);
console.log("Proporcje nukleotydów:", analizaTrex.proporcje);Ten przykład pokazuje:
- Użycie stałych statycznych (
BAZA_NUKLEOTYDÓW,MIN_DŁUGOŚĆ_DNA) - Globalny stan śledzący liczbę i rejestrację gatunków
- Statyczne metody narzędziowe jak
weryfikujSekwencjęiwygenerujId - Metodę fabryczną
utwórzTestowyGatunektworzącą instancje z losowymi danymi - Jak metody instancji mogą korzystać z właściwości statycznych
Klasy i metody abstrakcyjne
Klasy abstrakcyjne w TypeScript definiują szablon, który musi być zaimplementowany przez klasy dziedziczące. Nie można tworzyć instancji klasy abstrakcyjnej bezpośrednio - służy ona jako bazowy "wzorzec" dla innych klas.
Metody abstrakcyjne, określone w klasie abstrakcyjnej, muszą być zaimplementowane przez klasy dziedziczące. Definiują one kontrakt, określający, jakie metody muszą być dostępne, ale nie zawierają własnej implementacji.
Podstawy klas abstrakcyjnych
Zobaczmy, jak wykorzystać klasy abstrakcyjne w kontekście Parku Jurajskiego:
// Abstrakcyjna klasa bazowa dla wszystkich dinozaurów
abstract class Dinozaur {
// Właściwości wspólne dla wszystkich dinozaurów
private _id: string;
protected _nazwa: string;
protected _gatunek: string;
protected _wiek: number;
protected _waga: number;
constructor(id: string, nazwa: string, gatunek: string, wiek: number, waga: number) {
this._id = id;
this._nazwa = nazwa;
this._gatunek = gatunek;
this._wiek = wiek;
this._waga = waga;
}
// Gettery
get id(): string { return this._id; }
get nazwa(): string { return this._nazwa; }
get gatunek(): string { return this._gatunek; }
get wiek(): number { return this._wiek; }
get waga(): number { return this._waga; }
// Metody implementowane we wszystkich klasach pochodnych
abstract obliczZapotrzebowanieKaloryczne(): number;
abstract określPoziomZagrożenia(): number;
// Abstrakcyjna właściwość - musi być zaimplementowana w klasach pochodnych
abstract get typDiety(): string;
// Konkretna metoda (nie abstrakcyjna) - dostępna we wszystkich klasach pochodnych
pobierzPodstawoweDane(): string {
return `${this._nazwa} (${this._gatunek}) - ID: ${this._id}, Wiek: ${this._wiek} lat, Waga: ${this._waga} kg`;
}
// Metoda korzystająca z metod abstrakcyjnych
wygenerujRaportDinozaura(): string {
const kalorie = this.obliczZapotrzebowanieKaloryczne();
const poziomZagrożenia = this.określPoziomZagrożenia();
return `
=== RAPORT DINOZAURA ===
${this.pobierzPodstawoweDane()}
Typ diety: ${this.typDiety}
Dzienne zapotrzebowanie kaloryczne: ${kalorie} kcal
Poziom zagrożenia: ${poziomZagrożenia}/10
======================
`;
}
}
// Klasa dziedzicząca po klasie abstrakcyjnej
class DrapieżnyDinozaur extends Dinozaur {
private _siłaUgryzienia: number;
private _prędkośćBiegu: number;
constructor(
id: string,
nazwa: string,
gatunek: string,
wiek: number,
waga: number,
siłaUgryzienia: number,
prędkośćBiegu: number
) {
super(id, nazwa, gatunek, wiek, waga);
this._siłaUgryzienia = siłaUgryzienia;
this._prędkośćBiegu = prędkośćBiegu;
}
// Gettery
get siłaUgryzienia(): number { return this._siłaUgryzienia; }
get prędkośćBiegu(): number { return this._prędkośćBiegu; }
// Implementacja abstrakcyjnej właściwości
get typDiety(): string {
return "mięsożerny";
}
// Implementacje metod abstrakcyjnych
obliczZapotrzebowanieKaloryczne(): number {
// Dla drapieżników używamy złożonego wzoru
return Math.round(this._waga * 0.6 * (this._prędkośćBiegu * 0.2));
}
określPoziomZagrożenia(): number {
// Poziom zagrożenia zależy od siły ugryzienia, prędkości i wagi
const bazowy = (this._siłaUgryzienia * 0.7 + this._prędkośćBiegu * 0.3) / 100;
return Math.min(10, Math.max(1, Math.round(bazowy)));
}
// Metoda specyficzna dla drapieżników
poluj(): string {
return `${this._nazwa} poluje z prędkością ${this._prędkośćBiegu} km/h i siłą ugryzienia ${this._siłaUgryzienia} PSI`;
}
}
// Inna klasa dziedzicząca
class RoślinożernyDinozaur extends Dinozaur {
private _długośćSzyi: number;
private _typPancerza: "brak" | "lekki" | "średni" | "ciężki";
constructor(
id: string,
nazwa: string,
gatunek: string,
wiek: number,
waga: number,
długośćSzyi: number,
typPancerza: "brak" | "lekki" | "średni" | "ciężki"
) {
super(id, nazwa, gatunek, wiek, waga);
this._długośćSzyi = długośćSzyi;
this._typPancerza = typPancerza;
}
// Gettery
get długośćSzyi(): number { return this._długośćSzyi; }
get typPancerza(): string { return this._typPancerza; }
// Implementacja abstrakcyjnej właściwości
get typDiety(): string {
return "roślinożerny";
}
// Implementacje metod abstrakcyjnych
obliczZapotrzebowanieKaloryczne(): number {
// Dla roślinożerców używamy prostszego wzoru - potrzebują więcej kalorii na kilogram
return Math.round(this._waga * 0.8);
}
określPoziomZagrożenia(): number {
// Poziom zagrożenia jest niższy dla roślinożerców, ale zależy od wagi i typu pancerza
let bazowy = this._waga / 1000;
// Modyfikator zależny od pancerza
const modyfikatoryPancerza = {
"brak": 0,
"lekki": 1,
"średni": 2,
"ciężki": 3
};
bazowy += modyfikatoryPancerza[this._typPancerza];
return Math.min(7, Math.max(1, Math.round(bazowy))); // Maks. 7 dla roślinożerców
}
// Metoda specyficzna dla roślinożerców
pasięSię(): string {
const wysokośćSięgania = this._długośćSzyi > 2 ? "wysokich" : "niskich";
return `${this._nazwa} pasie się, zjadając rośliny z ${wysokośćSięgania} partii drzew`;
}
}
// Nie możemy utworzyć instancji klasy abstrakcyjnej
// const nieprawidłowy = new Dinozaur("ID", "Nazwa", "Gatunek", 1, 100); // Błąd!
// Tworzenie instancji klas pochodnych
const trex = new DrapieżnyDinozaur("T-REX-1", "Rex", "Tyrannosaurus", 8, 7000, 12800, 32);
const stegozaur = new RoślinożernyDinozaur("STEG-1", "Spike", "Stegosaurus", 12, 5000, 1.2, "ciężki");
const diplodok = new RoślinożernyDinozaur("DIPL-1", "Dippy", "Diplodocus", 15, 16000, 6.5, "brak");
// Korzystanie z metod zaimplementowanych w klasach pochodnych
console.log(trex.wygenerujRaportDinozaura());
console.log(stegozaur.wygenerujRaportDinozaura());
console.log(diplodok.wygenerujRaportDinozaura());
// Korzystanie z metod specyficznych dla danej klasy
console.log(trex.poluj());
console.log(stegozaur.pasięSię());
// Dla obu typów dinozaurów możemy korzystać z metod klasy bazowej
console.log(trex.pobierzPodstawoweDane());
console.log(diplodok.pobierzPodstawoweDane());W powyższym przykładzie:
Dinozaurto klasa abstrakcyjna zawierająca wspólne właściwości i metody- Abstrakcyjne metody
obliczZapotrzebowanieKaloryczne()iokreślPoziomZagrożenia()muszą być zaimplementowane przez klasy dziedziczące - Abstrakcyjna właściwość
typDietymusi być zdefiniowana w klasach pochodnych - Klasy
DrapieżnyDinozauriRoślinożernyDinozaurimplementują abstrakcyjne metody i właściwości - Nie można utworzyć instancji klasy
Dinozaurbezpośrednio
Zastosowanie abstrakcyjnych klas i metod
Klasy abstrakcyjne są szczególnie przydatne w następujących przypadkach:
- Definiowanie wspólnego interfejsu - Określenie spójnego zestawu metod dla grupy powiązanych klas
- Współdzielenie kodu - Zapewnienie wspólnej implementacji dla grup klas
- Wymuszanie kontraktu - Gwarancja, że wszystkie klasy pochodne zaimplementują wymagane metody
- Tworzenie hierarchii typów - Budowanie złożonych relacji między typami
Zobaczmy bardziej zaawansowany przykład, łączący abstrakcyjne klasy i metody z elementami statycznymi w systemie zarządzania protokołami bezpieczeństwa Parku Jurajskiego:
// Typy pomocnicze
type PoziomAlertów = "normalny" | "podwyższony" | "wysoki" | "krytyczny";
type StatusSystem = "aktywny" | "nieaktywny" | "w_konserwacji" | "awaria";
// Interfejs dla systemów monitorujących
interface SystemMonitorujący {
rozpocznijMonitorowanie(): void;
zakończMonitorowanie(): void;
pobierzAktualnyStatus(): StatusSystem;
}
// Abstrakcyjna klasa bazowa dla wszystkich systemów bezpieczeństwa
abstract class SystemBezpieczeństwa implements SystemMonitorujący {
// Statyczne właściwości - dla wszystkich systemów bezpieczeństwa
private static _poziomAlertówParku: PoziomAlertów = "normalny";
private static _aktywneSystemy: Set<string> = new Set();
private static _incydenty: Array<{data: Date, typSystemu: string, lokalizacja: string, opis: string}> = [];
// Zwykłe właściwości
protected _id: string;
protected _lokalizacja: string;
protected _status: StatusSystem;
protected _czyMonitorowany: boolean;
protected _dataPrzeglądu: Date;
constructor(id: string, lokalizacja: string) {
this._id = id;
this._lokalizacja = lokalizacja;
this._status = "nieaktywny";
this._czyMonitorowany = false;
this._dataPrzeglądu = new Date();
// Rejestracja systemu
SystemBezpieczeństwa.zarejestrujSystem(id, this.constructor.name);
}
// Statyczne metody
static zarejestrujSystem(id: string, typSystemu: string): void {
console.log(`Zarejestrowano nowy system bezpieczeństwa: ${typSystemu} (ID: ${id})`);
}
static zgłośIncydent(typSystemu: string, lokalizacja: string, opis: string): void {
const incydent = {
data: new Date(),
typSystemu,
lokalizacja,
opis
};
this._incydenty.push(incydent);
console.log(`ALERT: Zgłoszono incydent w lokalizacji ${lokalizacja}: ${opis}`);
// Automatycznie podnosimy poziom alertów
if (this._poziomAlertówParku === "normalny") {
this.zmieńPoziomAlertów("podwyższony");
} else if (this._poziomAlertówParku === "podwyższony") {
this.zmieńPoziomAlertów("wysoki");
} else if (this._poziomAlertówParku === "wysoki") {
this.zmieńPoziomAlertów("krytyczny");
}
}
static zmieńPoziomAlertów(nowyPoziom: PoziomAlertów): void {
this._poziomAlertówParku = nowyPoziom;
console.log(`UWAGA: Zmieniono poziom alertów parku na: ${nowyPoziom.toUpperCase()}`);
}
static get poziomAlertów(): PoziomAlertów {
return this._poziomAlertówParku;
}
static get ostatnieIncydenty(): Array<{data: Date, typSystemu: string, lokalizacja: string, opis: string}> {
// Zwracamy 5 ostatnich incydentów
return [...this._incydenty].slice(-5);
}
// Gettery instancji
get id(): string { return this._id; }
get lokalizacja(): string { return this._lokalizacja; }
get status(): StatusSystem { return this._status; }
// Implementacja interfejsu SystemMonitorujący
rozpocznijMonitorowanie(): void {
this._czyMonitorowany = true;
SystemBezpieczeństwa._aktywneSystemy.add(this._id);
console.log(`Rozpoczęto monitorowanie systemu ${this.constructor.name} w lokalizacji ${this._lokalizacja}`);
}
zakończMonitorowanie(): void {
this._czyMonitorowany = false;
SystemBezpieczeństwa._aktywneSystemy.delete(this._id);
console.log(`Zakończono monitorowanie systemu ${this.constructor.name} w lokalizacji ${this._lokalizacja}`);
}
pobierzAktualnyStatus(): StatusSystem {
return this._status;
}
// Abstrakcyjne metody, które muszą być zaimplementowane
abstract uruchom(): void;
abstract zatrzymaj(): void;
abstract wykonajPrzegląd(): void;
// Abstrakcyjne właściwości
abstract get typSystemu(): string;
abstract get poziomPriorytetuAlarmowego(): number; // 1-10
// Metoda wykorzystująca abstrakcyjne właściwości i metody
wygenerujRaportStatusu(): string {
return `
=== RAPORT SYSTEMU BEZPIECZEŃSTWA ===
ID: ${this._id}
Typ: ${this.typSystemu}
Lokalizacja: ${this._lokalizacja}
Status: ${this._status}
Monitorowany: ${this._czyMonitorowany ? "TAK" : "NIE"}
Priorytet alarmowy: ${this.poziomPriorytetuAlarmowego}/10
Ostatni przegląd: ${this._dataPrzeglądu.toLocaleDateString()}
Globalny poziom alertów: ${SystemBezpieczeństwa._poziomAlertówParku.toUpperCase()}
=================================
`;
}
}
// Klasa pochodna - System Ogrodzenia Elektrycznego
class SystemOgrodzeniaElektrycznego extends SystemBezpieczeństwa {
private _napięcie: number; // w woltach
private _długośćOgrodzenia: number; // w metrach
private _typZabezpieczenia: "standardowe" | "wzmocnione" | "ultrawzmocnione";
constructor(
id: string,
lokalizacja: string,
długośćOgrodzenia: number,
typZabezpieczenia: "standardowe" | "wzmocnione" | "ultrawzmocnione"
) {
super(id, lokalizacja);
this._napięcie = 0;
this._długośćOgrodzenia = długośćOgrodzenia;
this._typZabezpieczenia = typZabezpieczenia;
}
// Implementacja abstrakcyjnych właściwości
get typSystemu(): string {
return "Ogrodzenie Elektryczne";
}
get poziomPriorytetuAlarmowego(): number {
// Priorytet zależy od typu zabezpieczenia
const bazowy = this._typZabezpieczenia === "standardowe" ? 7 :
this._typZabezpieczenia === "wzmocnione" ? 8 : 10;
// Uwzględniamy długość ogrodzenia - dłuższe mają wyższy priorytet
const modyfikator = Math.min(2, Math.floor(this._długośćOgrodzenia / 1000));
return Math.min(10, bazowy + modyfikator);
}
// Implementacja abstrakcyjnych metod
uruchom(): void {
if (this._status === "w_konserwacji") {
console.log(`BŁĄD: Nie można uruchomić systemu ${this._id} - jest w trakcie konserwacji`);
return;
}
this._status = "aktywny";
// Napięcie zależy od typu zabezpieczenia
this._napięcie = this._typZabezpieczenia === "standardowe" ? 10000 :
this._typZabezpieczenia === "wzmocnione" ? 20000 : 30000;
console.log(`Uruchomiono system ogrodzenia ${this._id} w lokalizacji ${this._lokalizacja}`);
console.log(`Napięcie: ${this._napięcie}V, Długość: ${this._długośćOgrodzenia}m`);
}
zatrzymaj(): void {
this._status = "nieaktywny";
this._napięcie = 0;
console.log(`Zatrzymano system ogrodzenia ${this._id} w lokalizacji ${this._lokalizacja}`);
// Zgłoszenie incydentu przy wysokim poziomie alertów
if (SystemBezpieczeństwa.poziomAlertów === "wysoki" || SystemBezpieczeństwa.poziomAlertów === "krytyczny") {
SystemBezpieczeństwa.zgłośIncydent(
this.typSystemu,
this._lokalizacja,
`Wyłączenie ogrodzenia przy wysokim poziomie alertów!`
);
}
}
wykonajPrzegląd(): void {
const poprzedniStatus = this._status;
this._status = "w_konserwacji";
console.log(`Rozpoczęto przegląd systemu ogrodzenia ${this._id}`);
// Symulacja przeglądu
setTimeout(() => {
this._dataPrzeglądu = new Date();
this._status = poprzedniStatus;
console.log(`Zakończono przegląd systemu ogrodzenia ${this._id}`);
}, 2000);
}
// Metody specyficzne dla tego typu systemu
zmieńNapięcie(noweNapięcie: number): void {
if (this._status !== "aktywny") {
console.log(`BŁĄD: Nie można zmienić napięcia - system nie jest aktywny`);
return;
}
this._napięcie = noweNapięcie;
console.log(`Zmieniono napięcie ogrodzenia ${this._id} na ${noweNapięcie}V`);
}
zgłośPrzerwęWOgrodzeniu(): void {
this._status = "awaria";
SystemBezpieczeństwa.zgłośIncydent(
this.typSystemu,
this._lokalizacja,
`Wykryto przerwę w ogrodzeniu elektrycznym!`
);
}
}
// Inna klasa pochodna - System Monitoringu Wideo
class SystemMonitoringuWideo extends SystemBezpieczeństwa {
private _liczbaKamer: number;
private _rozdzielczość: "SD" | "HD" | "4K";
private _trybNocny: boolean;
constructor(
id: string,
lokalizacja: string,
liczbaKamer: number,
rozdzielczość: "SD" | "HD" | "4K"
) {
super(id, lokalizacja);
this._liczbaKamer = liczbaKamer;
this._rozdzielczość = rozdzielczość;
this._trybNocny = false;
}
// Implementacja abstrakcyjnych właściwości
get typSystemu(): string {
return "Monitoring Wideo";
}
get poziomPriorytetuAlarmowego(): number {
// Priorytet zależy od liczby kamer i rozdzielczości
const bazowy = 5;
// Modyfikator rozdzielczości
const modyfikatorRozdzielczości =
this._rozdzielczość === "SD" ? 0 :
this._rozdzielczość === "HD" ? 1 : 2;
// Modyfikator liczby kamer
const modyfikatorKamer = Math.min(2, Math.floor(this._liczbaKamer / 10));
return Math.min(10, bazowy + modyfikatorRozdzielczości + modyfikatorKamer);
}
// Implementacja abstrakcyjnych metod
uruchom(): void {
this._status = "aktywny";
console.log(`Uruchomiono system monitoringu ${this._id} w lokalizacji ${this._lokalizacja}`);
console.log(`Liczba kamer: ${this._liczbaKamer}, Rozdzielczość: ${this._rozdzielczość}`);
}
zatrzymaj(): void {
this._status = "nieaktywny";
console.log(`Zatrzymano system monitoringu ${this._id} w lokalizacji ${this._lokalizacja}`);
}
wykonajPrzegląd(): void {
this._status = "w_konserwacji";
console.log(`Rozpoczęto przegląd systemu monitoringu ${this._id}`);
// W tym przypadku przegląd kończy się natychmiast
this._dataPrzeglądu = new Date();
this._status = "aktywny";
console.log(`Zakończono przegląd systemu monitoringu ${this._id}`);
}
// Metody specyficzne dla tego typu systemu
włączTrybNocny(): void {
this._trybNocny = true;
console.log(`Włączono tryb nocny w systemie monitoringu ${this._id}`);
}
wyłączTrybNocny(): void {
this._trybNocny = false;
console.log(`Wyłączono tryb nocny w systemie monitoringu ${this._id}`);
}
wykryjRuch(obszar: string): void {
console.log(`System ${this._id}: Wykryto ruch w obszarze ${obszar}`);
if (SystemBezpieczeństwa.poziomAlertów !== "normalny") {
SystemBezpieczeństwa.zgłośIncydent(
this.typSystemu,
`${this._lokalizacja} - obszar ${obszar}`,
`Wykryto nieautoryzowany ruch!`
);
}
}
}
// Demonstracja systemu bezpieczeństwa Parku Jurajskiego
function testSystemuBezpieczeństwa() {
console.log("=== INICJALIZACJA SYSTEMÓW BEZPIECZEŃSTWA PARKU JURAJSKIEGO ===");
// Tworzenie systemów ogrodzenia
const ogrodzenieGłówne = new SystemOgrodzeniaElektrycznego("FNC-001", "Sektor A - Wejście główne", 2500, "ultrawzmocnione");
const ogrodzenieTRex = new SystemOgrodzeniaElektrycznego("FNC-002", "Sektor B - Wybieg T-Rex", 1200, "ultrawzmocnione");
const ogrodzenieRaptory = new SystemOgrodzeniaElektrycznego("FNC-003", "Sektor C - Wybieg Raptorów", 800, "wzmocnione");
// Tworzenie systemów monitoringu
const monitoringGłówny = new SystemMonitoringuWideo("CAM-001", "Centrum kontroli", 20, "4K");
const monitoringTRex = new SystemMonitoringuWideo("CAM-002", "Sektor B - Wybieg T-Rex", 12, "HD");
const monitoringRaptory = new SystemMonitoringuWideo("CAM-003", "Sektor C - Wybieg Raptorów", 8, "HD");
// Uruchamianie wszystkich systemów
console.log("\n=== URUCHAMIANIE SYSTEMÓW ===");
ogrodzenieGłówne.uruchom();
ogrodzenieTRex.uruchom();
ogrodzenieRaptory.uruchom();
monitoringGłówny.uruchom();
monitoringTRex.uruchom();
monitoringRaptory.uruchom();
// Rozpoczęcie monitorowania
console.log("\n=== AKTYWACJA MONITOROWANIA ===");
ogrodzenieGłówne.rozpocznijMonitorowanie();
ogrodzenieTRex.rozpocznijMonitorowanie();
ogrodzenieRaptory.rozpocznijMonitorowanie();
monitoringGłówny.rozpocznijMonitorowanie();
monitoringTRex.rozpocznijMonitorowanie();
monitoringRaptory.rozpocznijMonitorowanie();
// Sprawdzenie statusów
console.log("\n=== RAPORTY SYSTEMÓW ===");
console.log(ogrodzenieGłówne.wygenerujRaportStatusu());
console.log(monitoringTRex.wygenerujRaportStatusu());
// Symulacja incydentu
console.log("\n=== SYMULACJA INCYDENTU ===");
console.log("Aktualny poziom alertów:", SystemBezpieczeństwa.poziomAlertów);
monitoringRaptory.wykryjRuch("Południowy narożnik");
ogrodzenieRaptory.zgłośPrzerwęWOgrodzeniu();
// Sprawdzenie poziom alertów po incydentach
console.log("\nAktualny poziom alertów po incydentach:", SystemBezpieczeństwa.poziomAlertów);
// Wyświetlenie ostatnich incydentów
console.log("\n=== OSTATNIE INCYDENTY ===");
SystemBezpieczeństwa.ostatnieIncydenty.forEach((incydent, index) => {
console.log(`${index + 1}. [${incydent.data.toLocaleString()}] ${incydent.typSystemu} w ${incydent.lokalizacja}: ${incydent.opis}`);
});
// Przeprowadzenie przeglądu
console.log("\n=== PRZEGLĄD SYSTEMÓW ===");
ogrodzenieTRex.wykonajPrzegląd();
monitoringGłówny.wykonajPrzegląd();
// Ręczna zmiana poziomu alertów
console.log("\n=== NORMALIZACJA SYTUACJI ===");
SystemBezpieczeństwa.zmieńPoziomAlertów("normalny");
}
// Uruchomienie testu
testSystemuBezpieczeństwa();W tym zaawansowanym przykładzie:
- Używamy abstrakcyjnej klasy
SystemBezpieczeństwajako bazę dla wszystkich systemów bezpieczeństwa - Klasa definiuje statyczne właściwości i metody (np. poziom alertów parku, lista incydentów)
- Abstrakcyjne metody i właściwości wymuszają implementację specyficznej funkcjonalności w klasach pochodnych
- Klasy pochodne (
SystemOgrodzeniaElektrycznegoiSystemMonitoringuWideo) implementują abstrakcyjne elementy - Elementy statyczne pozwalają na centralną koordynację (np. zgłaszanie incydentów i zarządzanie poziomem alertów)
Łączenie elementów statycznych i abstrakcyjnych
Elementy statyczne i abstrakcyjne mogą być potężnym narzędziem, gdy są używane razem w dobrze zaprojektowanej hierarchii klas. Oto kilka wzorców i przykładów ich zastosowania:
1. Abstrakcyjna klasa bazowa ze statycznymi metodami fabrycznymi
abstract class GatunekDinozaura {
// Właściwości statyczne
private static _zarejestrowaneDinozaury: Map<string, GatunekDinozaura> = new Map();
// Właściwości instancji
private _nazwa: string;
private _eraDominocenitryczna: string;
protected _dietaTyp: "mięsożerny" | "roślinożerny" | "wszystkożerny";
constructor(nazwa: string, era: string, dieta: "mięsożerny" | "roślinożerny" | "wszystkożerny") {
this._nazwa = nazwa;
this._eraDominocenitryczna = era;
this._dietaTyp = dieta;
// Dodanie do rejestru
GatunekDinozaura._zarejestrowaneDinozaury.set(nazwa, this);
}
// Statyczna metoda fabryczna - tworzy odpowiedni gatunek na podstawie diety
static stwórzGatunek(
nazwa: string,
era: string,
dieta: "mięsożerny" | "roślinożerny" | "wszystkożerny",
parametryDodatkowe: Record<string, any>
): GatunekDinozaura {
if (dieta === "mięsożerny") {
return new MięsożernyGatunek(
nazwa,
era,
parametryDodatkowe.siłaUgryzienia,
parametryDodatkowe.prędkośćBiegu
);
} else {
return new RoślinożernyGatunek(
nazwa,
era,
parametryDodatkowe.długośćSzyi || 0,
parametryDodatkowe.posiadaPancerz || false
);
}
}
// Statyczna metoda do pobierania zarejestrowanych gatunków
static pobierzGatunek(nazwa: string): GatunekDinozaura | undefined {
return this._zarejestrowaneDinozaury.get(nazwa);
}
static get wszystkieGatunki(): string[] {
return Array.from(this._zarejestrowaneDinozaury.keys());
}
// Gettery instancji
get nazwa(): string { return this._nazwa; }
get era(): string { return this._eraDominocenitryczna; }
get typDiety(): string { return this._dietaTyp; }
// Abstrakcyjne metody
abstract opisZachowania(): string;
abstract obliczSzacowanąWagę(długość: number): number;
// Metoda wykorzystująca abstrakcyjne metody
generujOpis(): string {
return `${this._nazwa} - dinozaur ${this._dietaTyp} z ery ${this._eraDominocenitryczna}.
${this.opisZachowania()}`;
}
}
// Klasy pochodne
class MięsożernyGatunek extends GatunekDinozaura {
private _siłaUgryzienia: number; // w PSI
private _prędkośćBiegu: number; // w km/h
constructor(nazwa: string, era: string, siłaUgryzienia: number, prędkośćBiegu: number) {
super(nazwa, era, "mięsożerny");
this._siłaUgryzienia = siłaUgryzienia;
this._prędkośćBiegu = prędkośćBiegu;
}
// Gettery
get siłaUgryzienia(): number { return this._siłaUgryzienia; }
get prędkośćBiegu(): number { return this._prędkośćBiegu; }
// Implementacja abstrakcyjnych metod
opisZachowania(): string {
return `Poluje z prędkością ${this._prędkośćBiegu} km/h i siłą ugryzienia ${this._siłaUgryzienia} PSI.`;
}
obliczSzacowanąWagę(długość: number): number {
// Przybliżony wzór dla drapieżników
return długość * długość * 100;
}
}
class RoślinożernyGatunek extends GatunekDinozaura {
private _długośćSzyi: number; // w metrach
private _posiadaPancerz: boolean;
constructor(nazwa: string, era: string, długośćSzyi: number, posiadaPancerz: boolean) {
super(nazwa, era, "roślinożerny");
this._długośćSzyi = długośćSzyi;
this._posiadaPancerz = posiadaPancerz;
}
// Gettery
get długośćSzyi(): number { return this._długośćSzyi; }
get posiadaPancerz(): boolean { return this._posiadaPancerz; }
// Implementacja abstrakcyjnych metod
opisZachowania(): string {
const opisSzyi = this._długośćSzyi > 3
? `Posiada długą szyję (${this._długośćSzyi}m) umożliwiającą zjadanie wysokiej roślinności.`
: "Żywi się niską roślinnością.";
const opisPancerza = this._posiadaPancerz
? "Posiada pancerz chroniący przed drapieżnikami."
: "Nie posiada pancerza ochronnego.";
return `${opisSzyi} ${opisPancerza}`;
}
obliczSzacowanąWagę(długość: number): number {
// Przybliżony wzór dla roślinożerców (zwykle cięższe)
let waga = długość * długość * 150;
// Dodatkowa waga za pancerz
if (this._posiadaPancerz) {
waga *= 1.3;
}
return waga;
}
}
// Użycie
function testGatunkówDinozaurów() {
// Tworzenie gatunków za pomocą metody fabrycznej
GatunekDinozaura.stwórzGatunek(
"Tyrannosaurus Rex",
"późna kreda",
"mięsożerny",
{ siłaUgryzienia: 12800, prędkośćBiegu: 32 }
);
GatunekDinozaura.stwórzGatunek(
"Velociraptor",
"późna kreda",
"mięsożerny",
{ siłaUgryzienia: 2000, prędkośćBiegu: 64 }
);
GatunekDinozaura.stwórzGatunek(
"Brachiosaurus",
"późna jura",
"roślinożerny",
{ długośćSzyi: 9, posiadaPancerz: false }
);
GatunekDinozaura.stwórzGatunek(
"Stegosaurus",
"późna jura",
"roślinożerny",
{ długośćSzyi: 0.5, posiadaPancerz: true }
);
// Dostęp do zarejestrowanych gatunków
console.log("Dostępne gatunki:", GatunekDinozaura.wszystkieGatunki);
// Pobieranie informacji o gatunkach
const trex = GatunekDinozaura.pobierzGatunek("Tyrannosaurus Rex");
const brach = GatunekDinozaura.pobierzGatunek("Brachiosaurus");
if (trex) {
console.log(trex.generujOpis());
console.log(`Szacowana waga (12m długości): ${trex.obliczSzacowanąWagę(12)} kg`);
}
if (brach) {
console.log(brach.generujOpis());
console.log(`Szacowana waga (25m długości): ${brach.obliczSzacowanąWagę(25)} kg`);
}
// Sprawdzanie typu
const steg = GatunekDinozaura.pobierzGatunek("Stegosaurus") as RoślinożernyGatunek;
if (steg && steg instanceof RoślinożernyGatunek) {
console.log(`Stegosaurus posiada pancerz: ${steg.posiadaPancerz ? "TAK" : "NIE"}`);
}
const raptor = GatunekDinozaura.pobierzGatunek("Velociraptor") as MięsożernyGatunek;
if (raptor && raptor instanceof MięsożernyGatunek) {
console.log(`Velociraptor - prędkość biegu: ${raptor.prędkośćBiegu} km/h`);
}
}
testGatunkówDinozaurów();2. Abstrakcyjne metody statyczne
W TypeScript od wersji 4.0 możliwe jest definiowanie abstrakcyjnych metod statycznych. Umożliwia to tworzenie hierarchii klas, gdzie klasy pochodne muszą implementować określone metody statyczne:
abstract class SystemLokacji {
// Właściwości instancji
protected _id: string;
protected _nazwa: string;
constructor(id: string, nazwa: string) {
this._id = id;
this._nazwa = nazwa;
}
// Abstrakcyjna statyczna metoda, którą muszą zaimplementować klasy pochodne
static abstract generujIdentyfikatorLokacji(typ: string, numer: number): string;
// Zwykła abstrakcyjna metoda instancji
abstract pobierzInformacjeOLokacji(): Record<string, any>;
// Metoda instancji
wygenerujRaport(): string {
const info = this.pobierzInformacjeOLokacji();
let raport = `=== RAPORT LOKACJI: ${this._nazwa} (ID: ${this._id}) ===\n`;
for (const [klucz, wartość] of Object.entries(info)) {
raport += `${klucz}: ${wartość}\n`;
}
return raport;
}
}
class WybiegDinozaurów extends SystemLokacji {
private _gatunek: string;
private _powierzchnia: number; // w hektarach
private _liczbaOsobników: number;
constructor(numer: number, nazwa: string, gatunek: string, powierzchnia: number, liczbaOsobników: number) {
// Generowanie ID dla wybiegu
const id = WybiegDinozaurów.generujIdentyfikatorLokacji("wybieg", numer);
super(id, nazwa);
this._gatunek = gatunek;
this._powierzchnia = powierzchnia;
this._liczbaOsobników = liczbaOsobników;
}
// Implementacja abstrakcyjnej statycznej metody
static generujIdentyfikatorLokacji(typ: string, numer: number): string {
return `${typ.toUpperCase()}-${numer.toString().padStart(3, '0')}`;
}
// Implementacja abstrakcyjnej metody instancji
pobierzInformacjeOLokacji(): Record<string, any> {
return {
typ: "Wybieg dinozaurów",
gatunek: this._gatunek,
powierzchnia: `${this._powierzchnia} ha`,
liczbaOsobników: this._liczbaOsobników,
gęstośćZaludnienia: `${(this._liczbaOsobników / this._powierzchnia).toFixed(2)} os./ha`
};
}
// Metody specyficzne dla tej klasy
dodajOsobnika(): void {
this._liczbaOsobników++;
console.log(`Dodano nowego osobnika do wybiegu ${this._nazwa}. Nowa liczba: ${this._liczbaOsobników}`);
}
usuńOsobnika(): boolean {
if (this._liczbaOsobników > 0) {
this._liczbaOsobników--;
console.log(`Usunięto osobnika z wybiegu ${this._nazwa}. Nowa liczba: ${this._liczbaOsobników}`);
return true;
}
console.log(`Błąd: Nie można usunąć osobnika z wybiegu ${this._nazwa} - brak osobników.`);
return false;
}
}
class AtrakcjaTurystyczna extends SystemLokacji {
private _typAtrakcji: string;
private _pojemność: number;
private _czasOczekiwania: number; // w minutach
constructor(numer: number, nazwa: string, typAtrakcji: string, pojemność: number) {
// Generowanie ID dla atrakcji
const id = AtrakcjaTurystyczna.generujIdentyfikatorLokacji("atrakcja", numer);
super(id, nazwa);
this._typAtrakcji = typAtrakcji;
this._pojemność = pojemność;
this._czasOczekiwania = 0;
}
// Implementacja abstrakcyjnej statycznej metody
static generujIdentyfikatorLokacji(typ: string, numer: number): string {
// Inny format ID dla atrakcji
return `${typ.substring(0, 3).toUpperCase()}${numer.toString().padStart(4, '0')}`;
}
// Implementacja abstrakcyjnej metody instancji
pobierzInformacjeOLokacji(): Record<string, any> {
return {
typ: "Atrakcja turystyczna",
kategoria: this._typAtrakcji,
pojemność: this._pojemność,
czasOczekiwania: `${this._czasOczekiwania} min`
};
}
// Metody specyficzne dla tej klasy
aktualizujCzasOczekiwania(nowyOczekiwanieCzas: number): void {
this._czasOczekiwania = nowyOczekiwanieCzas;
console.log(`Zaktualizowano czas oczekiwania dla ${this._nazwa}: ${this._czasOczekiwania} min`);
}
}
// Zastosowanie
function testSystemLokacji() {
// Tworzenie wybiegów
const wybiegTRex = new WybiegDinozaurów(1, "Królestwo T-Rexa", "Tyrannosaurus Rex", 5, 1);
const wybiegRaptorów = new WybiegDinozaurów(2, "Dolina Raptorów", "Velociraptor", 3, 6);
// Tworzenie atrakcji
const centrumOdwiedzających = new AtrakcjaTurystyczna(101, "Centrum Genetyki", "edukacyjna", 500);
const safariJeepem = new AtrakcjaTurystyczna(102, "Safari Jurajskie", "przejażdżka", 50);
// Wyświetlanie raportów
console.log(wybiegTRex.wygenerujRaport());
console.log(wybiegRaptorów.wygenerujRaport());
console.log(centrumOdwiedzających.wygenerujRaport());
console.log(safariJeepem.wygenerujRaport());
// Wykonywanie operacji
wybiegRaptorów.dodajOsobnika();
wybiegRaptorów.dodajOsobnika();
safariJeepem.aktualizujCzasOczekiwania(45);
// Sprawdzenie zaktualizowanych danych
console.log(wybiegRaptorów.wygenerujRaport());
console.log(safariJeepem.wygenerujRaport());
// Demonstracja różnych formatów ID generowanych przez implementacje statycznych metod
console.log("Format ID wybiegu:", WybiegDinozaurów.generujIdentyfikatorLokacji("wybieg", 42));
console.log("Format ID atrakcji:", AtrakcjaTurystyczna.generujIdentyfikatorLokacji("atrakcja", 42));
}
testSystemLokacji();Podsumowanie
W tym ćwiczeniu poznaliśmy dwa potężne mechanizmy TypeScript:
Właściwości i metody statyczne:
- Należą do klasy, a nie do instancji
- Umożliwiają współdzielenie danych i funkcjonalności między wszystkimi instancjami
- Idealne do definiowania stałych, globalnego stanu i metod narzędziowych
- Dostępne bezpośrednio przez nazwę klasy, bez konieczności tworzenia instancji
Klasy i metody abstrakcyjne:
- Definiują "szablon" lub "kontrakt", który musi być zaimplementowany przez klasy dziedziczące
- Nie można tworzyć instancji klas abstrakcyjnych bezpośrednio
- Wymuszają implementację określonych metod w klasach pochodnych
- Pozwalają na współdzielenie wspólnej funkcjonalności przez hierarchię klas
Łącząc te koncepcje, możemy tworzyć eleganckie, modułowe i typowo bezpieczne systemy, które idealnie nadają się do modelowania złożonych relacji i procesów, takich jak te w systemie zarządzania Parkiem Jurajskim.
Dr. Henry Wu podsumowałby to następująco: "W naturze, podobnie jak w programowaniu, istnieje piękno w strukturze i porządku. Elementy statyczne zapewniają spójność dla całego gatunku, podczas gdy abstrakcyjne koncepcje stanowią podstawowy plan, który każdy organizm musi zaimplementować na swój własny sposób. Razem tworzą doskonałą harmonię - z odpowiednimi zabezpieczeniami, oczywiście... w większości przypadków."
Kod do tej lekcji: index.ts
// Właściwości statyczne i klasy abstrakcyjne - Park Jurajski
console.log("=== WŁAŚCIWOŚCI STATYCZNE I KLASY ABSTRAKCYJNE ===\n");
// ===========================================
// 1. Klasa abstrakcyjna Dinosaur
// ===========================================
abstract class Dinosaur {
// Statyczny licznik wszystkich dinozaurów
static totalCount: number = 0;
static readonly PARK_NAME: string = "Jurassic World";
// Statyczna metoda fabrykująca
static createId(): string {
return `DINO-${String(++Dinosaur.totalCount).padStart(4, "0")}`;
}
// Pola instancji
readonly id: string;
name: string;
protected weight: number;
constructor(name: string, weight: number) {
this.id = Dinosaur.createId();
this.name = name;
this.weight = weight;
}
// Metoda abstrakcyjna - każdy gatunek musi ją zaimplementować
abstract makeSound(): string;
abstract getDangerLevel(): number;
// Wspólna metoda
getProfile(): string {
return `[${this.id}] ${this.name} - ${this.weight}kg`;
}
}
// ===========================================
// 2. Implementacje klas konkretnych
// ===========================================
class TRex extends Dinosaur {
private biteForce: number;
constructor(name: string, weight: number, biteForce: number) {
super(name, weight);
this.biteForce = biteForce;
}
makeSound(): string {
return "ROOOOAAAR!";
}
getDangerLevel(): number {
return 10;
}
}
class Triceratops extends Dinosaur {
private hornLength: number;
constructor(name: string, weight: number, hornLength: number) {
super(name, weight);
this.hornLength = hornLength;
}
makeSound(): string {
return "BRRRRR!";
}
getDangerLevel(): number {
return 4;
}
}
// ===========================================
// 3. Statyczna metoda fabrykująca
// ===========================================
class DinosaurFactory {
static registry: Map<string, Dinosaur> = new Map();
static create(type: "trex" | "triceratops", name: string): Dinosaur {
let dino: Dinosaur;
if (type === "trex") {
dino = new TRex(name, 8000, 12800);
} else {
dino = new Triceratops(name, 6000, 90);
}
DinosaurFactory.registry.set(dino.id, dino);
return dino;
}
static getAll(): Dinosaur[] {
return Array.from(DinosaurFactory.registry.values());
}
}
// ===========================================
// Test
// ===========================================
const rex = DinosaurFactory.create("trex", "Rexy");
const trike = DinosaurFactory.create("triceratops", "Cera");
const rex2 = DinosaurFactory.create("trex", "Buck");
console.log("Park:", Dinosaur.PARK_NAME);
console.log("Liczba dinozaurow:", Dinosaur.totalCount);
console.log("");
DinosaurFactory.getAll().forEach(dino => {
console.log(dino.getProfile());
console.log(" Dzwiek:", dino.makeSound());
console.log(" Zagrozenie:", dino.getDangerLevel(), "/10");
});
// Nie mozna stworzyc instancji klasy abstrakcyjnej:
// const dino = new Dinosaur("Test", 100); // Error!
console.log("\nKlasa abstrakcyjna nie moze byc instancjonowana bezposrednio.");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym jest klasa abstrakcyjna w TypeScript?
2. Czym różnią się właściwości statyczne od zwykłych w klasie?
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj klasy z właściwościami statycznymi i abstrakcyjnymi.
- Klikanie w kolejności
Ułóż elementy deklaracji klasy abstrakcyjnej:
- Edytor kodu
Stwórz klasy z różnymi modyfikatorami dostępu dla systemu parku