Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Własne klasy błędów
W tej lekcji9
Witaj ponownie w Parku Jurajskim! W poprzednich ćwiczeniach poznaliśmy różne rodzaje błędów występujących w JavaScript oraz podstawy ich obsługi za pomocą try...catch...finally. Teraz zagłębimy się w tworzenie własnych, niestandardowych klas błędów, które są nieocenione w dużych aplikacjach - takich jak systemy zarządzania parkiem pełnym prehistorycznych gadów.
Dlaczego własne klasy błędów?
W złożonych systemach, takich jak Park Jurajski, potrzebujemy precyzyjnej kategoryzacji problemów. Nie wystarczy wiedzieć, że "coś poszło nie tak" - musimy wiedzieć dokładnie, co się stało, gdzie, i jak na to zareagować.
Własne klasy błędów pozwalają na:
- Precyzyjne kategoryzowanie różnych typów problemów
- Dołączanie dodatkowych danych kontekstowych do błędów
- Implementację własnych metod pomocniczych
- Łatwiejsze filtrowanie i obsługę specyficznych przypadków
To jak różnica między ogólnym alarmem w parku a precyzyjnym komunikatem: "Velociraptory wydostały się z wybiegu B6, ostatnio widziane zmierzające w kierunku centrum dla zwiedzających".
Podstawy tworzenia własnych klas błędów
W JavaScript wszystkie błędy dziedziczą z bazowej klasy Error. Nasze własne klasy błędów powinny również dziedziczyć z Error lub jednej z jej podklas.
Prosty przykład własnej klasy błędu
class DinosaurError extends Error {
constructor(message) {
super(message); // Wywołanie konstruktora klasy nadrzędnej
this.name = 'DinosaurError'; // Nadpisanie nazwy błędu
}
}
// Użycie
try {
throw new DinosaurError('Nieoczekiwane zachowanie T-Rexa');
} catch (error) {
console.log(error.name); // 'DinosaurError'
console.log(error.message); // 'Nieoczekiwane zachowanie T-Rexa'
}Dodawanie dodatkowych właściwości do błędów
Największą zaletą własnych klas błędów jest możliwość dodania dodatkowych właściwości z kontekstem:
class EnclosureBreachError extends Error {
constructor(message, dinosaurSpecies, location, dangerLevel) {
super(message);
this.name = 'EnclosureBreachError';
this.dinosaurSpecies = dinosaurSpecies;
this.location = location;
this.dangerLevel = dangerLevel;
this.timestamp = new Date();
}
getEmergencyMessage() {
return `UWAGA! ${this.dinosaurSpecies} wydostał się z wybiegu w lokalizacji ${this.location}.
Poziom zagrożenia: ${this.dangerLevel}/10.
Czas zdarzenia: ${this.timestamp.toLocaleTimeString()}`;
}
}
// Użycie
try {
throw new EnclosureBreachError(
'Naruszenie zabezpieczeń wybiegu',
'Velociraptor',
'Sektor B6',
9
);
} catch (error) {
if (error instanceof EnclosureBreachError) {
console.error(error.getEmergencyMessage());
// Uruchomienie odpowiednich procedur awaryjnych zależnie od poziomu zagrożenia
if (error.dangerLevel >= 8) {
evacuateSector(error.location);
dispatchSecurityTeam(error.location, error.dinosaurSpecies);
}
}
}Hierarchia klas błędów
W dużych aplikacjach, takich jak system zarządzania Parkiem Jurajskim, warto stworzyć hierarchię klas błędów:
// Bazowa klasa błędu specyficzna dla aplikacji
class JurassicParkError extends Error {
constructor(message) {
super(message);
this.name = 'JurassicParkError';
this.timestamp = new Date();
}
logError() {
console.error(`[${this.timestamp.toISOString()}] ${this.name}: ${this.message}`);
}
}
// Błędy związane z dinozaurami
class DinosaurError extends JurassicParkError {
constructor(message, species) {
super(message);
this.name = 'DinosaurError';
this.species = species;
}
}
// Konkretne typy błędów związanych z dinozaurami
class DinosaurHealthError extends DinosaurError {
constructor(message, species, healthIssue, severity) {
super(message, species);
this.name = 'DinosaurHealthError';
this.healthIssue = healthIssue;
this.severity = severity;
}
requiresVeterinarian() {
return this.severity >= 7;
}
}
class DinosaurBehaviorError extends DinosaurError {
constructor(message, species, behavior, dangerLevel) {
super(message, species);
this.name = 'DinosaurBehaviorError';
this.behavior = behavior;
this.dangerLevel = dangerLevel;
}
requiresIntervention() {
return this.dangerLevel >= 5;
}
}
// Błędy związane z infrastrukturą parku
class ParkInfrastructureError extends JurassicParkError {
constructor(message, systemName, location) {
super(message);
this.name = 'ParkInfrastructureError';
this.systemName = systemName;
this.location = location;
}
}
// Konkretne typy błędów infrastruktury
class PowerSystemError extends ParkInfrastructureError {
constructor(message, location, affectedSystems) {
super(message, 'PowerSystem', location);
this.name = 'PowerSystemError';
this.affectedSystems = affectedSystems;
}
requiresBackupPower() {
return this.affectedSystems.includes('SecurityFences');
}
}Taka hierarchia pozwala na precyzyjną obsługę różnych typów błędów:
async function monitorParkSystems() {
try {
await checkDinosaurHealth();
await checkEnclosureSecurity();
await checkPowerSystems();
} catch (error) {
// Logowanie wszystkich błędów
console.error(`[${new Date().toISOString()}] Error:`, error);
// Różne reakcje w zależności od typu błędu
if (error instanceof DinosaurHealthError) {
if (error.requiresVeterinarian()) {
await dispatchVeterinarianTeam(error.species, error.healthIssue, error.severity);
} else {
await scheduleRoutineCheckup(error.species);
}
}
else if (error instanceof DinosaurBehaviorError) {
if (error.requiresIntervention()) {
await dispatchBehavioralSpecialist(error.species, error.behavior);
if (error.dangerLevel >= 8) {
await prepareTransquilizers(error.species);
}
}
}
else if (error instanceof PowerSystemError) {
await notifyMaintenanceTeam(error.location, error.message);
if (error.requiresBackupPower()) {
await activateBackupGenerators(error.location);
}
}
else if (error instanceof JurassicParkError) {
// Ogólna obsługa dla wszystkich błędów parku
await logToSecuritySystem(error);
}
else {
// Nieznany typ błędu
console.error('Nieznany błąd:', error);
}
}
}Serializacja błędów
Jeden z problemów z obiektami błędów w JavaScript to ich serializacja. Domyślnie, gdy próbujemy przekonwertować błąd do JSON, tracimy większość informacji:
const error = new Error('Test error');
console.log(JSON.stringify(error)); // {} - puste obiekty!Własne klasy błędów mogą rozwiązać ten problem implementując metodę toJSON:
class SerializableError extends Error {
constructor(message) {
super(message);
this.name = this.constructor.name;
}
toJSON() {
return {
name: this.name,
message: this.message,
stack: this.stack,
// Dodatkowe właściwości specyficzne dla podklas
...Object.getOwnPropertyNames(this)
.filter(prop => !['name', 'message', 'stack'].includes(prop))
.reduce((obj, prop) => {
obj[prop] = this[prop];
return obj;
}, {})
};
}
}
// Teraz możemy tworzyć serializowalne błędy
class DinosaurEscapeError extends SerializableError {
constructor(message, species, location) {
super(message);
this.species = species;
this.location = location;
this.timestamp = new Date();
}
}
const error = new DinosaurEscapeError(
'Dinozaur uciekł z wybiegu',
'Velociraptor',
'Sektor B6'
);
// Teraz error można poprawnie serializować
console.log(JSON.stringify(error, null, 2));
/* Wynik:
{
"name": "DinosaurEscapeError",
"message": "Dinozaur uciekł z wybiegu",
"stack": "DinosaurEscapeError: Dinozaur uciekł z wybiegu\n at ...",
"species": "Velociraptor",
"location": "Sektor B6",
"timestamp": "2023-05-15T10:30:45.123Z"
}
*/Jest to szczególnie przydatne, gdy musimy przesyłać informacje o błędach przez API lub zapisywać je w logach.
Obsługa błędów asynchronicznych z niestandardowymi klasami
Własne klasy błędów świetnie współpracują z asynchronicznym kodem:
// Klasa błędu specyficzna dla API
class APIError extends Error {
constructor(message, statusCode, endpoint) {
super(message);
this.name = 'APIError';
this.statusCode = statusCode;
this.endpoint = endpoint;
this.timestamp = new Date();
}
isServerError() {
return this.statusCode >= 500;
}
isClientError() {
return this.statusCode >= 400 && this.statusCode < 500;
}
isAuthError() {
return this.statusCode === 401 || this.statusCode === 403;
}
}
// Funkcja pobierająca dane z API, która używa niestandardowej klasy błędu
async function fetchDinosaurData(dinoId) {
try {
const response = await fetch(`https://jurassic-park-api.com/dinosaurs/${dinoId}`);
if (!response.ok) {
throw new APIError(
`Błąd podczas pobierania danych o dinozaurze #${dinoId}`,
response.status,
`/dinosaurs/${dinoId}`
);
}
return await response.json();
} catch (error) {
if (error instanceof APIError) {
// Obsługa błędów API
if (error.isAuthError()) {
await refreshAuthToken();
return fetchDinosaurData(dinoId); // Ponowna próba po odświeżeniu tokenu
} else if (error.isServerError()) {
console.error('Błąd serwera, próba użycia zapasowego API...');
return fetchDinosaurDataFromBackupAPI(dinoId);
} else {
console.error(`Błąd klienta: ${error.message} (statusCode: ${error.statusCode})`);
throw error; // Przekazujemy błąd dalej
}
} else {
// Inny rodzaj błędu (np. sieciowy)
console.error('Nieoczekiwany błąd:', error);
throw new Error(`Nie udało się pobrać danych o dinozaurze #${dinoId}: ${error.message}`);
}
}
}Zaawansowany przykład: System raportowania incydentów
Zobaczmy, jak możemy wykorzystać własne klasy błędów w bardziej rozbudowanym przykładzie - systemie raportowania incydentów w Parku Jurajskim:
// Bazowa klasa błędu dla incydentów
class IncidentError extends Error {
constructor(message, location, severity) {
super(message);
this.name = 'IncidentError';
this.location = location;
this.severity = severity; // 1-10
this.timestamp = new Date();
this.resolved = false;
this.resolutionTime = null;
}
markAsResolved() {
this.resolved = true;
this.resolutionTime = new Date();
return this;
}
getIncidentDuration() {
if (!this.resolved) return null;
return (this.resolutionTime - this.timestamp) / 1000; // w sekundach
}
requiresEvacuation() {
return this.severity >= 7;
}
requiresNotification() {
return this.severity >= 4;
}
getSummary() {
return {
type: this.name,
message: this.message,
location: this.location,
severity: this.severity,
timestamp: this.timestamp,
status: this.resolved ? 'Rozwiązany' : 'Aktywny',
resolutionTime: this.resolutionTime
};
}
toJSON() {
return this.getSummary();
}
}
// Klasy dla różnych typów incydentów
class DinosaurEscapeIncident extends IncidentError {
constructor(message, location, species, count, dangerLevel) {
super(message, location, dangerLevel);
this.name = 'DinosaurEscapeIncident';
this.species = species;
this.count = count;
this.lastSighting = location;
}
updateSighting(newLocation) {
this.lastSighting = newLocation;
return this;
}
getSummary() {
return {
...super.getSummary(),
species: this.species,
count: this.count,
lastSighting: this.lastSighting
};
}
}
class SystemFailureIncident extends IncidentError {
constructor(message, location, system, affectedAreas, backupStatus) {
// Obliczenie poziomu krytyczności na podstawie systemu i dostępności backupu
const severity = SystemFailureIncident.calculateSeverity(system, backupStatus);
super(message, location, severity);
this.name = 'SystemFailureIncident';
this.system = system;
this.affectedAreas = affectedAreas;
this.backupStatus = backupStatus;
}
static calculateSeverity(system, backupStatus) {
const systemCriticality = {
'electric_fences': 10,
'security_doors': 9,
'surveillance': 7,
'climate_control': 6,
'guest_services': 3
};
// Jeśli backup działa, zmniejsz poziom krytyczności
const baseSeverity = systemCriticality[system] || 5;
return backupStatus === 'operational' ? Math.max(3, baseSeverity - 3) : baseSeverity;
}
requiresMaintenanceTeam() {
return true;
}
requiresEmergencyPower() {
return this.system === 'electric_fences' || this.system === 'security_doors';
}
getSummary() {
return {
...super.getSummary(),
system: this.system,
affectedAreas: this.affectedAreas,
backupStatus: this.backupStatus,
requiresEmergencyPower: this.requiresEmergencyPower()
};
}
}
class VisitorIncident extends IncidentError {
constructor(message, location, visitorCount, injuryLevel, medicalStatus) {
// Obliczenie poziomu krytyczności na podstawie liczby gości i poziomu obrażeń
const severity = VisitorIncident.calculateSeverity(visitorCount, injuryLevel);
super(message, location, severity);
this.name = 'VisitorIncident';
this.visitorCount = visitorCount;
this.injuryLevel = injuryLevel; // 'none', 'minor', 'moderate', 'severe'
this.medicalStatus = medicalStatus; // 'not_required', 'dispatched', 'on_scene', 'evacuating'
}
static calculateSeverity(visitorCount, injuryLevel) {
const injurySeverity = {
'none': 1,
'minor': 3,
'moderate': 6,
'severe': 9
};
// Zwiększ poziom krytyczności dla większej liczby gości
const baseSeverity = injurySeverity[injuryLevel] || 5;
const visitorFactor = visitorCount > 10 ? 2 : visitorCount > 3 ? 1 : 0;
return Math.min(10, baseSeverity + visitorFactor);
}
requiresMedicalTeam() {
return this.injuryLevel !== 'none';
}
updateMedicalStatus(newStatus) {
this.medicalStatus = newStatus;
// Jeśli pomoc medyczna jest na miejscu i sytuacja nie jest krytyczna,
// możemy zmniejszyć poziom krytyczności
if (newStatus === 'on_scene' && this.injuryLevel !== 'severe') {
this.severity = Math.max(2, this.severity - 2);
}
return this;
}
getSummary() {
return {
...super.getSummary(),
visitorCount: this.visitorCount,
injuryLevel: this.injuryLevel,
medicalStatus: this.medicalStatus,
requiresMedicalTeam: this.requiresMedicalTeam()
};
}
}
// System zarządzania incydentami
class IncidentManagementSystem {
constructor() {
this.activeIncidents = new Map();
this.resolvedIncidents = [];
this.eventListeners = {
'new': [],
'update': [],
'resolve': []
};
}
reportIncident(incident) {
if (!(incident instanceof IncidentError)) {
throw new TypeError('Można raportować tylko obiekty typu IncidentError');
}
const incidentId = `INC-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
this.activeIncidents.set(incidentId, incident);
// Powiadomienie wszystkich słuchaczy o nowym incydencie
this._notifyListeners('new', { id: incidentId, incident });
// Automatyczne reakcje na incydent
this._triggerAutomatedResponses(incidentId, incident);
return incidentId;
}
updateIncident(incidentId, updateFn) {
if (!this.activeIncidents.has(incidentId)) {
throw new Error(`Incydent o ID ${incidentId} nie istnieje lub został już rozwiązany`);
}
const incident = this.activeIncidents.get(incidentId);
updateFn(incident);
// Powiadomienie wszystkich słuchaczy o aktualizacji incydentu
this._notifyListeners('update', { id: incidentId, incident });
return incident;
}
resolveIncident(incidentId, resolutionNotes = '') {
if (!this.activeIncidents.has(incidentId)) {
throw new Error(`Incydent o ID ${incidentId} nie istnieje lub został już rozwiązany`);
}
const incident = this.activeIncidents.get(incidentId);
incident.markAsResolved();
incident.resolutionNotes = resolutionNotes;
// Przenieś incydent z aktywnych do rozwiązanych
this.activeIncidents.delete(incidentId);
this.resolvedIncidents.push({ id: incidentId, incident });
// Powiadomienie wszystkich słuchaczy o rozwiązaniu incydentu
this._notifyListeners('resolve', { id: incidentId, incident });
return incident;
}
getActiveIncidents() {
return Array.from(this.activeIncidents.entries()).map(([id, incident]) => ({
id,
...incident.getSummary()
}));
}
getIncidentById(incidentId) {
if (this.activeIncidents.has(incidentId)) {
return {
id: incidentId,
status: 'active',
...this.activeIncidents.get(incidentId).getSummary()
};
}
const resolvedIncident = this.resolvedIncidents.find(inc => inc.id === incidentId);
if (resolvedIncident) {
return {
id: incidentId,
status: 'resolved',
...resolvedIncident.incident.getSummary()
};
}
return null;
}
addEventListener(event, callback) {
if (!this.eventListeners[event]) {
throw new Error(`Nieznany typ zdarzenia: ${event}`);
}
this.eventListeners[event].push(callback);
return () => this.removeEventListener(event, callback); // Funkcja do usunięcia listenera
}
removeEventListener(event, callback) {
if (!this.eventListeners[event]) return false;
const index = this.eventListeners[event].indexOf(callback);
if (index !== -1) {
this.eventListeners[event].splice(index, 1);
return true;
}
return false;
}
_notifyListeners(event, data) {
if (!this.eventListeners[event]) return;
for (const listener of this.eventListeners[event]) {
try {
listener(data);
} catch (error) {
console.error(`Błąd w listenerze zdarzenia ${event}:`, error);
}
}
}
_triggerAutomatedResponses(incidentId, incident) {
console.log(`Automatyczna reakcja na incydent ${incidentId}:`, incident.name);
// Różne reakcje w zależności od typu incydentu
if (incident instanceof DinosaurEscapeIncident) {
if (incident.requiresEvacuation()) {
console.log(`EWAKUACJA! Uruchamianie protokołu ewakuacji dla: ${incident.location}`);
// evacuateSector(incident.location);
}
console.log(`Wysyłanie zespołu ACU (Asset Containment Unit) do lokalizacji: ${incident.lastSighting}`);
// dispatchACUTeam(incident.lastSighting, incident.species, incident.count);
}
else if (incident instanceof SystemFailureIncident) {
console.log(`Powiadomienie zespołu technicznego o awarii systemu: ${incident.system}`);
// notifyMaintenanceTeam(incident.system, incident.location);
if (incident.requiresEmergencyPower()) {
console.log('Uruchamianie systemu zasilania awaryjnego!');
// activateEmergencyPower(incident.affectedAreas);
}
}
else if (incident instanceof VisitorIncident) {
if (incident.requiresMedicalTeam()) {
console.log(`Wysyłanie zespołu medycznego do lokalizacji: ${incident.location}`);
// dispatchMedicalTeam(incident.location, incident.injuryLevel, incident.visitorCount);
// Aktualizacja statusu medycznego
this.updateIncident(incidentId, inc => inc.updateMedicalStatus('dispatched'));
}
if (incident.requiresEvacuation()) {
console.log(`Rozpoczynam ewakuację gości z: ${incident.location}`);
// evacuateVisitors(incident.location);
}
}
// Wspólne reakcje dla wszystkich incydentów
if (incident.requiresNotification()) {
console.log('Powiadamianie kierownictwa parku...');
// notifyParkManagement(incident.getSummary());
}
}
}
// Przykład użycia systemu incydentów
function demoParkIncidentSystem() {
const incidentSystem = new IncidentManagementSystem();
// Dodajemy słuchacza dla nowych incydentów
incidentSystem.addEventListener('new', ({ id, incident }) => {
console.log(`NOWY INCYDENT [${id}]: ${incident.name} w lokalizacji ${incident.location}`);
});
// Raportowanie incydentu z dinozaurem
const raptorIncidentId = incidentSystem.reportIncident(
new DinosaurEscapeIncident(
'Ucieczka Velociraptorów z zagrody',
'Sektor C4',
'Velociraptor',
3,
9 // Wysoki poziom zagrożenia
)
);
// Aktualizacja incydentu - zmiana ostatniego spostrzeżenia
setTimeout(() => {
incidentSystem.updateIncident(raptorIncidentId, incident => {
incident.updateSighting('Sektor C5 - w pobliżu centrum odwiedzających');
console.log(`Aktualizacja: Raptory zauważono w ${incident.lastSighting}`);
});
}, 2000);
// Raportowanie incydentu systemowego
const powerIncidentId = incidentSystem.reportIncident(
new SystemFailureIncident(
'Awaria zasilania ogrodzeń elektrycznych',
'Sektor B1-B3',
'electric_fences',
['TRex Paddock', 'Raptor Containment'],
'offline' // Backup nie działa
)
);
// Raportowanie incydentu z gośćmi
const visitorIncidentId = incidentSystem.reportIncident(
new VisitorIncident(
'Goście poza wyznaczoną trasą zwiedzania',
'Sektor D2',
4, // Liczba gości
'minor', // Drobne obrażenia
'not_required' // Status medyczny
)
);
// Wyświetlanie aktywnych incydentów
setTimeout(() => {
console.log('\n--- AKTYWNE INCYDENTY ---');
console.table(incidentSystem.getActiveIncidents());
}, 3000);
// Rozwiązanie incydentu z gośćmi
setTimeout(() => {
incidentSystem.resolveIncident(
visitorIncidentId,
'Goście zostali bezpiecznie eskortowani z powrotem na wyznaczoną trasę zwiedzania.'
);
console.log(`Incydent ${visitorIncidentId} został oznaczony jako rozwiązany.`);
}, 4000);
// Rozwiązanie incydentu z zasilaniem
setTimeout(() => {
incidentSystem.resolveIncident(
powerIncidentId,
'Zasilanie przywrócone, ogrodzenia ponownie aktywne.'
);
console.log(`Incydent ${powerIncidentId} został oznaczony jako rozwiązany.`);
}, 5000);
// Rozwiązanie incydentu z raptorami
setTimeout(() => {
incidentSystem.resolveIncident(
raptorIncidentId,
'Wszystkie 3 Velociraptory złapane i bezpiecznie przetransportowane z powrotem do zagrody.'
);
console.log(`Incydent ${raptorIncidentId} został oznaczony jako rozwiązany.`);
// Wyświetlenie podsumowania incydentu
const incidentDetails = incidentSystem.getIncidentById(raptorIncidentId);
console.log('\n--- SZCZEGÓŁY ROZWIĄZANEGO INCYDENTU ---');
console.log(JSON.stringify(incidentDetails, null, 2));
}, 6000);
}
// Uruchomienie demonstracji
// demoParkIncidentSystem();Dobre praktyki tworzenia własnych klas błędów
- Nazywaj błędy znacząco - nazwa powinna jasno wskazywać, co poszło nie tak
- Twórz hierarchię błędów - używaj dziedziczenia, aby stworzyć logiczną hierarchię klas błędów
- Dodawaj kontekst - zawsze dołączaj dodatkowe informacje, które pomogą w diagnozie i obsłudze błędu
- Implementuj metody pomocnicze - dodawaj metody, które ułatwią kategorizację i obsługę błędów
- Dbaj o serializację - dodaj metodę
toJSON(), aby błędy można było łatwo logować i przesyłać - Zachowaj ślad stosu - upewnij się, że wywołujesz
super(message)w konstruktorze, aby zachować ślad stosu - Dokumentuj swoje klasy błędów - inni programiści (i przyszły ty) powinni wiedzieć, kiedy i jak używać twoich klas błędów
Wnioski
Własne klasy błędów to potężne narzędzie w arsenale programisty JavaScript. W złożonych aplikacjach, takich jak system zarządzania Parkiem Jurajskim, precyzyjna kategoryzacja i obsługa różnych typów błędów jest kluczowa dla utrzymania bezpieczeństwa i stabilności.
Pamiętaj, że jak powiedział Dr. Ian Malcolm: "Życie... uh... znajdzie sposób." To samo dotyczy błędów w kodzie. Najlepszym podejściem jest nie udawać, że błędy nie istnieją, ale spodziewać się ich i być przygotowanym na ich obsługę w jak najbardziej elegancki i skuteczny sposób.
W następnym ćwiczeniu wykorzystamy wszystkie poznane techniki do implementacji pełnej aplikacji, która będzie demonstrować moduły, asynchroniczność i obsługę błędów w praktyce.
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. Jak prawidłowo stworzyć własną klasę błędu w JavaScript?
2. Do czego służy operator instanceof w obsłudze błędów?
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj klasy ParkError, FenceBreachError i PowerFailureError z metodami pomocniczymi.
- Klikanie w kolejności
Ułóż elementy definicji własnej klasy błędu w poprawnej kolejności: