Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Modyfikatory dostępu (public, private, protected)
W tej lekcji9
"Bezpieczeństwo w Parku Jurajskim to kwestia najwyższej wagi," stwierdza stanowczo John Hammond, prezes InGen. "Niektóre dane i procedury muszą być dostępne dla wszystkich pracowników, inne tylko dla osób z odpowiednimi uprawnieniami, a jeszcze inne są tak krytyczne, że dostęp do nich ma wyłącznie najwyższe kierownictwo."
Podobnie jak w Parku Jurajskim, w programowaniu obiektowym kontrola dostępu do właściwości i metod klas jest fundamentalnym aspektem dobrego projektowania. TypeScript oferuje trzy modyfikatory dostępu, które pozwalają precyzyjnie określić, kto i w jakim zakresie może korzystać z poszczególnych elementów klas: public, private i protected.
Wprowadzenie do modyfikatorów dostępu
Modyfikatory dostępu określają, z jakich poziomów kodu można uzyskać dostęp do właściwości i metod klasy:
- public - dostęp z dowolnego miejsca w kodzie (domyślny)
- private - dostęp tylko wewnątrz danej klasy
- protected - dostęp wewnątrz danej klasy i klas dziedziczących
Przyjrzyjmy się, jak te modyfikatory działają w praktyce, implementując system zarządzania dinozaurami w Parku Jurajskim.
Modyfikator public
Elementy oznaczone jako public są dostępne z dowolnego miejsca w kodzie - zarówno wewnątrz klasy, jak i na jej instancjach. Jest to domyślny modyfikator dostępu w TypeScript - jeśli nie określisz żadnego modyfikatora, element zostanie automatycznie oznaczony jako public.
class Dinozaur {
// Właściwości publiczne
public nazwa: string;
public gatunek: string;
public wiek: number;
constructor(nazwa: string, gatunek: string, wiek: number) {
this.nazwa = nazwa;
this.gatunek = gatunek;
this.wiek = wiek;
}
// Metoda publiczna
public wyświetlInformacje(): void {
console.log(`${this.nazwa}: ${this.gatunek}, ${this.wiek} lat`);
}
}
// Tworzenie instancji
const rex = new Dinozaur("Rex", "Tyrannosaurus", 7);
// Dostęp do publicznych właściwości i metod z zewnątrz klasy
console.log(rex.nazwa); // "Rex" - dostęp do publicznej właściwości
rex.wiek = 8; // Modyfikacja publicznej właściwości
rex.wyświetlInformacje(); // Wywołanie publicznej metodyWłaściwości i metody publiczne są jak ogólnodostępne informacje w parku - na przykład mapa parku, godziny otwarcia, czy lokalizacje toalet. Wszyscy mogą ich używać bez ograniczeń.
Modyfikator private
Elementy oznaczone jako private są dostępne tylko wewnątrz klasy, w której zostały zdefiniowane. Ta hermetyzacja pozwala na ukrycie wewnętrznych szczegółów implementacji i zapobiega przypadkowym modyfikacjom stanu z zewnątrz klasy.
class DiagnozaZdrowia {
// Właściwości prywatne
private id: string;
private wynikiBadań: Record<string, number>;
private uwagi: string;
public statusZdrowia: "zdrowy" | "chory" | "krytyczny";
constructor(id: string) {
this.id = id;
this.wynikiBadań = {};
this.uwagi = "";
this.statusZdrowia = "zdrowy";
}
// Prywatna metoda - używana tylko wewnątrz klasy
private analizujWyniki(): "zdrowy" | "chory" | "krytyczny" {
// Złożona logika analizy wyników badań
const temperaturaCiała = this.wynikiBadań["temperaturaCiała"] || 37;
const poziomLeukocytów = this.wynikiBadań["poziomLeukocytów"] || 7000;
if (temperaturaCiała > 40 || poziomLeukocytów > 15000) {
return "krytyczny";
} else if (temperaturaCiała > 38.5 || poziomLeukocytów > 11000) {
return "chory";
} else {
return "zdrowy";
}
}
// Publiczne metody korzystające z prywatnych właściwości
public dodajWynikBadania(nazwa: string, wartość: number): void {
this.wynikiBadań[nazwa] = wartość;
this.statusZdrowia = this.analizujWyniki(); // Wywołanie prywatnej metody
}
public dodajUwagę(uwaga: string): void {
this.uwagi += uwaga + "\n";
}
public pobierzRaport(): string {
return `
ID: ${this.id}
Status zdrowia: ${this.statusZdrowia}
Uwagi: ${this.uwagi || "Brak"}
`;
}
}
// Tworzenie instancji
const diagnozaRaptora = new DiagnozaZdrowia("VL-001");
// Używanie publicznego API
diagnozaRaptora.dodajWynikBadania("temperaturaCiała", 39.2);
diagnozaRaptora.dodajWynikBadania("poziomLeukocytów", 12500);
diagnozaRaptora.dodajUwagę("Objawy infekcji wirusowej");
console.log(diagnozaRaptora.statusZdrowia); // "chory" - dostęp do publicznej właściwości
console.log(diagnozaRaptora.pobierzRaport()); // Wywołanie publicznej metody
// Próba dostępu do prywatnych elementów
// console.log(diagnozaRaptora.id); // Błąd: Property 'id' is private
// console.log(diagnozaRaptora.wynikiBadań); // Błąd: Property 'wynikiBadań' is private
// diagnozaRaptora.analizujWyniki(); // Błąd: Property 'analizujWyniki' is privatePrywatne właściwości i metody są jak zastrzeżone procedury laboratorium genetycznego - tylko upoważniony personel laboratorium (metody klasy) ma do nich dostęp, a dla reszty personelu są one ukryte ze względów bezpieczeństwa.
Modyfikator protected
Elementy oznaczone jako protected są dostępne wewnątrz klasy, w której zostały zdefiniowane, oraz w klasach dziedziczących. Pozwala to na tworzenie hierarchii klas, gdzie klasy pochodne mają dostęp do chronionych elementów klasy bazowej, ale elementy te pozostają niedostępne z zewnątrz hierarchii klas.
// Klasa bazowa
class Zwierzę {
// Właściwości chronione
protected id: string;
protected gatunek: string;
protected waga: number;
protected zdrowie: number; // 0-100
constructor(id: string, gatunek: string, waga: number) {
this.id = id;
this.gatunek = gatunek;
this.waga = waga;
this.zdrowie = 100;
}
// Chroniona metoda
protected zmodyfikujZdrowie(zmiana: number): void {
this.zdrowie = Math.max(0, Math.min(100, this.zdrowie + zmiana));
}
// Publiczna metoda
public wyświetlStatus(): string {
return `${this.gatunek} (${this.id}): Waga: ${this.waga}kg, Zdrowie: ${this.zdrowie}%`;
}
}
// Klasa dziedzicząca
class Dinozaur extends Zwierzę {
public imię: string;
private poziomAgresji: number; // 0-10
constructor(id: string, gatunek: string, imię: string, waga: number) {
super(id, gatunek, waga);
this.imię = imię;
this.poziomAgresji = 5;
}
// Metoda wykorzystująca chronione elementy klasy bazowej
public nakarm(ilość: number): void {
this.zmodyfikujZdrowie(ilość * 5); // Dostęp do chronionej metody z klasy bazowej
this.poziomAgresji = Math.max(0, this.poziomAgresji - 1);
console.log(`${this.imię} został nakarmiony. Nowy poziom zdrowia: ${this.zdrowie}%`);
}
public doznajObrażeń(ilość: number): void {
this.zmodyfikujZdrowie(-ilość); // Dostęp do chronionej metody z klasy bazowej
this.poziomAgresji = Math.min(10, this.poziomAgresji + 2);
console.log(`${this.imię} doznał obrażeń. Nowy poziom zdrowia: ${this.zdrowie}%`);
}
// Nadpisanie metody bazowej z wykorzystaniem chronionych właściwości
public wyświetlStatus(): string {
return `${this.imię} (${this.gatunek}): Waga: ${this.waga}kg, Zdrowie: ${this.zdrowie}%, Agresja: ${this.poziomAgresji}/10`;
}
}
// Klasa dziedzicząca z modyfikacją chronionej właściwości
class DinozaurMorski extends Zwierzę {
private głębokośćNurkowania: number;
constructor(id: string, gatunek: string, waga: number, głębokośćNurkowania: number) {
super(id, gatunek, waga);
this.głębokośćNurkowania = głębokośćNurkowania;
// Modyfikacja chronionej właściwości w konstruktorze
this.zdrowie = 90; // Morskie dinozaury zaczynają z mniejszym zdrowiem
}
public pływaj(czas: number): void {
// Używanie chronionej metody
this.zmodyfikujZdrowie(czas > 10 ? -10 : 5);
console.log(`Dinozaur morski ${this.id} pływał przez ${czas} minut na głębokości ${this.głębokośćNurkowania}m`);
console.log(`Nowy poziom zdrowia: ${this.zdrowie}%`);
}
}
// Tworzenie instancji
const velociraptor = new Dinozaur("VL-002", "Velociraptor", "Blue", 150);
const mosasaur = new DinozaurMorski("MS-001", "Mosasaurus", 15000, 50);
// Używanie publicznych metod
velociraptor.nakarm(2);
velociraptor.doznajObrażeń(15);
console.log(velociraptor.wyświetlStatus());
mosasaur.pływaj(15);
console.log(mosasaur.wyświetlStatus());
// Próba dostępu do chronionych elementów
// console.log(velociraptor.id); // Błąd: Property 'id' is protected
// console.log(mosasaur.zdrowie); // Błąd: Property 'zdrowie' is protected
// velociraptor.zmodyfikujZdrowie(50); // Błąd: Property 'zmodyfikujZdrowie' is protectedChronione właściwości i metody są jak procedury bezpieczeństwa parku - dostęp do nich mają tylko upoważnieni pracownicy i ich podwładni (klasa bazowa i klasy dziedziczące), ale nie goście parku (kod zewnętrzny).
Konstruktor i modyfikatory dostępu
TypeScript oferuje specjalną składnię dla konstruktorów, która pozwala na bezpośrednie deklarowanie właściwości z modyfikatorami dostępu w parametrach konstruktora. Jest to skrótowy zapis, który pozwala uniknąć powtarzania kodu.
// Tradycyjny zapis
class PracownikParku {
private id: string;
public imię: string;
public nazwisko: string;
protected poziomDostępu: number;
constructor(id: string, imię: string, nazwisko: string, poziomDostępu: number) {
this.id = id;
this.imię = imię;
this.nazwisko = nazwisko;
this.poziomDostępu = poziomDostępu;
}
}
// Skrócony zapis z modyfikatorami w parametrach konstruktora
class PracownikParkuSkrócony {
constructor(
private id: string,
public imię: string,
public nazwisko: string,
protected poziomDostępu: number
) {} // Puste ciało konstruktora - wszystko już zostało zainicjalizowane
}
// Oba zapisy działają identycznie
const pracownik1 = new PracownikParku("EMP-001", "John", "Hammond", 10);
const pracownik2 = new PracownikParkuSkrócony("EMP-002", "Ellie", "Sattler", 8);
console.log(pracownik1.imię, pracownik1.nazwisko); // "John Hammond"
console.log(pracownik2.imię, pracownik2.nazwisko); // "Ellie Sattler"
// console.log(pracownik1.id); // Błąd: Property 'id' is private
// console.log(pracownik2.id); // Błąd: Property 'id' is privateTa skrócona składnia jest szczególnie przydatna w prostych klasach z wieloma właściwościami, ponieważ redukuje ilość powtarzającego się kodu.
Hermetyzacja i wzorzec dostępowy (gettery i settery)
Jednym z głównych powodów stosowania modyfikatorów dostępu jest hermetyzacja - ukrywanie szczegółów implementacji i udostępnianie tylko kontrolowanego interfejsu do interakcji z klasą. Częścią tego podejścia jest stosowanie getterów i setterów - specjalnych metod kontrolujących dostęp do właściwości.
class EnclosureSecurity {
// Prywatne właściwości
private _statusOgrodzenia: "aktywne" | "nieaktywne" | "w_naprawie";
private _poziomNaładowaniaBaterii: number; // 0-100
private _ostatniaPrzegląd: Date;
private _logZdarzeń: string[];
constructor() {
this._statusOgrodzenia = "aktywne";
this._poziomNaładowaniaBaterii = 100;
this._ostatniaPrzegląd = new Date();
this._logZdarzeń = ["System uruchomiony: " + new Date().toISOString()];
}
// Gettery - kontrolowany dostęp do odczytu prywatnych właściwości
get statusOgrodzenia(): "aktywne" | "nieaktywne" | "w_naprawie" {
this.dodajLog("Odczytano status ogrodzenia");
return this._statusOgrodzenia;
}
get poziomNaładowaniaBaterii(): number {
this.dodajLog("Odczytano poziom naładowania baterii");
return this._poziomNaładowaniaBaterii;
}
get ostatniaPrzegląd(): Date {
return new Date(this._ostatniaPrzegląd.getTime()); // Defensywna kopia
}
get raportBezpieczeństwa(): string {
this.dodajLog("Wygenerowano raport bezpieczeństwa");
return `
Status ogrodzenia: ${this._statusOgrodzenia}
Poziom naładowania baterii: ${this._poziomNaładowaniaBaterii}%
Ostatni przegląd: ${this._ostatniaPrzegląd.toLocaleDateString()}
Liczba zdarzeń w logu: ${this._logZdarzeń.length}
`;
}
// Settery - kontrolowany dostęp do modyfikacji prywatnych właściwości
set statusOgrodzenia(nowyStatus: "aktywne" | "nieaktywne" | "w_naprawie") {
this.dodajLog(`Zmieniono status ogrodzenia z ${this._statusOgrodzenia} na ${nowyStatus}`);
this._statusOgrodzenia = nowyStatus;
if (nowyStatus === "nieaktywne") {
this.uruchomProcedurySecurity();
}
}
// Ten setter zawiera logikę walidacyjną
set poziomNaładowaniaBaterii(nowyPoziom: number) {
if (nowyPoziom < 0 || nowyPoziom > 100) {
throw new Error("Poziom naładowania baterii musi być między 0 a 100");
}
const staraWartość = this._poziomNaładowaniaBaterii;
this._poziomNaładowaniaBaterii = nowyPoziom;
this.dodajLog(`Zmieniono poziom naładowania baterii z ${staraWartość}% na ${nowyPoziom}%`);
if (nowyPoziom < 20) {
this.dodajLog("UWAGA: Niski poziom baterii!");
}
}
// Prywatna metoda pomocnicza
private dodajLog(wiadomość: string): void {
this._logZdarzeń.push(`${new Date().toISOString()}: ${wiadomość}`);
}
// Prywatna metoda biznesowa
private uruchomProcedurySecurity(): void {
this.dodajLog("ALERT: Uruchomiono procedury awaryjne!");
// Logika obsługi sytuacji awaryjnej
}
// Publiczna metoda
public przeprowadźPrzegląd(): void {
this._ostatniaPrzegląd = new Date();
this.dodajLog("Przeprowadzono przegląd ogrodzenia");
this._poziomNaładowaniaBaterii = 100;
this._statusOgrodzenia = "aktywne";
}
// Publiczna metoda
public pobierzLogZdarzeń(): string[] {
// Zwracamy kopię, aby uniemożliwić modyfikację oryginalnego logu
return [...this._logZdarzeń];
}
}
// Użycie klasy
const security = new EnclosureSecurity();
// Używanie getterów
console.log("Status ogrodzenia:", security.statusOgrodzenia);
console.log("Poziom baterii:", security.poziomNaładowaniaBaterii);
// Używanie setterów
security.statusOgrodzenia = "w_naprawie";
security.poziomNaładowaniaBaterii = 85;
// Używanie publicznych metod
security.przeprowadźPrzegląd();
// Próba ustawienia nieprawidłowej wartości
try {
security.poziomNaładowaniaBaterii = 110; // Wywoła błąd
} catch (e) {
console.error(e.message);
}
// Odczyt raportu i logów
console.log(security.raportBezpieczeństwa);
console.log("Historia zdarzeń:");
security.pobierzLogZdarzeń().forEach((log, i) => {
console.log(`${i + 1}. ${log}`);
});Używanie getterów i setterów pozwala na większą kontrolę nad dostępem do danych:
- Możemy dodać logikę walidacji przed zmianą wartości
- Możemy wykonać dodatkowe operacje przy dostępie do danych
- Możemy zwracać defensywne kopie obiektów, aby zapobiec przypadkowym modyfikacjom
- Możemy logować dostęp do danych
Praktyczny przykład: System zarządzania dinozaurami
Poniżej przedstawiamy kompleksowy przykład systemu zarządzania dinozaurami, który wykorzystuje wszystkie omówione modyfikatory dostępu dla stworzenia dobrze zorganizowanej architektury obiektowej:
// Typy i interfejsy
type StatusDinozaura = "zdrowy" | "chory" | "w leczeniu" | "uśpiony" | "zmarły";
type TypDiety = "mięsożerny" | "roślinożerny" | "wszystkożerny";
interface IMonitorowania {
rozpocznijMonitorowanie(): void;
zakończMonitorowanie(): void;
pobierzStatusMonitorowania(): string;
}
// Abstrakcyjna klasa bazowa
abstract class ZwierzęParku {
// Właściwości z różnymi modyfikatorami dostępu
private _id: string;
protected _gatunek: string;
protected _wiek: number;
protected _waga: number;
protected _status: StatusDinozaura;
private _dataUtworzenia: Date;
private _ostatniaAktualizacja: Date;
constructor(id: string, gatunek: string, wiek: number, waga: number) {
this._id = id;
this._gatunek = gatunek;
this._wiek = wiek;
this._waga = waga;
this._status = "zdrowy";
this._dataUtworzenia = new Date();
this._ostatniaAktualizacja = new Date();
}
// Gettery
get id(): string {
return this._id;
}
get gatunek(): string {
return this._gatunek;
}
get wiek(): number {
return this._wiek;
}
get waga(): number {
return this._waga;
}
get status(): StatusDinozaura {
return this._status;
}
// Setter ze sprawdzeniem wartości i aktualizacją daty
set status(nowyStatus: StatusDinozaura) {
if (this._status !== nowyStatus) {
this._status = nowyStatus;
this._ostatniaAktualizacja = new Date();
this.logZmianyStatusu(nowyStatus);
}
}
// Chroniona metoda dostępna dla klas dziedziczących
protected aktualizujWagę(nowaWaga: number): void {
if (nowaWaga > 0) {
this._waga = nowaWaga;
this._ostatniaAktualizacja = new Date();
} else {
throw new Error("Waga musi być większa od zera.");
}
}
// Prywatna metoda dostępna tylko wewnątrz tej klasy
private logZmianyStatusu(nowyStatus: StatusDinozaura): void {
console.log(`[${new Date().toISOString()}] Zmiana statusu ${this._id}: ${nowyStatus}`);
}
// Abstrakcyjna metoda - każda klasa dziedzicząca musi ją zaimplementować
abstract pobierzOpisKliniczny(): string;
// Publiczna metoda
public pobierzPodstawoweDane(): string {
return `ID: ${this._id} | Gatunek: ${this._gatunek} | Wiek: ${this._wiek} lat | Waga: ${this._waga} kg | Status: ${this._status}`;
}
}
// Klasa dziedzicząca
class Dinozaur extends ZwierzęParku implements IMonitorowania {
// Prywatne właściwości specyficzne dla dinozaurów
private _dieta: TypDiety;
private _poziomAgresji: number; // 1-10
private _czyMonitorowany: boolean;
private _ostatniPosiłek: Date | null;
private _przypisanyWybieg: string | null;
constructor(
id: string,
gatunek: string,
wiek: number,
waga: number,
dieta: TypDiety,
poziomAgresji: number
) {
super(id, gatunek, wiek, waga);
this._dieta = dieta;
this._poziomAgresji = this.walidujPoziomAgresji(poziomAgresji);
this._czyMonitorowany = false;
this._ostatniPosiłek = null;
this._przypisanyWybieg = null;
}
// Implementacja metody abstrakcyjnej
pobierzOpisKliniczny(): string {
let opis = `Dinozaur ${this.gatunek} (ID: ${this.id})\n`;
opis += `Status zdrowotny: ${this.status}\n`;
opis += `Wiek: ${this.wiek} lat, Waga: ${this.waga} kg\n`;
opis += `Dieta: ${this._dieta}\n`;
opis += `Poziom agresji: ${this._poziomAgresji}/10\n`;
opis += `Ostatni posiłek: ${this._ostatniPosiłek ? this._ostatniPosiłek.toLocaleString() : "Brak danych"}\n`;
return opis;
}
// Implementacja interfejsu IMonitorowania
rozpocznijMonitorowanie(): void {
this._czyMonitorowany = true;
console.log(`Rozpoczęto monitorowanie dinozaura ${this.id}`);
}
zakończMonitorowanie(): void {
this._czyMonitorowany = false;
console.log(`Zakończono monitorowanie dinozaura ${this.id}`);
}
pobierzStatusMonitorowania(): string {
return this._czyMonitorowany ? "Aktywny" : "Nieaktywny";
}
// Publiczne metody specyficzne dla dinozaurów
public nakarm(ilość: number): void {
if (ilość <= 0) {
throw new Error("Ilość pokarmu musi być większa od zera.");
}
const przyrostWagi = this._dieta === "mięsożerny" ? ilość * 0.3 : ilość * 0.2;
this.aktualizujWagę(this.waga + przyrostWagi);
this._ostatniPosiłek = new Date();
this._poziomAgresji = this.walidujPoziomAgresji(this._poziomAgresji - 1);
console.log(`Dinozaur ${this.id} został nakarmiony. Nowa waga: ${this.waga} kg`);
}
public przydzielDoWybiegu(kodWybiegu: string): void {
this._przypisanyWybieg = kodWybiegu;
console.log(`Dinozaur ${this.id} został przydzielony do wybiegu ${kodWybiegu}`);
}
public uśpij(): void {
this.status = "uśpiony";
this._poziomAgresji = 1;
console.log(`Dinozaur ${this.id} został uśpiony`);
}
public obudź(): void {
if (this.status === "uśpiony") {
this.status = "zdrowy";
this._poziomAgresji = this.walidujPoziomAgresji(this._poziomAgresji + 2);
console.log(`Dinozaur ${this.id} został obudzony`);
}
}
// Gettery i settery
get dieta(): TypDiety {
return this._dieta;
}
get poziomAgresji(): number {
return this._poziomAgresji;
}
get ostatniPosiłek(): Date | null {
return this._ostatniPosiłek ? new Date(this._ostatniPosiłek.getTime()) : null;
}
get przypisanyWybieg(): string | null {
return this._przypisanyWybieg;
}
set poziomAgresji(poziom: number) {
this._poziomAgresji = this.walidujPoziomAgresji(poziom);
}
// Prywatna metoda pomocnicza
private walidujPoziomAgresji(poziom: number): number {
return Math.max(1, Math.min(10, poziom));
}
}
// Użycie systemu
function testSystemuZarządzaniaDinozaurami() {
// Tworzenie dinozaurów
const trex = new Dinozaur("T-REX-01", "Tyrannosaurus Rex", 8, 7500, "mięsożerny", 9);
const stegozaur = new Dinozaur("STEG-01", "Stegosaurus", 12, 5000, "roślinożerny", 4);
// Wyświetlanie podstawowych informacji
console.log("=== DANE PODSTAWOWE ===");
console.log(trex.pobierzPodstawoweDane());
console.log(stegozaur.pobierzPodstawoweDane());
// Operacje na dinozaurach
trex.nakarm(50);
trex.przydzielDoWybiegu("CARNIVORE-A");
trex.rozpocznijMonitorowanie();
stegozaur.nakarm(80);
stegozaur.przydzielDoWybiegu("HERBIVORE-B");
// Zmiana statusu
trex.status = "w leczeniu";
stegozaur.uśpij();
// Pobieranie raportów klinicznych
console.log("\n=== RAPORTY KLINICZNE ===");
console.log(trex.pobierzOpisKliniczny());
console.log(stegozaur.pobierzOpisKliniczny());
// Status monitorowania
console.log("\n=== STATUS MONITOROWANIA ===");
console.log(`T-Rex monitoring: ${trex.pobierzStatusMonitorowania()}`);
console.log(`Stegozaur monitoring: ${stegozaur.pobierzStatusMonitorowania()}`);
// Próba dostępu do prywatnych/chronionych elementów
// Poniższe linie spowodowałyby błąd kompilacji:
// console.log(trex._id); // Błąd: Property '_id' is private
// console.log(trex._gatunek); // Błąd: Property '_gatunek' is protected
// trex.logZmianyStatusu("zdrowy"); // Błąd: Property 'logZmianyStatusu' is private
// trex.walidujPoziomAgresji(5); // Błąd: Property 'walidujPoziomAgresji' is private
}
// Uruchomienie testu
testSystemuZarządzaniaDinozaurami();W powyższym przykładzie:
- Abstrakcyjna klasa bazowa (ZwierzęParku) definiuje wspólne właściwości i zachowania dla wszystkich zwierząt w parku
- Prywatne właściwości (_id, _dataUtworzenia, _ostatniaAktualizacja) są dostępne tylko wewnątrz klasy
- Chronione właściwości (_gatunek, _wiek, _waga, _status) są dostępne w klasie bazowej i klasach dziedziczących
- Publiczne gettery i settery zapewniają kontrolowany dostęp do właściwości
- Prywatne metody (logZmianyStatusu, walidujPoziomAgresji) są używane jako pomocnicze implementacje dostępne tylko wewnątrz klasy
- Chronione metody (aktualizujWagę) są dostępne dla klas dziedziczących
- Abstrakcyjna metoda (pobierzOpisKliniczny) wymusza implementację w klasach dziedziczących
- Interface (IMonitorowania) definiuje kontrakt, który klasa Dinozaur musi implementować
Kiedy i jak stosować modyfikatory dostępu
Wybór odpowiedniego modyfikatora dostępu zależy od konkretnego przypadku użycia, ale istnieje kilka ogólnych zasad:
Używaj private dla:
- Wewnętrznych szczegółów implementacji
- Danych, które nigdy nie powinny być dostępne poza klasą
- Metod pomocniczych, które nie są częścią publicznego API
- Właściwości, które muszą być modyfikowane tylko przez kontrolowane settery
Używaj protected dla:
- Właściwości i metod, które muszą być dostępne w klasach dziedziczących
- Implementacji, które mogą być rozszerzone lub nadpisane w klasach pochodnych
- Danych, które są wspólne dla całej hierarchii klas, ale nie powinny być dostępne z zewnątrz
Używaj public dla:
- Elementów, które tworzą publiczny interfejs API klasy
- Metod, które muszą być dostępne dla wszystkich użytkowników klasy
- Właściwości, które mogą być bezpiecznie odczytywane lub modyfikowane z zewnątrz
Podsumowanie
Modyfikatory dostępu w TypeScript są kluczowym narzędziem do implementacji zasad dobrego projektowania obiektowego, takich jak enkapsulacja, dziedziczenie i polimorfizm. Pozwalają na precyzyjną kontrolę dostępu do właściwości i metod klas, co sprzyja tworzeniu bezpiecznego, modularnego i łatwego w utrzymaniu kodu.
Podobnie jak w Parku Jurajskim, gdzie system bezpieczeństwa wymaga różnych poziomów dostępu, dobrze zaprojektowany system obiektowy wykorzystuje modyfikatory dostępu, aby zapewnić, że każdy element jest dostępny tylko dla tych, którzy rzeczywiście powinni mieć do niego dostęp.
John Hammond podsumowałby to krótko: "W Parku Jurajskim i w programowaniu - bezpieczeństwo jest najważniejsze. Modyfikatory dostępu są jak strefy bezpieczeństwa w parku - publiczne dla wszystkich, chronione dla specjalistów, a prywatne tylko dla najwyższego szczebla zarządzania. To klucz do utrzymania porządku i zapobiegania... niespodziankom."
Kod do tej lekcji: index.ts
// Modyfikatory dostępu w TypeScript - Park Jurajski
console.log("System bezpieczeństwa Parku Jurajskiego");
console.log("Demonstracja modyfikatorów dostępu: public, private, protected\n");
// ===========================================
// 1. Podstawowe modyfikatory dostępu
// ===========================================
console.log("=== 1. MODYFIKATORY DOSTĘPU ===");
class BasicDinosaur {
// public - dostępne z każdego miejsca (domyślnie)
public name: string;
public species: string;
// private - dostępne tylko w tej klasie
private dnaSequence: string;
private securityCode: number;
// protected - dostępne w tej klasie i klasach dziedziczących
protected age: number;
protected habitat: string;
constructor(name: string, species: string, dnaSequence: string) {
this.name = name;
this.species = species;
this.dnaSequence = dnaSequence;
this.securityCode = Math.floor(Math.random() * 10000);
this.age = 0;
this.habitat = "Enclosure";
}
// Publiczna metoda
public getBasicInfo(): string {
return `${this.name} (${this.species})`;
}
// Prywatna metoda
private validateDNA(): boolean {
return this.dnaSequence.length > 10;
}
// Chroniona metoda
protected calculateMaturity(): string {
if (this.age < 5) return "Młody";
if (this.age < 15) return "Dorosły";
return "Stary";
}
// Publiczny dostęp do prywatnej funkcjonalności
public isDNAValid(): boolean {
return this.validateDNA();
}
// Metoda z kontrolowanym dostępem do prywatnych danych
public getSecureInfo(accessCode: number): string | null {
if (accessCode === this.securityCode) {
return `DNA: ${this.dnaSequence.substring(0, 5)}...`;
}
return null;
}
}
const basicDino = new BasicDinosaur("Rex", "T-Rex", "ATCGATCGATCG");
console.log("Podstawowe info:", basicDino.getBasicInfo());
console.log("Publiczne pola:");
console.log(" Name:", basicDino.name);
console.log(" Species:", basicDino.species);
console.log("DNA valid:", basicDino.isDNAValid());
// Te nie zadziałają - błędy kompilacji w TypeScript:
// console.log(basicDino.dnaSequence); // Error: private
// console.log(basicDino.age); // Error: protected
// basicDino.validateDNA(); // Error: private method
console.log("\n");
// ===========================================
// 2. Dziedziczenie i modyfikatory
// ===========================================
console.log("=== 2. DZIEDZICZENIE I MODYFIKATORY ===");
class CarnivorousDinosaur extends BasicDinosaur {
private huntingExperience: number;
protected packSize: number;
constructor(name: string, species: string, dnaSequence: string) {
super(name, species, dnaSequence);
this.huntingExperience = 0;
this.packSize = 1;
}
// Dostęp do protected pól z klasy bazowej
public setAge(newAge: number): void {
this.age = newAge; // OK - protected w klasie bazowej
console.log(`${this.name} ma teraz ${this.age} lat`);
}
public getMaturityStatus(): string {
// Dostęp do protected metody z klasy bazowej
return `${this.name} jest ${this.calculateMaturity()}`;
}
// Nadpisanie protected metody
protected calculateMaturity(): string {
const baseMaturity = super.calculateMaturity();
const huntingLevel = this.huntingExperience > 10 ? "Doświadczony łowca" : "Początkujący";
return `${baseMaturity} - ${huntingLevel}`;
}
public hunt(): string {
this.huntingExperience++;
return `${this.name} poluje! Doświadczenie: ${this.huntingExperience}`;
}
// Nie można uzyskać dostępu do private pól z klasy bazowej
// public getDNA(): string {
// return this.dnaSequence; // Error: private in base class
// }
}
const carnivoreDino = new CarnivorousDinosaur("Blue", "Velociraptor", "GCTAGCTAGCTA");
carnivoreDino.setAge(8);
console.log("Status dojrzałości:", carnivoreDino.getMaturityStatus());
console.log("Polowanie:", carnivoreDino.hunt());
console.log("\n");
// ===========================================
// 3. Enkapsulacja danych wrażliwych
// ===========================================
console.log("=== 3. ENKAPSULACJA DANYCH WRAŻLIWYCH ===");
class SecureDinosaur {
public readonly id: string;
public name: string;
private dnaSequence: string;
private medicalHistory: string[];
private behaviorPatterns: Map<string, number>;
protected enclosureAccess: boolean;
protected emergencyProtocols: string[];
constructor(id: string, name: string, dna: string) {
this.id = id;
this.name = name;
this.dnaSequence = dna;
this.medicalHistory = [];
this.behaviorPatterns = new Map();
this.enclosureAccess = true;
this.emergencyProtocols = ["Tranquilizer", "Emergency Lock"];
}
// Kontrolowany dostęp do danych medycznych
public addMedicalRecord(record: string, veterinarianCode: string): boolean {
if (this.validateVeterinarianAccess(veterinarianCode)) {
this.medicalHistory.push(`[${new Date().toISOString()}] ${record}`);
return true;
}
console.log("Unauthorized access to medical records");
return false;
}
public getMedicalHistory(veterinarianCode: string): string[] | null {
if (this.validateVeterinarianAccess(veterinarianCode)) {
return [...this.medicalHistory]; // Kopia, nie referencja
}
console.log("Unauthorized access to medical records");
return null;
}
// Kontrolowany dostęp do wzorców zachowań
public updateBehaviorPattern(pattern: string, intensity: number, researcherCode: string): boolean {
if (this.validateResearcherAccess(researcherCode)) {
this.behaviorPatterns.set(pattern, intensity);
console.log(`Behavior pattern '${pattern}' updated to ${intensity}`);
return true;
}
console.log("Unauthorized access to behavior data");
return false;
}
public getBehaviorAnalysis(researcherCode: string): string | null {
if (this.validateResearcherAccess(researcherCode)) {
const patterns = Array.from(this.behaviorPatterns.entries());
return patterns.map(([pattern, intensity]) => `${pattern}: ${intensity}`).join(", ");
}
console.log("Unauthorized access to behavior data");
return null;
}
// Prywatne metody walidacji
private validateVeterinarianAccess(code: string): boolean {
return code === "VET-2023";
}
private validateResearcherAccess(code: string): boolean {
return code === "RESEARCH-2023";
}
// Publiczne metody bezpieczeństwa
public getPublicInfo(): object {
return {
id: this.id,
name: this.name,
hasAccess: this.enclosureAccess,
lastUpdate: new Date().toISOString()
};
}
}
const secureDino = new SecureDinosaur("SEC-001", "Alpha", "CLASSIFIED-DNA");
console.log("Publiczne info:", secureDino.getPublicInfo());
// Test kontroli dostępu
console.log("\nTest dostępu weterynaryjnego:");
secureDino.addMedicalRecord("Rutynowe badanie", "VET-2023"); // Autoryzowany
secureDino.addMedicalRecord("Szczepienie", "FAKE-CODE"); // Nieautoryzowany
console.log("\nTest dostępu badawczego:");
secureDino.updateBehaviorPattern("Agresja", 7, "RESEARCH-2023"); // Autoryzowany
secureDino.updateBehaviorPattern("Spokój", 3, "HACKER-CODE"); // Nieautoryzowany
console.log("\n");
// ===========================================
// 4. Wzorzec Builder z modyfikatorami dostępu
// ===========================================
console.log("=== 4. WZORZEC BUILDER Z MODYFIKATORAMI ===");
class DinosaurBuilder {
private dinosaur: {
name?: string;
species?: string;
diet?: string;
weight?: number;
dangerLevel?: number;
};
constructor() {
this.dinosaur = {};
}
public setName(name: string): DinosaurBuilder {
this.dinosaur.name = name;
return this;
}
public setSpecies(species: string): DinosaurBuilder {
this.dinosaur.species = species;
return this;
}
public setDiet(diet: string): DinosaurBuilder {
this.dinosaur.diet = diet;
return this;
}
public setWeight(weight: number): DinosaurBuilder {
this.dinosaur.weight = weight;
return this;
}
public setDangerLevel(level: number): DinosaurBuilder {
this.dinosaur.dangerLevel = level;
return this;
}
// Prywatna walidacja
private validateDinosaur(): boolean {
const required = ['name', 'species', 'diet', 'weight', 'dangerLevel'];
return required.every(field => this.dinosaur[field as keyof typeof this.dinosaur] !== undefined);
}
public build(): CompleteDinosaur | null {
if (!this.validateDinosaur()) {
console.log("Validation failed - missing required fields");
return null;
}
return new CompleteDinosaur(
this.dinosaur.name!,
this.dinosaur.species!,
this.dinosaur.diet!,
this.dinosaur.weight!,
this.dinosaur.dangerLevel!
);
}
}
class CompleteDinosaur {
public readonly name: string;
public readonly species: string;
private readonly diet: string;
private readonly weight: number;
private readonly dangerLevel: number;
constructor(name: string, species: string, diet: string, weight: number, dangerLevel: number) {
this.name = name;
this.species = species;
this.diet = diet;
this.weight = weight;
this.dangerLevel = dangerLevel;
}
public getPublicProfile(): object {
return {
name: this.name,
species: this.species
};
}
public getDetailedInfo(securityClearance: number): object | null {
if (securityClearance >= this.dangerLevel) {
return {
name: this.name,
species: this.species,
diet: this.diet,
weight: this.weight,
dangerLevel: this.dangerLevel
};
}
console.log(`Insufficient security clearance. Required: ${this.dangerLevel}, Provided: ${securityClearance}`);
return null;
}
}
// Użycie Builder pattern
const builder = new DinosaurBuilder();
const completeDino = builder
.setName("Indominus Rex")
.setSpecies("Indominus Rex")
.setDiet("carnivore")
.setWeight(5500)
.setDangerLevel(10)
.build();
if (completeDino) {
console.log("Publiczny profil:", completeDino.getPublicProfile());
console.log("\nPróba dostępu z clearance 5:", completeDino.getDetailedInfo(5));
console.log("Próba dostępu z clearance 10:", completeDino.getDetailedInfo(10));
}
console.log("\n");
// ===========================================
// 5. System uprawnień i ról
// ===========================================
console.log("=== 5. SYSTEM UPRAWNIEŃ I RÓL ===");
enum UserRole {
Visitor = 1,
Staff = 2,
Veterinarian = 3,
Researcher = 4,
Security = 5,
Administrator = 6
}
abstract class ParkUser {
protected name: string;
protected role: UserRole;
protected accessLevel: number;
constructor(name: string, role: UserRole) {
this.name = name;
this.role = role;
this.accessLevel = role;
}
public getName(): string {
return this.name;
}
public getRole(): string {
return UserRole[this.role];
}
// Abstract metoda - musi być zaimplementowana w klasach pochodnych
public abstract canAccess(resource: string): boolean;
protected hasMinimumAccess(requiredLevel: number): boolean {
return this.accessLevel >= requiredLevel;
}
}
class ParkStaff extends ParkUser {
private department: string;
constructor(name: string, role: UserRole, department: string) {
super(name, role);
this.department = department;
}
public canAccess(resource: string): boolean {
const resourcePermissions: { [key: string]: number } = {
"public_areas": UserRole.Visitor,
"staff_rooms": UserRole.Staff,
"dinosaur_basic_info": UserRole.Staff,
"medical_records": UserRole.Veterinarian,
"research_data": UserRole.Researcher,
"security_systems": UserRole.Security,
"admin_panel": UserRole.Administrator
};
const requiredLevel = resourcePermissions[resource];
if (requiredLevel === undefined) {
console.log(`Unknown resource: ${resource}`);
return false;
}
const hasAccess = this.hasMinimumAccess(requiredLevel);
console.log(`${this.name} (${this.getRole()}) accessing ${resource}: ${hasAccess ? 'GRANTED' : 'DENIED'}`);
return hasAccess;
}
public getDepartment(): string {
return this.department;
}
}
// Test systemu uprawnień
const visitor = new ParkStaff("John Doe", UserRole.Visitor, "Tourist");
const veterinarian = new ParkStaff("Dr. Sarah Connor", UserRole.Veterinarian, "Medical");
const researcher = new ParkStaff("Dr. Alan Grant", UserRole.Researcher, "Paleontology");
const admin = new ParkStaff("Robert Muldoon", UserRole.Administrator, "Operations");
console.log("\nTest kontroli dostępu:");
const resources = ["public_areas", "dinosaur_basic_info", "medical_records", "research_data", "admin_panel"];
const users = [visitor, veterinarian, researcher, admin];
users.forEach(user => {
console.log(`\n${user.getName()} (${user.getRole()}):`);
resources.forEach(resource => {
user.canAccess(resource);
});
});
console.log("\n");
// ===========================================
// 6. Gettery i settery z kontrolą dostępu
// ===========================================
console.log("=== 6. GETTERY I SETTERY Z KONTROLĄ DOSTĘPU ===");
class MonitoredDinosaur {
private _name: string;
private _health: number;
private _feedingSchedule: Date[];
private _isQuarantined: boolean;
private _lastHealthCheck: Date;
constructor(name: string) {
this._name = name;
this._health = 100;
this._feedingSchedule = [];
this._isQuarantined = false;
this._lastHealthCheck = new Date();
}
// Getter z logowaniem dostępu
get name(): string {
console.log(`Access logged: Reading name of ${this._name}`);
return this._name;
}
// Getter z walidacją uprawnień
get health(): number {
console.log(`Health data accessed for ${this._name}`);
return this._health;
}
// Setter z walidacją
set health(value: number) {
if (value < 0 || value > 100) {
console.log(`Invalid health value: ${value}. Must be 0-100`);
return;
}
const oldHealth = this._health;
this._health = value;
this._lastHealthCheck = new Date();
console.log(`Health updated for ${this._name}: ${oldHealth} → ${value}`);
// Automatyczna kwarantanna przy niskim zdrowiu
if (value < 30 && !this._isQuarantined) {
this._isQuarantined = true;
console.log(`${this._name} automatically quarantined due to low health`);
}
}
// Computed property
get status(): string {
if (this._isQuarantined) return "Quarantined";
if (this._health < 30) return "Critical";
if (this._health < 60) return "Poor";
if (this._health < 80) return "Good";
return "Excellent";
}
// Setter z business logic
set isQuarantined(value: boolean) {
if (value !== this._isQuarantined) {
this._isQuarantined = value;
console.log(`${this._name} quarantine status: ${value ? 'ACTIVE' : 'INACTIVE'}`);
if (!value && this._health < 50) {
console.log(`Warning: Releasing ${this._name} from quarantine with health ${this._health}`);
}
}
}
get isQuarantined(): boolean {
return this._isQuarantined;
}
// Metoda z kontrolowanym dostępem do historii
public getFeedingHistory(accessLevel: number): Date[] | null {
if (accessLevel < UserRole.Staff) {
console.log(`Insufficient access to feeding history`);
return null;
}
return [...this._feedingSchedule];
}
public scheduleFeed(time: Date): void {
this._feedingSchedule.push(time);
console.log(`Feeding scheduled for ${this._name} at ${time.toLocaleTimeString()}`);
}
}
const monitoredDino = new MonitoredDinosaur("Alpha-7");
console.log("\nTest monitorowanego dinozaura:");
console.log("Name:", monitoredDino.name);
console.log("Initial health:", monitoredDino.health);
console.log("Initial status:", monitoredDino.status);
// Test setterów
monitoredDino.health = 25; // Automatyczna kwarantanna
console.log("Status after health drop:", monitoredDino.status);
monitoredDino.health = 85; // Poprawa zdrowia
console.log("Status after recovery:", monitoredDino.status);
monitoredDino.isQuarantined = false; // Ręczne zwolnienie z kwarantanny
// Test planowania karmienia
monitoredDino.scheduleFeed(new Date(Date.now() + 3600000)); // Za godzinę
console.log("\n");
// ===========================================
// 7. Podsumowanie modyfikatorów dostępu
// ===========================================
console.log("=== 7. PODSUMOWANIE MODYFIKATORÓW DOSTĘPU ===");
console.log("PUBLIC:");
console.log(" • Dostępne z każdego miejsca");
console.log(" • Domyślny modyfikator w TypeScript");
console.log(" • Używaj do API publicznego klasy\n");
console.log("PRIVATE:");
console.log(" • Dostępne tylko w tej samej klasie");
console.log(" • Enkapsulacja implementacji");
console.log(" • Ochrona danych wrażliwych\n");
console.log("PROTECTED:");
console.log(" • Dostępne w klasie i klasach dziedziczących");
console.log(" • Współdzielenie między hierarchią klas");
console.log(" • Kontrolowany dostęp w dziedziczeniu\n");
console.log("READONLY:");
console.log(" • Można przypisać tylko w konstruktorze");
console.log(" • Ochrona przed modyfikacją");
console.log(" • Immutable fields\n");
console.log("Modyfikatory dostępu zapewniają bezpieczeństwo w Parku Jurajskim!");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. Który modyfikator dostępu w TypeScript pozwala na dostęp do właściwości tylko wewnątrz klasy i jej klas pochodnych?