Szybki quiz – przypomnienie poprzedniej lekcji

Lekcja 14: cookies i sesje. Odpowiedz z pamięci, bez zaglądania do kodu.

1. Co wyświetli ten skrypt przy pierwszym otwarciu strony, a co przy drugim?

<?php
setcookie('motyw', 'ciemny', time() + 3600);
echo $_COOKIE['motyw'] ?? '(brak)';

2. Znajdź błąd i powiedz, jaki komunikat zobaczy użytkownik:

<?php
echo "<h1>TaskQuest</h1>";
session_start();
$_SESSION['login'] = 'Kama';

3. W TaskQuest login zalogowanego użytkownika trzymamy w sesji, a wybrany widok listy — w ciasteczku. Podaj powód tej decyzji (jedno zdanie dla każdego).

4. Wskaż dwa problemy w tej linii:

if ($_COOKIE['rola'] === 'admin') { /* panel administratora */ }

5. Uzupełnij kod usuwający ciasteczko filtr:

setcookie('filtr', '', ______);

6. Zapisujemy liczbę 99 raz do sesji ($_SESSION['xp'] = 99;), raz do ciasteczka (setcookie('xp', 99, time() + 3600);). Co pokaże var_dump() dla każdej z tych wartości w następnym żądaniu?

7. Co wyświetli poniższy kod przy drugim odświeżeniu strony? A co, gdyby zabrakło pierwszej linii?

<?php
session_start();
$_SESSION['wizyty'] = ($_SESSION['wizyty'] ?? 0) + 1;
echo $_SESSION['wizyty'];

TaskQuest

Dodatek

Programowanie obiektowe – OOP (object-oriented programming) – pozwala na przedstawienie rzeczywistości i relacji w niej zachodzących za pomocą obiektów.

Po co nam programowanie obiektowe?

Programowanie obiektowe (ang. Object-Oriented Programming, OOP) wprowadza strukturę i organizację do kodu, co ułatwia jego tworzenie, rozwijanie i utrzymanie. Poniżej znajdziesz wyjaśnienie, po co stosować programowanie obiektowe, z przykładami jego głównych zalet:

1. Organizacja i modularność

• OOP pozwala dzielić kod na mniejsze, logiczne fragmenty (klasy), które odpowiadają rzeczywistym obiektom lub pojęciom.
• Dzięki temu kod jest bardziej przejrzysty i łatwiejszy w zarządzaniu.

Przykład: W grze komputerowej można mieć klasy Gracz, Przeciwnik, Broń. Każda z nich zawiera tylko dane i funkcje związane z tym obiektem.

2. Reużywalność kodu

• Możesz tworzyć klasy i wykorzystywać je wielokrotnie w różnych projektach lub częściach programu.
• Dziedziczenie umożliwia tworzenie nowych klas na podstawie istniejących, dzięki czemu kod jest bardziej elastyczny.

Przykład: Klasa Pojazd może mieć podklasy Samochód, Motocykl, które dziedziczą podstawowe cechy pojazdu (np. prędkość, masa), ale dodają swoje specyficzne funkcje.

3. Łatwiejsze rozwijanie aplikacji

• W OOP zmiany są łatwiejsze do wprowadzenia, ponieważ każda klasa działa jako oddzielny moduł.
• Jeśli potrzebujesz zmienić zachowanie jednego elementu, modyfikujesz tylko odpowiednią klasę, bez wpływu na inne części programu.

Przykład: Dodanie nowej broni w grze wymaga jedynie stworzenia nowej klasy na podstawie istniejącego schematu, np. Broń.

4. Ukrywanie szczegółów (enkapsulacja)

• OOP pozwala ukrywać szczegóły implementacji, dzięki czemu kod jest bardziej bezpieczny i trudniejszy do przypadkowego uszkodzenia.
• Dane w klasach są chronione, a dostęp do nich odbywa się przez ściśle określone metody.

Przykład: W klasie KontoBankowe saldo konta jest ukryte, a użytkownik może je zmieniać tylko za pomocą metod wpłać() i wypłać().

5. Naturalne odwzorowanie rzeczywistości

• OOP naśladuje sposób, w jaki myślimy o świecie, opierając się na obiektach, ich cechach i zachowaniach.
• Dzięki temu kod staje się bardziej intuicyjny i łatwiejszy do zrozumienia.

Przykład: Klasa Kot ma cechy takie jak kolor futra (atrybuty) i umiejętności jak miauczenie (metody).

6. Łatwość debugowania i testowania

• Dzięki temu, że klasy są niezależne, błędy w jednym obiekcie nie wpływają na inne.
• Testowanie poszczególnych modułów (klas) jest prostsze niż testowanie całości kodu.

7. Polimorfizm – elastyczność w działaniu

• Polimorfizm umożliwia różnym obiektom używanie tej samej metody, ale w różny sposób.
• Pozwala to na pisanie bardziej uniwersalnego i elastycznego kodu.

Przykład: Metoda atakuj() może działać inaczej w klasie Rycerz i Mag, mimo że jest wywoływana w ten sam sposób.

8. Ułatwienie pracy zespołowej

• W dużych projektach, podział kodu na klasy ułatwia współpracę, ponieważ każdy programista może pracować nad innymi obiektami, nie wchodząc sobie w drogę.

Podsumowanie

Programowanie obiektowe jest użyteczne, gdy:

• Tworzysz duże, złożone systemy.
• Chcesz pisać kod, który łatwo rozwijać, utrzymywać i testować.
• Potrzebujesz odzwierciedlić rzeczywiste pojęcia lub obiekty w swoim kodzie.

Jeśli jednak tworzysz mały, prosty skrypt, nie zawsze konieczne jest stosowanie OOP – wtedy wystarczą inne podejścia, jak programowanie proceduralne.

Klasa i obiekt

Kiedy mówimy o klasie musimy wyobrazić ją sobie jak ogólny zarys/opis jakiegoś obiektu, zbiór cech wspólnych dla np. człowieka. Gdybyśmy mieli klasę człowiek moglibyśmy określić ogólne cechy jakie definiują ludzi, czyli np. to że śpi, że ma głos, oczy, włosy, ręce, nogi itd.

Obiekt jest instancją danej klasy, czyli konkretnym człowiekiem np. Janem Kowalskim, który ma brązowe włosy, jest typem „skowronka” i ma niebieskie oczy. Te cechy nie są bezpośrednio związane z klasą, a z obiektem (instancją/wystąpieniem klasy).

Można powiedzieć, że Jan Kowalski jest zmienną typu klasy, czyli obiektem typu człowiek.

Przykład utworzenia klasy – Streamer na Twitchu

<?php 
// Tworzymy klasę Streamer
class Streamer {
    public $nick;
    public $subskrybcje;
    public $followers;
    public $kategoria;
}
?>

Mając tak zdefiniowana klasę możemy otworzyć konkretny obiekt:

<?php
$streamer1 = new Streamer(); // Tworzymy nowy obiekt klasy Streamer

// Nadajemy konkretne cechy
$streamer1->nick = 'GamingLegend';
$streamer1->subskrybcje = 1520;
$streamer1->followers = 45000;
$streamer1->kategoria = 'League of Legends';

// Wyświetlamy rezultaty
echo 'Streamer: ' . $streamer1->nick . '<br>';
echo 'Subskrybcje: ' . $streamer1->subskrybcje . '<br>';
echo 'Followersi: ' . $streamer1->followers . '<br>';
echo 'Gra w: ' . $streamer1->kategoria . '<br>';

/*
Wyświetli się:
Streamer: GamingLegend
Subskrybcje: 1520
Followersi: 45000
Gra w: League of Legends
*/
?>

Wyświetlenie stworzonego obiektu

Możemy wyświetlić sobie stworzony obiekt:

<?php
echo '<pre>';
print_r($streamer1);
echo '</pre>';

/*
Wyświetli się:
Streamer Object
(
    [nick] => GamingLegend
    [subskrybcje] => 1520
    [followers] => 45000
    [kategoria] => League of Legends
)
*/
?>

Wartości domyślne w klasie

Klasie możemy nadać domyślne wartości, które zostaną nadane w momencie tworzenia obiektu:

<?php
class Streamer {
    public $nick;
    public $subskrybcje = 0;        // Wartość domyślna
    public $followers = 0;           // Wartość domyślna
    public $kategoria = 'Just Chatting'; // Wartość domyślna
}

$streamer1 = new Streamer(); // Tworzymy nowy obiekt

// Nadajemy tylko niektóre cechy
$streamer1->nick = 'NewbieStreamer';
$streamer1->followers = 150;

// Wyświetlamy rezultaty
echo 'Streamer: ' . $streamer1->nick . '<br>';
echo 'Subskrybcje: ' . $streamer1->subskrybcje . '<br>';
echo 'Followersi: ' . $streamer1->followers . '<br>';
echo 'Kategoria: ' . $streamer1->kategoria . '<br>';

/*
Wyświetli się:
Streamer: NewbieStreamer
Subskrybcje: 0
Followersi: 150
Kategoria: Just Chatting
*/
?>

Już potrafisz:

• stworzyć definicję obiektu w postaci klasy
• dodać publiczne pola do klasy i nadawać im wartości domyślne
• przypisywać im wartości
• odczytywać ich wartość
• korzystać z „->”, by dostać się do pola klasy

Metody

Klasa może definiować metody, czyli nic innego jak funkcje z podejścia proceduralnego. Kiedy tworzymy obiekt nadajemy mu dostęp do metod danej klasy.

Trochę praktyki – Discord Bot

<?php
class DiscordBot {
    public $nazwa;
    public $serwery = 0;        // Liczba serwerów
    public $uzytkownicy = 0;    // Liczba użytkowników
    public $wersja = '1.0';     // Wersja bota

    // Teraz tworzymy metodę
    public function pobierzStatus() {
        return "Bot {$this->nazwa} jest aktywny na {$this->serwery} serwerach.";
    }
}

$bot1 = new DiscordBot();
$bot1->nazwa = 'MusicBot';
$bot1->serwery = 350;

$bot2 = new DiscordBot();
$bot2->nazwa = 'ModerationBot';
$bot2->serwery = 1200;

$bot3 = new DiscordBot();
$bot3->nazwa = 'GamesBot';

echo '<pre>';
print_r($bot1);
echo '</pre>';

echo $bot1->pobierzStatus() . '<br>';

echo '<pre>';
print_r($bot2);
echo '</pre>';

echo $bot2->pobierzStatus() . '<br>';

echo '<pre>';
print_r($bot3);
echo '</pre>';

echo $bot3->pobierzStatus() . '<br>';
?>

Zostanie wyświetlone:

DiscordBot Object
(
    [nazwa] => MusicBot
    [serwery] => 350
    [uzytkownicy] => 0
    [wersja] => 1.0
)

Bot MusicBot jest aktywny na 350 serwerach.

DiscordBot Object
(
    [nazwa] => ModerationBot
    [serwery] => 1200
    [uzytkownicy] => 0
    [wersja] => 1.0
)

Bot ModerationBot jest aktywny na 1200 serwerach.

DiscordBot Object
(
    [nazwa] => GamesBot
    [serwery] => 0
    [uzytkownicy] => 0
    [wersja] => 1.0
)

Bot GamesBot jest aktywny na 0 serwerach.

Zmienna $this

Aby dostać się do konkretnego pola w obiekcie, korzystamy ze zmiennej $this.

W powyższym przykładzie nadawaliśmy wartości odnosząc się bezpośrednio do pola klasy. Nie jest to dobra metoda, ponieważ użytkownik może wpisać co chce w dane pole i niestety skrypt może się „wysypać”.

Aby tego uniknąć dodajemy dane za pomocą metody, którą możemy łatwo zabezpieczyć przed niechcianym kodem.

Bezpieczne metody – setter i getter

Powyższy kod powinien wyglądać następująco:

<?php
class DiscordBot {
    public $nazwa;
    public $serwery = 0;
    public $uzytkownicy = 0;
    public $wersja = '1.0';

    // Metoda pobierająca status (getter)
    public function pobierzStatus() {
        return "Bot {$this->nazwa} jest aktywny na {$this->serwery} serwerach.";
    }

    // Metoda przypisująca liczbę serwerów (setter)
    public function przypiszSerwery($ilosc) {
        // Można dodać tutaj sprawdzanie czy wprowadzona wartość jest int 
        // i mieści się w określonym przedziale
        $this->serwery = $ilosc;
    }
}

$bot1 = new DiscordBot();
$bot1->nazwa = 'MusicBot';
$bot1->przypiszSerwery(350);  // Bezpieczne przypisanie

$bot2 = new DiscordBot();
$bot2->nazwa = 'ModerationBot';
$bot2->przypiszSerwery(1200);

$bot3 = new DiscordBot();
$bot3->nazwa = 'GamesBot';

echo '<pre>';
print_r($bot1);
echo '</pre>';

echo $bot1->pobierzStatus() . '<br>';

echo '<pre>';
print_r($bot2);
echo '</pre>';

echo $bot2->pobierzStatus() . '<br>';

echo '<pre>';
print_r($bot3);
echo '</pre>';

echo $bot3->pobierzStatus() . '<br>';
?>

Walidacja danych w metodach

A teraz przykład z walidacją liczby serwerów:

<?php
class DiscordBot {
    public $nazwa;
    public $serwery = 'brak danych';  // Wartość domyślna
    public $uzytkownicy = 0;
    public $wersja = '1.0';

    // Metoda pobierająca status
    public function pobierzStatus() {
        return "Bot {$this->nazwa} jest aktywny na {$this->serwery} serwerach.";
    }

    // Metoda przypisująca liczbę serwerów Z WALIDACJĄ
    public function przypiszSerwery($ilosc) {
        // Sprawdzanie czy wprowadzona wartość jest int i mieści się w przedziale
        $ilosc = intval($ilosc);
        
        if ($ilosc > 0 && $ilosc < 1000000) {
            $this->serwery = $ilosc;
        }
    }
}

$bot1 = new DiscordBot();
$bot1->nazwa = 'MusicBot';
$bot1->przypiszSerwery('tekst');  // Nieprawidłowa wartość - zostanie odrzucona

$bot2 = new DiscordBot();
$bot2->nazwa = 'ModerationBot';
$bot2->przypiszSerwery(1200);     // Prawidłowa wartość

$bot3 = new DiscordBot();
$bot3->nazwa = 'GamesBot';

echo '<pre>';
print_r($bot1);
echo '</pre>';

echo $bot1->pobierzStatus() . '<br>';

echo '<pre>';
print_r($bot2);
echo '</pre>';

echo $bot2->pobierzStatus() . '<br>';

echo '<pre>';
print_r($bot3);
echo '</pre>';

echo $bot3->pobierzStatus() . '<br>';
?>

Wyświetli się:

DiscordBot Object
(
    [nazwa] => MusicBot
    [serwery] => brak danych
    [uzytkownicy] => 0
    [wersja] => 1.0
)

Bot MusicBot jest aktywny na brak danych serwerach.

DiscordBot Object
(
    [nazwa] => ModerationBot
    [serwery] => 1200
    [uzytkownicy] => 0
    [wersja] => 1.0
)

Bot ModerationBot jest aktywny na 1200 serwerach.

DiscordBot Object
(
    [nazwa] => GamesBot
    [serwery] => brak danych
    [uzytkownicy] => 0
    [wersja] => 1.0
)

Bot GamesBot jest aktywny na brak danych serwerach.

Już potrafisz:

• stworzyć metodę klasy
• zwrócić wartość i przekazać argumenty
• korzystać ze zmiennej $this
• zabezpieczyć dane

Modyfikatory dostępu

Do tej pory wykonywaliśmy przykłady w oparciu o publiczną dostępność danego elementu, czyli public. Taka metoda lub właściwość jest publiczna, więc widoczna wszędzie wewnątrz obiektu i poza nim. Dostęp do pola jest nieograniczony i można je odczytywać i zmieniać dowolnie.

Właściwość lub metoda może być prywatna, czyli private, wówczas może zostać użyta tylko wewnątrz obiektu.

Właściwość lub metoda protected może być użyta tylko wewnątrz obiektu, ale może być również dziedziczona.

Zaleca się w programowaniu i w życiu, nie udostępniać zbyt wiele informacji na zewnątrz, więc tego się trzymajmy – korzystamy z modyfikatorów private.

Przykład public – Serwer gry online

<?php
class SerwerGry {
    public $czyOnline = true;

    public function wlacz() {
        $this->czyOnline = true;
    }

    public function wylacz() {
        $this->czyOnline = false;
    }

    public function sprawdzStatus() {
        return $this->czyOnline;
    }
}

$serwer = new SerwerGry();
$serwer->wylacz();
$serwer->czyOnline = true;  // Zmieniamy wartość parametru bezpośrednio!

echo $serwer->sprawdzStatus() ? 'Serwer online' : 'Serwer offline';

// Wyświetli: Serwer online
?>

W powyższym przykładzie należy zwrócić uwagę na to, że pomimo iż ostatnią operacją na obiekcie było wyłączenie serwera, wprowadzenie bezpośredniej zmiany pola $serwer->czyOnline na true, sprawiło że otrzymujemy informację, że serwer jest online.

Możemy tego uniknąć blokując dostęp do pól i metod klasy, czyli zmieniając ich modyfikatory z publicznych na prywatne.

Ustawiamy wartość prywatną:

<?php
class SerwerGry {
    private $czyOnline = true;  // Modyfikator prywatny, brak dostępu z zewnątrz

    public function wlacz() {
        $this->czyOnline = true;
    }

    public function wylacz() {
        $this->czyOnline = false;
    }

    public function sprawdzStatus() {
        return $this->czyOnline;
    }
}

$serwer = new SerwerGry();
$serwer->wylacz();
$serwer->czyOnline = true;  // Chcemy zmienić wartość parametru

// Tutaj interpreter zwróci błąd, gdyż nie ma dostępu do zmiennej

echo $serwer->sprawdzStatus() ? 'Serwer online' : 'Serwer offline';
?>

Przykład powyższy generuje błąd, ponieważ nie ma dostępu do prywatnej wartości pola klasy.

Ustawimy teraz metody na prywatne i publiczne:

<?php
class StreamConfig {
    private $bitrate = 6000;
    
    private function obliczJakosc() {
        return $this->bitrate / 1000 . 'Mbps';
    }
    
    public function czyMoznaStreamowac($upload) {
        return $this->bitrate < $upload ? 'TAK' : 'NIE';
    }
}

$config = new StreamConfig();

echo '<pre>';
print_r($config);
echo '</pre>';

echo $config->czyMoznaStreamowac(8000);  // Wyświetli: TAK
echo $config->czyMoznaStreamowac(3000);  // Wyświetli: NIE

// echo $config->obliczJakosc();  // Tutaj interpreter zwróci błąd, 
                                  // gdyż nie ma dostępu do metody
?>

O modyfikatorze protected, trochę później – przy temacie dziedziczenie.

Już potrafisz:

• ograniczać dostęp do pól klasy i metod
• pozwalać klasie bazowej oraz klasom dziedziczącym na modyfikację pola lub metody

Dziedziczenie

Tak jak w życiu – jako potomkowie dziedziczymy po naszych przodkach pewne cechy (tak naprawdę to 50% od matki i 50% od ojca), tak samo klasy dziedziczą pola i metody, ale mogą zostać uzupełnione o inne elementy, których przodek nie posiada.

Jeżeli klasa przodka posiada pola i metody, które nie są prywatne, to klasa potomna również będzie je posiadać.

Klasa może dziedziczyć tylko po jednej klasie (rozszerzać tylko jedną klasę bazową )

Aby klasa dziedziczyła po innej należy użyć słówka extends i podać nazwę klasy przodka:

Przykład – Postać w grze RPG

<?php
class Postac {
    private $nick = 'Gracz123';
    protected $poziom = 1;
    protected $hp = 100;
    public $imie;
    
    public function czyMartwy() {
        return $this->hp <= 0;
    }
    
    public function otrzymajObrazenia($obrazenia) {
        return $this->zadajObrazenia($obrazenia);
    }
    
    protected function zadajObrazenia($ilosc) {
        $this->hp -= $ilosc;
        if ($this->hp < 0) {
            $this->hp = 0;
        }
        return $this->hp;
    }
}

// Następuje dziedziczenie
class Wojownik extends Postac {
    private $pancerz = 50;
    
    public function mocnyAtak() {
        return $this->atakujZSila(30);
    }
    
    private function atakujZSila($ilosc) {
        if ($this->poziom > 0) {  // Mamy dostęp do pola poziom, gdyż jest protected
            return $this->otrzymajObrazenia($ilosc);  // Metoda otrzymajObrazenia jest public
        }
        return $this->pancerz += $ilosc;
    }
}

$bohater = new Wojownik();

$bohater->imie = 'Conan';
$bohater->otrzymajObrazenia(25);
$bohater->mocnyAtak();

if ($bohater->czyMartwy()) {
    echo $bohater->imie . ' nie żyje!';
} else {
    echo $bohater->imie . ' walczy dalej!';
}

echo '<pre>';
print_r($bohater);
echo '</pre>';

// $hp = $bohater->hp;  // Ta linijka wygeneruje błąd, 
                         // gdyż z zewnątrz nie mamy dostępu do pola protected
// $bohater->zadajObrazenia(10);  // Ta linijka podobnie, jak wyżej
?>

Final, a nadpisywanie

Wiemy już doskonale, że zadeklarowanie w kodzie zmiennej o nazwie, która już istnieje, spowoduje nadpisanie jej wartości. Tak samo dzieje się z metodami. Jeżeli klasa dziedzicząca będzie posiadała metodę o nazwie istniejącej w klasie bazowej, to jej funkcjonalność zostanie nadpisana:

<?php
class ProfilBazowy {
    public function wyswietlNazwe() {
        echo "Nazywam się: Użytkownik";
    }
}

class ProfilPremium extends ProfilBazowy {
    public function wyswietlNazwe() {
        echo "Nazywam się: Premium User";
    }
}

$profil = new ProfilPremium();
$profil->wyswietlNazwe();

// Wyświetli: Nazywam się: Premium User
?>

W powyższym kodzie widzimy, że metoda wyswietlNazwe() została nadpisana i zamiast wyświetlić „Nazywam się: Użytkownik” otrzymaliśmy „Nazywam się: Premium User”.

Słowo kluczowe final

Jeżeli chcemy zabronić klasie potomnej nadpisywania metod w klasie bazowej, używamy słowa final przed deklaracją metody:

<?php
class ProfilBazowy {
    final public function wyswietlNazwe() {
        echo "Nazywam się: Użytkownik";
    }
}

class ProfilPremium extends ProfilBazowy {
    /*
    public function wyswietlNazwe() {
        // Ta metoda wygeneruje błąd: 
        // Fatal error: Cannot override final method...
    }
    */
}

$profil = new ProfilPremium();
$profil->wyswietlNazwe();
?>

Modyfikatora final możemy użyć przed nazwą klasy, wówczas ta klasa nie będzie mogła być dziedziczona.

Już potrafisz:

• stworzyć klasę rozszerzającą inną klasę
• korzystać z pól i metod klasy bazowej
• nadpisywać metody klasy bazowej
• blokować nadpisywanie przy pomocy słowa final

Metody magiczne

Nazwa tych metod wzięła się stąd, że wywoływane są automatycznie w momencie tworzenia obiektu i nie wymagają dodatkowych akcji. Metody te występują tylko w kontekście klas, a ich nazwy są poprzedzone 2 znakami „podłogi” (podkreślnika) __ .

Konstruktor – __construct

Dzięki konstruktorowi możemy przesłać określone wartości do obiektu w momencie jego tworzenia.

Teoretycznie PHP umożliwia stworzenie tylko 1go konstruktora, ale po to mamy kreatywność żeby móc sobie z tym poradzić Zapraszam do zbadania tej ewentualności na stronie: https://kursphp.com/programowanie-obiektowe-php/konstruktor/

<?php
// PHP ma TYLKO JEDEN konstruktor, ale możemy symulować wiele:

class Uzytkownik {
    private string $imie;
    private string $email;
    
    // Jedyny prawdziwy konstruktor
    private function __construct(string $imie, string $email) {
        $this->imie = $imie;
        $this->email = $email;
    }
    
    // Statyczne metody fabrykujące (factory methods) - symulacja wielu konstruktorów
    public static function zLoginu(string $login): self {
        // Pobierz dane z bazy po loginie
        return new self($login, "$login@example.com");
    }
    
    public static function zEmail(string $email): self {
        // Pobierz dane z bazy po email
        $login = explode('@', $email)[0];
        return new self($login, $email);
    }
}

// Użycie - wygląda jak różne konstruktory:
$user1 = Uzytkownik::zLoginu('jan123');
$user2 = Uzytkownik::zEmail('anna@example.com');

Destruktor – __destruct

Destruktor wykonuje się w momencie niszczenia obiektu.

Przykład użycia konstruktora i destruktora:

<?php
class GraczOnline {
    private $nick;
    private $poziom;

    public function __construct(string $nick, int $poziom) {
        $this->nick = $nick;
        $this->poziom = $poziom;
        echo "Gracz {$this->nick} dołączył do gry!<br>";
    }

    public function getNick(): string {
        return $this->nick;
    }

    public function getPoziom(): int {
        return $this->poziom;
    }

    public function __destruct() {
        echo "Gracz {$this->nick} opuścił grę!<br>";
    }
}

$gracz = new GraczOnline('ProGamer99', 45);
echo 'Nick: ' . $gracz->getNick() . ', Poziom: ' . $gracz->getPoziom() . '<br>';

unset($gracz);  // Usuwanie obiektu
// Wynik: Gracz ProGamer99 opuścił grę!
?>

Inne popularne metody magiczne

// __call() - wywoływana gdy metoda nie istnieje
public function __call($name, $arguments) {
    echo "Próba wywołania nieistniejącej metody: $name";
}

// __isset() - sprawdzanie czy właściwość istnieje
public function __isset($name) {
    return isset($this->data[$name]);
}

// __unset() - usuwanie właściwości
public function __unset($name) {
    unset($this->data[$name]);
}

// __clone() - klonowanie obiektu
public function __clone() {
    echo "Obiekt został sklonowany";
}

Więcej informacji na temat metod magicznych znajdziesz w dokumentacji: http://php.net/manual/en/language.oop5.magic.php

Stałe

Stała to właściwość klasy tylko do odczytu. Jak wiemy z języka PHP, stałe deklarujemy drukowanymi literami, są dostępne public i nie można ich modyfikować w kodzie.

Aby zadeklarować stałą, używaliśmy dotychczas konstrukcji define(), możemy to też zrobić używając modyfikatora const. Pamiętać należy, że jedna i druga konstrukcja nie są sobie równe.  Za pomocą const definiujemy stałe w klasach i tylko w nich.

Aby się do niej odwołać wewnątrz klasy, musimy użyć modyfikatora self::

Aby wywołać właściwość poza klasą używamy modyfikatora nazwaKlasy::

<?php
class KonfiguracjaGry {
    const MAX_GRACZY = 100;
    const MIN_POZIOM = 1;
    const MAX_POZIOM = 100;
    
    private $liczbaGraczy;
    
    public function __construct($liczbaGraczy) {
        $this->liczbaGraczy = $liczbaGraczy;
    }
    
    public function mozeDolczyc() {
        return $this->liczbaGraczy < self::MAX_GRACZY;
    }
}

// KonfiguracjaGry::MAX_GRACZY = 200;  // Nie można modyfikować

$gra = new KonfiguracjaGry(85);
echo 'Czy można dołączyć: ' . ($gra->mozeDolczyc() ? 'TAK' : 'NIE') . '<br>';
echo 'Maksymalna liczba graczy: ' . KonfiguracjaGry::MAX_GRACZY . '<br>';
echo 'Maksymalny poziom: ' . KonfiguracjaGry::MAX_POZIOM . '<br>';
?>

Metody i właściwości statyczne

Metody i właściwości statyczne to takie, które nie wymagają utworzenia obiektu, aby móc się do nich odwołać. Nadawane są dla całej klasy. Tworzymy je przy pomocy modyfikatora static.

Z racji tego, że właściwość ta nadawana jest dla klasy (nie dla obiektu), aby się do niej odwołać wewnątrz klasy, musimy użyć modyfikatora self::, nie korzystamy w tym przypadku z $this. Aby wywołać właściwość poza klasą używamy modyfikatora nazwaKlasy::

<?php
class LicznikGraczy {
    public static $iloscGraczy = 0;
    
    public function __construct() {
        self::$iloscGraczy++;
    }
}

echo 'Graczy online: ' . LicznikGraczy::$iloscGraczy . '<br>';  // Wartość początkowa: 0

$gracz1 = new LicznikGraczy();
$gracz2 = new LicznikGraczy();
$gracz3 = new LicznikGraczy();

echo 'Graczy online: ' . LicznikGraczy::$iloscGraczy . '<br>';  // Wartość po dodaniu: 3
?>

Klasy i metody abstrakcyjne

Klasa abstrakcyjna definiuje pewien model i zachowanie obiektu.

Taka klasa nie posiada definicji tych metod, jedynie ich deklaracje, że gdzieś dalej w kodzie muszą się pojawić. Czyli do czasu rozszerzenia ich o funkcjonalności w klasach dziedziczących, te metody nie istnieją (są abstrakcją).

Metody abstrakcyjne definiujemy w klasie bazowej klauzulą abstract. Wszystkie tego typu zadeklarowane metody będą musiały pojawić się w klasach dziedziczących. Jeśli nie pojawią się, to PHP wygeneruje nam błąd.

Nie można utworzyć obiektu klasy abstrakcyjnej. Klasa ta jest jedynie „bazą” dla klas potomnych.

Pamiętamy, że klasę dziedziczymy i możemy zrobić to tylko raz.

<?php
abstract class PostacGry {
    abstract public function getNazwa();
    abstract public function atak();
}

class Mag extends PostacGry {
    public function getNazwa() {
        return 'Mag';
    }
    
    public function atak() {
        return 'Rzuca zaklęcie!';
    }
}

class Wojownik extends PostacGry {
    public function getNazwa() {
        return 'Wojownik';
    }
    
    public function atak() {
        return 'Uderza mieczem!';
    }
}

$mag = new Mag();
echo $mag->getNazwa() . ': ' . $mag->atak() . '<br>';

$wojownik = new Wojownik();
echo $wojownik->getNazwa() . ': ' . $wojownik->atak() . '<br>';
?>

Interfejsy

Interfejs jest zbiorem metod jakie wymagamy by posiadała klasa, która go implementuje.

Możemy implementować wiele interfejsów dla jednej klasy.

Wszystkie metody określane w interfejsie są abstrakcyjne.

<?php
interface PostacInterface {
    public function getNazwa(): string;
    public function getPoziom(): int;
}

interface WalkaInterface {
    public function atak(): string;
    public function obrona(): string;
}

class Bohater implements PostacInterface, WalkaInterface {
    private $nazwa;
    private $poziom;
    
    public function __construct(string $nazwa, int $poziom) {
        $this->nazwa = $nazwa;
        $this->poziom = $poziom;
    }
    
    public function getNazwa(): string {
        return $this->nazwa;
    }

    public function getPoziom(): int {
        return $this->poziom;
    }

    public function atak(): string {
        return "{$this->nazwa} atakuje!";
    }
    
    public function obrona(): string {
        return "{$this->nazwa} broni się!";
    }
}

$bohater = new Bohater('Aragorn', 50);
echo $bohater->getNazwa() . '<br>';
echo 'Poziom: ' . $bohater->getPoziom() . '<br>';
echo $bohater->atak() . '<br>';
echo $bohater->obrona() . '<br>';
?>

Różnice między interfejsem, a klasą abstrakcyjną

• klasa może implementować wiele interfejsów, ale rozszerzać tylko jednego rodzica
• metody w interfejsie są publiczne, w klasie publiczne lub chronione
• interfejs może zawierać tylko deklaracje metod, a klasa też metody zdefiniowane
• klasy abstrakcyjne mogą zawierać atrybuty(pola), interfejsy nie
• w interfejsach wszystkie metody są abstrakcyjne, natomiast w klasie abstrakcyjnej można stworzyć metody posiadające ciało, jak i abstrakcyjne
• klasa abstrakcyjna zazwyczaj jest ściśle związana z klasami dziedziczącymi w sensie logicznym, czyli np. tworzymy klasę abstrakcyjną Planeta po której dziedziczą konkretne klasy planet (np. Ziemia, Mars). Interfejs natomiast nie musi być już tak mocno związany z daną klasą, on określa jej cechy, np możesz stworzyć interfejs Zniszczalny, który mówi że dany obiekt może zostać zniszczony. Taki interfejs możesz nadać zarówno klasą Planeta, Gwiazda, Budynek itp.
• interfejs może dziedziczyć jedynie po innych interfejsach, a klasa abstrakcyjna może dziedziczyć po klasach abstrakcyjnych, interfejsach a nawet zwykłych klasach
• interfejs nie może mieć konstruktora, w klasie abstrakcyjnej możemy dostarczyć implementację konstruktora domyślnego

<?php
// PHP 8.0+ - interfejsy mogą mieć metody z implementacją (rzadko używane)
interface Logger {
    public function log(string $message): void;
    
    // PHP 8.0+ - metoda z implementacją w interfejsie
    public function logError(string $message): void {
        $this->log("ERROR: " . $message);
    }
}

Przestrzenie nazw

Przestrzenie nazw pozwalają na zadeklarowanie wielu klas lub funkcji o tej samej nazwie.

W programowaniu jak w życiu, tak samo jak nie mogą w jednym folderze istnieć 2 pliki o tej samej nazwie i rozszerzeniu, tak samo w kodzie PHP dwie tak samo nazwane funkcje lub klasy generują błąd.

Przestrzenie nazw PHP umożliwiają grupowanie powiązanych klas, interfejsów, funkcji i stałych.

Zalecane jest tworzenie jednej przestrzeni nazw w jednym pliku.

<?php
// Przestrzenie nazw pozwalają na organizację kodu i unikanie konfliktów nazw

// Przykład problemu BEZ przestrzeni nazw:
// Jeśli masz dwie biblioteki, które mają klasę o nazwie User, będzie konflikt:

// biblioteka1.php
class User { }

// biblioteka2.php
class User { }  // BŁĄD! Klasa User już istnieje

// --------------------------------------------------

// Rozwiązanie Z przestrzeniami nazw:

// biblioteka1.php
namespace Biblioteka1;
class User { }

// biblioteka2.php
namespace Biblioteka2;
class User { }

// Teraz możesz używać obu:
use Biblioteka1\User as User1;
use Biblioteka2\User as User2;

$user1 = new User1();
$user2 = new User2();

Przestrzenie nazw działają jak foldery w systemie plików

Zalecane jest: jedna przestrzeń nazw = jeden plik

Konwencja: odpowiadają strukturze folderów (PSR-4)

Więcej w dokumentacji

PHP 8 – nowości

1. Typed Properties (właściwości typowane)

PHP 8 pozwala na określenie typu dla właściwości klasy:

<?php
class GraczOnline {
    public string $nick;
    public int $poziom;
    public float $hp;
    public bool $premium;
    
    public function __construct(string $nick, int $poziom) {
        $this->nick = $nick;
        $this->poziom = $poziom;
        $this->hp = 100.0;
        $this->premium = false;
    }
}

$gracz = new GraczOnline('ProGamer', 45);
// $gracz->poziom = 'tekst';  // Błąd: Typ musi być int
?>

2. Constructor Property Promotion

PHP 8 pozwala na zwięzłe deklarowanie właściwości bezpośrednio w konstruktorze:

<?php
// PHP 7 - długie
class GraczStary {
    private string $nick;
    private int $poziom;
    
    public function __construct(string $nick, int $poziom) {
        $this->nick = $nick;
        $this->poziom = $poziom;
    }
}

// PHP 8 - zwięzłe
class GraczNowy {
    public function __construct(
        private string $nick,
        private int $poziom,
        private float $hp = 100.0
    ) {}
}

$gracz = new GraczNowy('ProGamer', 45);
?>

3. Named Arguments

PHP 8 pozwala na przekazywanie argumentów po nazwie:

<?php
class PostacGry {
    public function __construct(
        private string $imie,
        private int $poziom = 1,
        private int $hp = 100,
        private int $mana = 50
    ) {}
}

// PHP 7 - musimy podać wszystkie
$postac1 = new PostacGry('Gandalf', 1, 100, 200);

// PHP 8 - możemy pominąć środkowe
$postac2 = new PostacGry(
    imie: 'Gandalf',
    mana: 200,
    poziom: 50
);
?>

4. Match Expression

PHP 8 wprowadza match jako lepszą alternatywę dla switch:

<?php
class SystemRang {
    public function getRanga(int $punkty): string {
        // PHP 7 - switch
        switch (true) {
            case $punkty < 1000:
                return 'Brązowy';
            case $punkty < 2000:
                return 'Srebrny';
            case $punkty < 3000:
                return 'Złoty';
            default:
                return 'Diamentowy';
        }
        
        // PHP 8 - match (zwięzłe i bezpieczniejsze)
        return match (true) {
            $punkty < 1000 => 'Brązowy',
            $punkty < 2000 => 'Srebrny',
            $punkty < 3000 => 'Złoty',
            default => 'Diamentowy'
        };
    }
}
?>

5. Nullsafe Operator

PHP 8 wprowadza operator ?-> który zapobiega błędom przy null:

<?php
class Ekwipunek {
    public ?Bron $bron = null;
}

class Bron {
    public string $nazwa;
}

$gracz = new stdClass();
$gracz->ekwipunek = new Ekwipunek();

// PHP 7 - długie sprawdzanie
$nazwaBroni = null;
if ($gracz->ekwipunek !== null && $gracz->ekwipunek->bron !== null) {
    $nazwaBroni = $gracz->ekwipunek->bron->nazwa;
}

// PHP 8 - nullsafe operator
$nazwaBroni = $gracz->ekwipunek?->bron?->nazwa;
?>

6. Union Types

PHP 8 pozwala na określenie wielu typów dla jednego parametru:

<?php
class Gracz {
    // Może być int lub string
    public function setId(int|string $id): void {
        // ...
    }
    
    // Może zwrócić PostacGry lub null
    public function znajdzPostac(string $nazwa): PostacGry|null {
        // ...
    }
}
?>

Przykłady

Przykład 1: System Streamingu na Twitchu – przykład z obszernym komentarzem w kodzie

<?php
/*
 * ==========================================
 * KLASA STREAMER - System Streamingu Twitch
 * ==========================================
 * 
 * Ta klasa reprezentuje streamera na platformie Twitch.
 * Każdy streamer ma:
 * - pseudonim (nick)
 * - liczbę subskrybcji
 * - liczbę followerów
 * - status online/offline
 */

class Streamer {
    
    /*
     * KONSTRUKTOR - metoda automatycznie wywoływana przy tworzeniu obiektu
     * 
     * PHP 8 - Constructor Property Promotion:
     * Parametry konstruktora automatycznie stają się właściwościami klasy.
     * To skrót, który oszczędza pisanie kodu.
     * 
     * Tradycyjny sposób (PHP 7):
     * -------------------------
     * private string $nick;
     * public function __construct(string $nick) {
     *     $this->nick = $nick;
     * }
     * 
     * Nowy sposób (PHP 8):
     * --------------------
     * public function __construct(private string $nick) {}
     * 
     * Oba robią to samo, ale PHP 8 jest krócej!
     */
    public function __construct(
        private string $nick,              // Pseudonim streamera (WYMAGANE - brak wartości domyślnej)
        private int $subskrybcje = 0,      // Liczba subskrybcji (domyślnie 0)
        private int $followers = 0,         // Liczba followerów (domyślnie 0)
        private bool $czyOnline = false    // Status online (domyślnie false = offline)
    ) {
        /*
         * Ciało konstruktora jest PUSTE {}, ponieważ PHP 8 automatycznie:
         * 1. Tworzy prywatne właściwości: $nick, $subskrybcje, $followers, $czyOnline
         * 2. Przypisuje im wartości przekazane przy tworzeniu obiektu
         * 
         * Gdybyśmy chcieli coś dodatkowego zrobić przy tworzeniu obiektu,
         * moglibyśmy napisać tu dodatkowy kod, np:
         * echo "Utworzono konto dla {$this->nick}!";
         */
    }
    
    /*
     * METODA: rozpocznijStream()
     * --------------------------
     * Uruchamia stream - zmienia status streamera na "online"
     * 
     * public - metoda jest dostępna z zewnątrz klasy
     * void - metoda nie zwraca żadnej wartości (tylko wykonuje akcję)
     */
    public function rozpocznijStream(): void {
        // Zmieniamy właściwość $czyOnline na true
        // $this-> oznacza "tego obiektu" (tego konkretnego streamera)
        $this->czyOnline = true;
        
        // Wyświetlamy komunikat
        // {$this->nick} wstawia wartość właściwości $nick do tekstu
        echo "{$this->nick} rozpoczął stream!<br>";
    }
    
    /*
     * METODA: zakonczStream()
     * -----------------------
     * Kończy stream - zmienia status streamera na "offline"
     */
    public function zakonczStream(): void {
        // Ustawiamy status na offline
        $this->czyOnline = false;
        
        // Wyświetlamy komunikat
        echo "{$this->nick} zakończył stream!<br>";
    }
    
    /*
     * METODA: dodajSuba()
     * -------------------
     * Dodaje jedną subskrybcję do konta streamera
     * 
     * Dlaczego metoda zamiast bezpośredniego dostępu?
     * ------------------------------------------------
     * Właściwość $subskrybcje jest PRIVATE, więc nie można jej zmienić z zewnątrz:
     * 
     * ŹLE (nie zadziała):
     *   $streamer->subskrybcje = 999;  // BŁĄD! Właściwość jest private
     * 
     * DOBRZE (zadziała):
     *   $streamer->dodajSuba();  // OK! Używamy publicznej metody
     * 
     * Zalety tego podejścia:
     * - Kontrola: możemy dodać walidację (np. sprawdzić czy sub jest ważny)
     * - Bezpieczeństwo: nikt nie ustawi liczby subów na -100
     * - Logika biznesowa: możemy dodać dodatkowe akcje (np. powiadomienia)
     */
    public function dodajSuba(): void {
        // Operator ++ zwiększa wartość o 1
        // Równoznaczne z: $this->subskrybcje = $this->subskrybcje + 1;
        $this->subskrybcje++;
        
        // Wyświetlamy komunikat z aktualną liczbą subów
        echo "Nowy sub! Razem: {$this->subskrybcje}<br>";
        
        /*
         * MIEJSCE NA ROZBUDOWĘ:
         * Tutaj moglibyśmy dodać dodatkową logikę, np:
         * 
         * if ($this->subskrybcje % 100 == 0) {
         *     echo "MILESTONE! {$this->subskrybcje} subów!<br>";
         * }
         * 
         * Albo:
         * if ($this->subskrybcje == 1000) {
         *     echo "Gratulacje! 1000 subskrypcji!<br>";
         * }
         */
    }
    
    /*
     * METODA: wyswietlStatus()
     * ------------------------
     * Wyświetla pełny status streamera:
     * - pseudonim
     * - czy jest online/offline
     * - liczba subskrybcji
     * - liczba followerów
     */
    public function wyswietlStatus(): void {
        /*
         * OPERATOR TRÓJARGUMENTOWY (ternary operator):
         * -------------------------------------------
         * Składnia: warunek ? wartość_jeśli_prawda : wartość_jeśli_fałsz
         * 
         * Długa wersja (identyczne działanie):
         * if ($this->czyOnline == true) {
         *     $status = 'LIVE';
         * } else {
         *     $status = 'OFFLINE';
         * }
         * 
         * Krótka wersja:
         * $status = $this->czyOnline ? 'LIVE' : 'OFFLINE';
         */
        $status = $this->czyOnline ? 'LIVE' : 'OFFLINE';
        
        // Wyświetlamy nagłówek z pseudonimem i statusem
        echo "--- {$this->nick} [{$status}] ---<br>";
        
        // Wyświetlamy szczegóły
        echo "Subskrybcje: {$this->subskrybcje}<br>";
        echo "Followersi: {$this->followers}<br>";
    }
}

/*
 * ==========================================
 * UŻYCIE KLASY - Tworzenie obiektu i praca z nim
 * ==========================================
 */

/*
 * TWORZENIE OBIEKTU (instancji klasy):
 * ------------------------------------
 * Słowo kluczowe 'new' tworzy nowy obiekt na podstawie klasy Streamer
 * 
 * new Streamer(...) wywołuje konstruktor i przekazuje do niego argumenty:
 * - 'GamingLegend' → przypisane do $nick
 * - 150 → przypisane do $subskrybcje
 * - 5000 → przypisane do $followers
 * - $czyOnline nie podane, więc dostaje wartość domyślną: false
 * 
 * Obiekt zapisujemy w zmiennej $streamer
 */
$streamer = new Streamer('GamingLegend', 150, 5000);

/*
 * Co się stało w pamięci?
 * -----------------------
 * Utworzono obiekt $streamer z następującymi wartościami:
 * 
 * $streamer:
 *   ├─ $nick = 'GamingLegend'
 *   ├─ $subskrybcje = 150
 *   ├─ $followers = 5000
 *   └─ $czyOnline = false
 */

// WYWOŁANIE METODY: wyswietlStatus()
// ----------------------------------
// Operator -> służy do wywoływania metod i dostępu do właściwości obiektu
// Wywołujemy metodę wyswietlStatus() na obiekcie $streamer
$streamer->wyswietlStatus();
/*
 * Wyświetli:
 * --- GamingLegend [OFFLINE] ---
 * Subskrybcje: 150
 * Followersi: 5000
 */

echo "<br>"; // Odstęp dla czytelności

// WYWOŁANIE METODY: rozpocznijStream()
// ------------------------------------
// Zmieniamy status streamera na "online"
$streamer->rozpocznijStream();
/*
 * Dzieje się:
 * 1. $czyOnline zmienia się na true
 * 2. Wyświetla się: GamingLegend rozpoczął stream!
 */

// WYWOŁANIE METODY: dodajSuba() - pierwsze wywołanie
// --------------------------------------------------
// Dodajemy pierwszą subskrybcję
$streamer->dodajSuba();
/*
 * Dzieje się:
 * 1. $subskrybcje zwiększa się z 150 do 151
 * 2. Wyświetla się: Nowy sub! Razem: 151
 */

// WYWOŁANIE METODY: dodajSuba() - drugie wywołanie
// ------------------------------------------------
// Dodajemy kolejną subskrybcję
$streamer->dodajSuba();
/*
 * Dzieje się:
 * 1. $subskrybcje zwiększa się z 151 do 152
 * 2. Wyświetla się: Nowy sub! Razem: 152
 */

// WYWOŁANIE METODY: zakonczStream()
// ---------------------------------
// Kończymy stream
$streamer->zakonczStream();
/*
 * Dzieje się:
 * 1. $czyOnline zmienia się na false
 * 2. Wyświetla się: GamingLegend zakończył stream!
 */

echo "<br>"; // Odstęp dla czytelności

// WYWOŁANIE METODY: wyswietlStatus() - ponownie
// ---------------------------------------------
// Wyświetlamy status po zakończeniu streamu
$streamer->wyswietlStatus();
/*
 * Wyświetli:
 * --- GamingLegend [OFFLINE] ---
 * Subskrybcje: 152  <-- Zauważ: zwiększyło się z 150 do 152
 * Followersi: 5000
 * 
 * Status zmienił się z LIVE na OFFLINE
 */

/*
 * ==========================================
 * PEŁNY OUTPUT PROGRAMU:
 * ==========================================
 * 
 * --- GamingLegend [OFFLINE] ---
 * Subskrybcje: 150
 * Followersi: 5000
 * 
 * GamingLegend rozpoczął stream!
 * Nowy sub! Razem: 151
 * Nowy sub! Razem: 152
 * GamingLegend zakończył stream!
 * 
 * --- GamingLegend [OFFLINE] ---
 * Subskrybcje: 152
 * Followersi: 5000
 */

/*
 * ==========================================
 * DODATKOWE PRZYKŁADY - Tworzenie wielu streamerów
 * ==========================================
 */

echo "<hr><h3>Dodatkowe przykłady:</h3>";

// Przykład 1: Nowy streamer z minimalnymi danymi
// ----------------------------------------------
// Podajemy tylko nick (reszta dostanie wartości domyślne)
$nowyStreamer = new Streamer('RookiePlayer');
/*
 * Wartości:
 * - $nick = 'RookiePlayer'
 * - $subskrybcje = 0 (domyślna)
 * - $followers = 0 (domyślna)
 * - $czyOnline = false (domyślna)
 */

$nowyStreamer->wyswietlStatus();
/*
 * Wyświetli:
 * --- RookiePlayer [OFFLINE] ---
 * Subskrybcje: 0
 * Followersi: 0
 */

echo "<br>";

// Przykład 2: Wielki streamer
// ---------------------------
$megaStreamer = new Streamer('xQcOW', 85000, 1500000);
$megaStreamer->rozpocznijStream();
$megaStreamer->wyswietlStatus();
/*
 * Wyświetli:
 * xQcOW rozpoczął stream!
 * --- xQcOW [LIVE] ---
 * Subskrybcje: 85000
 * Followersi: 1500000
 */

echo "<br>";

// Przykład 3: Porównanie dwóch streamerów
// ----------------------------------------
echo "<h4>Porównanie streamerów:</h4>";

$streamer1 = new Streamer('Ninja', 75000, 180000);
$streamer2 = new Streamer('Shroud', 50000, 100000);

// Obaj zaczynają stream
$streamer1->rozpocznijStream();
$streamer2->rozpocznijStream();

echo "<br>";

// Wyświetlamy ich statusy
echo "Status Ninja:<br>";
$streamer1->wyswietlStatus();

echo "<br>";

echo "Status Shroud:<br>";
$streamer2->wyswietlStatus();

/*
 * WAŻNA OBSERWACJA:
 * -----------------
 * Każdy obiekt ($streamer1, $streamer2) ma WŁASNE wartości właściwości.
 * Zmiana wartości w jednym obiekcie NIE WPŁYWA na drugi obiekt.
 * 
 * To tak jakby mieć dwa oddzielne konta na Twitchu - każde jest niezależne.
 */

/*
 * ==========================================
 * KLUCZOWE POJĘCIA - PODSUMOWANIE:
 * ==========================================
 * 
 * 1. KLASA (class):
 *    - Szablon/przepis na tworzenie obiektów
 *    - Definiuje jakie właściwości i metody będą miały obiekty
 * 
 * 2. OBIEKT (object/instancja):
 *    - Konkretny "egzemplarz" utworzony na podstawie klasy
 *    - Tworzy się słowem kluczowym 'new'
 * 
 * 3. WŁAŚCIWOŚCI (properties):
 *    - Zmienne należące do obiektu
 *    - W naszym przykładzie: $nick, $subskrybcje, $followers, $czyOnline
 * 
 * 4. METODY (methods):
 *    - Funkcje należące do klasy
 *    - Operują na właściwościach obiektu
 *    - W naszym przykładzie: rozpocznijStream(), dodajSuba(), wyswietlStatus()
 * 
 * 5. $this:
 *    - Odnosi się do "bieżącego obiektu"
 *    - Używamy go w metodach aby dostać się do właściwości obiektu
 * 
 * 6. MODYFIKATORY DOSTĘPU:
 *    - private: dostęp tylko wewnątrz klasy
 *    - public: dostęp z każdego miejsca
 * 
 * 7. KONSTRUKTOR (__construct):
 *    - Specjalna metoda wywoływana automatycznie przy tworzeniu obiektu
 *    - Służy do inicjalizacji (ustawienia początkowych wartości)
 * 
 * 8. OPERATOR -> :
 *    - Służy do dostępu do właściwości i metod obiektu
 *    - Składnia: $obiekt->metoda() lub $obiekt->właściwość
 */
?>

Przykład z wizualizacją stanu obiektów

<?php
// Wizualizacja jak zmieniają się dane w obiekcie

echo "<h3>Śledzenie zmian w obiekcie krok po kroku:</h3>";

// Krok 1: Tworzenie obiektu
echo "<strong>KROK 1: Tworzenie obiektu</strong><br>";
$streamer = new Streamer('TestStreamer', 10, 100);
echo "Utworzono streamera. Stan obiektu:<br>";
$streamer->wyswietlStatus();
/*
 * Stan obiektu:
 * $nick = 'TestStreamer'
 * $subskrybcje = 10
 * $followers = 100
 * $czyOnline = false
 */

echo "<br><hr>";

// Krok 2: Rozpoczęcie streamu
echo "<strong>KROK 2: Rozpoczęcie streamu</strong><br>";
$streamer->rozpocznijStream();
echo "Stan obiektu po rozpoczęciu:<br>";
$streamer->wyswietlStatus();
/*
 * Stan obiektu:
 * $nick = 'TestStreamer'
 * $subskrybcje = 10
 * $followers = 100
 * $czyOnline = true  <-- ZMIANA!
 */

echo "<br><hr>";

// Krok 3: Dodanie 3 subskrybcji
echo "<strong>KROK 3: Dodanie 3 subskrybcji</strong><br>";
$streamer->dodajSuba();
$streamer->dodajSuba();
$streamer->dodajSuba();
echo "Stan obiektu po dodaniu subów:<br>";
$streamer->wyswietlStatus();
/*
 * Stan obiektu:
 * $nick = 'TestStreamer'
 * $subskrybcje = 13  <-- ZMIANA! (było 10, teraz 13)
 * $followers = 100
 * $czyOnline = true
 */

echo "<br><hr>";

// Krok 4: Zakończenie streamu
echo "<strong>KROK 4: Zakończenie streamu</strong><br>";
$streamer->zakonczStream();
echo "Stan obiektu po zakończeniu:<br>";
$streamer->wyswietlStatus();
/*
 * Stan obiektu:
 * $nick = 'TestStreamer'
 * $subskrybcje = 13
 * $followers = 100
 * $czyOnline = false  <-- ZMIANA!
 */

echo "<br><hr>";

// Podsumowanie
echo "<strong>PODSUMOWANIE ZMIAN:</strong><br>";
echo "Początek: 10 subskrybcji, OFFLINE<br>";
echo "Koniec: 13 subskrybcji, OFFLINE<br>";
echo "Różnica: +3 subskrybcje<br>";
?>

Przykład 2: OOP obsługujące fabrykę samochodów

<?php

// Klasa bazowa dla fabryki Chevrolet
class ChevroletFactory {
    // Stała reprezentująca maksymalną pojemność produkcji
    const MAX_CAPACITY = 500;

    // Właściwości klasy
    protected $brand = "Chevrolet";
    protected $producedCars = 0;

    // Konstruktor inicjalizuje fabrykę
    public function __construct() {
        echo "Fabryka marki {$this->brand} została otwarta.<br>";
    }

    // Metoda do produkcji samochodów
    public function produceCar($quantity) {
        if ($this->producedCars + $quantity > self::MAX_CAPACITY) {
            echo "Nie można wyprodukować $quantity samochodów. Przekroczono maksymalną pojemność produkcyjną.<br>";
        } else {
            $this->producedCars += $quantity;
            echo "Wyprodukowano $quantity samochodów. Łączna produkcja: {$this->producedCars}.<br>";
        }
    }

    // Metoda do wyświetlenia statusu produkcji
    public function factoryStatus() {
        echo "Fabryka marki {$this->brand} wyprodukowała {$this->producedCars} samochodów.<br>";
    }

    // Magiczna metoda __get. Obsługuje odczyt nieistniejących właściwości.
    public function __get($name) {
        echo "Próba dostępu do właściwości '{$name}', która nie istnieje.<br>";
        return null;
    }

    // Magiczna metoda __set. Obsługuje próbę ustawienia niedozwolonych właściwości.
    public function __set($name, $value) {
        echo "Próba ustawienia właściwości '{$name}' na wartość '{$value}'. Operacja niedozwolona!<br>";
    }

    // Magiczna metoda __toString, która pozwoli na łatwą reprezentację obiektu jako tekst
    public function __toString() {
        return "Fabryka marki {$this->brand}: wyprodukowano {$this->producedCars} samochodów. Maksymalna pojemność: " . self::MAX_CAPACITY . ".<br>";
    }

    // Destruktor wyświetla komunikat o zamknięciu fabryki i wyprodukowanej liczbie samochodów.
    // Destruktor - wywoływany automatycznie gdy:
    // 1. Kończy się skrypt
    // 2. Obiekt jest usuwany przez unset()
    // 3. Obiekt jest nadpisywany przez nowy
    public function __destruct() {
        echo "Fabryka marki {$this->brand} została zamknięta. Łączna produkcja: {$this->producedCars} samochodów.<br>";
    }
}

// Klasa pochodna dla modelu Camaro
class Camaro extends ChevroletFactory {
    public $modelName = "Camaro";
    private $engineType;

    // Konstruktor klasy pochodnej
    public function __construct($engineType) {
        parent::__construct(); // Wywołanie konstruktora klasy bazowej
        $this->engineType = $engineType;
        echo "Rozpoczęto produkcję modelu {$this->modelName} z silnikiem {$this->engineType}.<br>";
    }
}

// Klasa pochodna dla modelu Corvette
class Corvette extends ChevroletFactory {
    public $modelName = "Corvette";
    private $color;

    // Konstruktor klasy pochodnej
    public function __construct($color) {
        parent::__construct(); // Wywołanie konstruktora klasy bazowej
        $this->color = $color;
        echo "Rozpoczęto produkcję modelu {$this->modelName} w kolorze {$this->color}.<br>";
    }
}

// Przykład użycia
echo "==== Fabryka Chevrolet ====<br>";

// Tworzenie fabryki dla Camaro
$camaroFactory = new Camaro("V8");
$camaroFactory->produceCar(100); // Produkcja 100 samochodów
$camaroFactory->produceCar(450); // Przekroczenie pojemności
echo $camaroFactory; // Wywołanie __toString
echo $camaroFactory->nonExistentProperty; // Magiczne __get
$camaroFactory->nonExistentProperty = "Test"; // Magiczne __set
$camaroFactory->factoryStatus(); // Status fabryki

echo "<br>==== Fabryka Corvette ====<br>";

// Tworzenie fabryki dla Corvette
$corvetteFactory = new Corvette("Czerwony");
$corvetteFactory->produceCar(200); // Produkcja 200 samochodów
echo $corvetteFactory; // Wywołanie __toString
$corvetteFactory->factoryStatus(); // Status fabryki

// Destruktory wywołają się automatycznie po zakończeniu skryptu
?>

Klasa ChevroletFactory jest klasą bazową, która reprezentuje fabrykę samochodów marki Chevrolet. W tej klasie definiujemy:

• Stałą MAX_CAPACITY:
  Stała MAX_CAPACITY określa maksymalną liczbę samochodów, które mogą być wyprodukowane przez fabrykę. Wartość ta jest stała i niezmienna, wynosi 500 w naszym przypadku.

• Właściwości $brand i $producedCars:
  • $brand to nazwa marki fabryki, w tym przypadku „Chevrolet”.
  • $producedCars to liczba wyprodukowanych samochodów przez fabrykę, początkowo ustawiona na 0.
• Konstruktor: Konstruktor jest wywoływany, gdy tworzony jest nowy obiekt klasy ChevroletFactory. W momencie tworzenia fabryki, wyświetlany jest komunikat o jej otwarciu.

• Metoda produceCar($quantity): Ta metoda służy do produkcji określonej liczby samochodów. Jeśli liczba samochodów przekroczyłaby MAX_CAPACITY, metoda wyświetla komunikat o błędzie. W przeciwnym razie dodaje liczbę wyprodukowanych samochodów do właściwości $producedCars.

• Metoda __toString(): Jest to metoda magiczna, która pozwala na „przekształcenie” obiektu na ciąg tekstowy. Gdy próbujemy wydrukować obiekt, np. echo $obiekt, PHP wywołuje __toString() i wyświetla zwrócony tekst. W naszym przypadku metoda ta zwraca szczegóły dotyczące fabryki, czyli liczbę wyprodukowanych samochodów i maksymalną pojemność.

• Destruktor: Destruktor jest wywoływany, gdy obiekt jest usuwany z pamięci, co zwykle następuje, gdy skrypt kończy działanie. W naszym przypadku, destruktor wyświetla komunikat o zamknięciu fabryki i liczbie wyprodukowanych samochodów.

• Magic Methods __get i __set:

  • __get($name): Została dodana po to, aby obsługiwać przypadki, gdy próbujemy uzyskać dostęp do właściwości, która nie istnieje. W takim przypadku wyświetlamy komunikat informujący o próbie dostępu do nieistniejącej właściwości.
  • __set($name, $value): Została dodana, aby obsługiwać próbę ustawienia wartości właściwości, która nie istnieje, lub która nie jest dozwolona do ustawiania.

  Przykładowo, jeśli spróbujemy przypisać wartość do nieistniejącej właściwości, metoda __set zostanie wywołana i wyświetli komunikat.

W naszym przykładzie mamy dwie klasy pochodne:

• Camaro: Reprezentuje model samochodu Camaro. Klasa ta dziedziczy po klasie ChevroletFactory i dodaje specyficzną właściwość $engineType (typ silnika).

  Konstruktor klasy Camaro wywołuje konstruktor klasy ChevroletFactory za pomocą parent::__construct(), a następnie ustawia właściwość $engineType i wyświetla komunikat o rozpoczęciu produkcji.

• Corvette: Reprezentuje model samochodu Corvette. Podobnie jak w przypadku Camaro, dziedziczy po klasie ChevroletFactory, ale dodaje właściwość $color (kolor samochodu).

  Konstruktor klasy Corvette również wywołuje konstruktor klasy ChevroletFactory, ustawia kolor i wyświetla komunikat o rozpoczęciu produkcji.

W sekcji przykładu użycia tworzymy obiekty klasy Camaro i Corvette i wywołujemy na nich różne metody:

• Tworzymy fabrykę Camaro:

  • Tworzymy obiekt Camaro, który przyjmuje typ silnika jako argument w konstruktorze.
  • Wywołujemy metodę produceCar(), aby wyprodukować samochody, a potem wyświetlamy status fabryki przy pomocy echo i metody __toString().

• Tworzymy fabrykę Corvette:

  • Tworzymy obiekt Corvette, który przyjmuje kolor jako argument w konstruktorze.
  • Wywołujemy metodę produceCar() i ponownie wyświetlamy status fabryki przy pomocy echo i metody __toString().

Podsumowanie:

• Klasa ChevroletFactory reprezentuje fabrykę samochodów i zawiera metody do produkcji, statusu fabryki oraz metody magiczne do zarządzania właściwościami obiektów.
• Klasy pochodne (Camaro i Corvette) reprezentują konkretne modele samochodów i dziedziczą właściwości i metody klasy bazowej, dodając własne specyficzne właściwości (np. typ silnika, kolor).
• Metoda __toString() umożliwia łatwe reprezentowanie obiektu w formie tekstowej.

Każdy obiekt fabryki może produkować samochody, wyświetlać stan fabryki oraz korzystać z funkcji związanych z magią PHP (__get, __set).

Przykład 3: Postaci w grze RPG

Poniżej przedstawiam przykład wykorzystania OOP do tworzenia postaci w grze i symulowania ich walki.

<?php
// Klasa główna Postac. To podstawowa klasa, z której dziedziczą inne postacie. Ma podstawowe cechy: imię, poziom i zdrowie.

class Postac {
    // Własności
    protected $imie;
    protected $poziom;
    protected $zdrowie;

    // Konstruktor
    public function __construct($imie, $poziom = 1) {
        $this->imie = $imie;
        $this->poziom = $poziom;
        $this->zdrowie = 100;
    }

    // Metoda, która zwiększa poziom
    public function awans() {
        $this->poziom++;
        $this->zdrowie += 20;
        echo "{$this->imie} awansował na poziom {$this->poziom}! Zdrowie wynosi teraz {$this->zdrowie}.\n";
    }

    // Metoda magiczna __toString
    public function __toString() {
        return "Postać: $this->imie, Poziom: $this->poziom, Zdrowie: $this->zdrowie.";
    }
}

// Klasa Wojownik, dziedziczy po klasie Postac
class Wojownik extends Postac {
    private $sila;

    // Konstruktor
    public function __construct($imie, $poziom = 1) {
        parent::__construct($imie, $poziom);
        $this->sila = 10 + $poziom * 2;
    }

    // Atak
    public function atak() {
        echo "{$this->imie} wykonuje potężny atak mieczem, zadając {$this->sila} obrażeń!\n";
    }

    // Nadpisanie metody awans
    public function awans() {
        parent::awans();
        $this->sila += 5;
        echo "{$this->imie} zwiększył siłę do {$this->sila}.\n";
    }
}

// Klasa Mag, dziedziczy po klasie Postac
class Mag extends Postac {
    private $mana;

    // Konstruktor
    public function __construct($imie, $poziom = 1) {
        parent::__construct($imie, $poziom);
        $this->mana = 50 + $poziom * 10;
    }

    // Rzucenie zaklęcia
    public function rzucZaklecie() {
        if ($this->mana >= 10) {
            $this->mana -= 10;
            echo "{$this->imie} rzuca zaklęcie, zadając 30 obrażeń! Pozostała mana: {$this->mana}.\n";
        } else {
            echo "{$this->imie} nie ma wystarczającej ilości many!\n";
        }
    }

    // Nadpisanie metody awans
    public function awans() {
        parent::awans();
        $this->mana += 20;
        echo "{$this->imie} zwiększył manę do {$this->mana}.\n";
    }
}

// Tworzenie postaci
$wojownik = new Wojownik("Thor");
$mag = new Mag("Gandalf");

// Wypisanie informacji o postaciach
echo $wojownik . "\n"; // Wyświetla: Postać: Thor, Poziom: 1, Zdrowie: 100.
echo $mag . "\n";      // Wyświetla: Postać: Gandalf, Poziom: 1, Zdrowie: 100.

// Akcje postaci
$wojownik->atak();       // Thor wykonuje potężny atak mieczem, zadając 12 obrażeń!
$mag->rzucZaklecie();    // Gandalf rzuca zaklęcie, zadając 30 obrażeń! Pozostała mana: 50.

// Awansowanie postaci
$wojownik->awans();      // Thor awansował na poziom 2! Zdrowie wynosi teraz 120. Zwiększył siłę do 17.
$mag->awans();           // Gandalf awansował na poziom 2! Zdrowie wynosi teraz 120. Zwiększył manę do 80.

echo $wojownik . "\n";   // Wyświetla: Postać: Thor, Poziom: 2, Zdrowie: 120.
echo $mag . "\n";        // Wyświetla: Postać: Gandalf, Poziom: 2, Zdrowie: 120.

Wyjaśnienie kodu:

Dziedziczenie: Klasy Wojownik i Mag dziedziczą po Postac i dodają swoje unikalne właściwości (sila, mana) oraz metody (atak, rzucZaklecie).

Konstruktor: Każda klasa ma swój konstruktor, który inicjalizuje własności. Wojownik i Mag wywołują konstruktor z klasy nadrzędnej za pomocą parent::__construct().

Metoda magiczna __toString: Pozwala reprezentować obiekt jako ciąg znaków, np. przy wywołaniu echo $obiekt.

Polimorfizm: Metoda awans() jest nadpisywana w klasach Wojownik i Mag, aby uwzględnić specyficzne zmiany.

Zadanie: rozszerz kod o kolejną postać np. łucznik

Zadanie 3: System Zarządzania Gildią Graczy

Opis zadania:

Wyobraź sobie, że zarządzasz gildią w grze MMORPG. Twoim celem jest stworzenie systemu, który pozwala dodawać graczy do gildii, zarządzać ich rangami, a także organizować misje. Każdy gracz należy do gildii i może współpracować z innymi w ramach drużyny.

Wymagania funkcjonalne:

Klasa Player:

Atrybuty:

• name – imię gracza.
• rank – ranga w gildii (np. „Rekrut”, „Członek”, „Oficer”).
• level – poziom doświadczenia gracza.
• role – rola w drużynie (np. „Tank”, „DPS”, „Healer”).

Metody:

• promote() – zwiększa rangę gracza (np. z „Rekruta” na „Członka”).
• demote() – obniża rangę gracza (np. z „Oficera” na „Członka”).

Klasa Guild:

Atrybuty:

• name – nazwa gildii.
• members – lista graczy w gildii (obiekty klasy Player).

Metody:

• add_member(player) – dodaje nowego gracza do gildii.
• remove_member(player) – usuwa gracza z gildii.
• list_members() – wyświetla listę wszystkich graczy z ich szczegółami.
• assign_team(players) – przypisuje wybranych graczy do drużyny (np. na misję).

Klasa Mission:

Atrybuty:

• name – nazwa misji.
• difficulty – poziom trudności (np. „Łatwy”, „Średni”, „Trudny”).
• required_roles – lista wymaganych ról (np. [„Tank”, „DPS”, „Healer”]).

Metody:

• is_team_eligible(team) – sprawdza, czy drużyna spełnia wymagania roli.

Rozszerzenia:

• Dodaj system zdobywania punktów doświadczenia i automatycznego awansu na wyższy poziom.
• Wprowadź ograniczenie maksymalnej liczby graczy w gildii.
• Stwórz mechanizm losowania nagród za ukończone misje.

Zadanie 4: Gra Wirtualnych Walk Robotów

Opis zadania:

Stwórz symulację walk robotów, w której każdy robot ma różne parametry, broń i strategie walki.

Wymagania:

Klasa Robot:

Atrybuty:

• name – nazwa robota.
• health – punkty życia.
• attack_power – siła ataku.
• defense – poziom obrony.
• weapon – broń robota (np. „Laser”, „Rakiety”).

Metody:

• attack(opponent) – zmniejsza punkty życia przeciwnika na podstawie siły ataku i broni.
• defend(damage) – redukuje otrzymane obrażenia na podstawie obrony.
• status() – wyświetla aktualne zdrowie robota.

Symulator walki:

Wybierz dwóch robotów i pozwól im walczyć w rundach, aż jeden z nich przegra (zdrowie spadnie do 0). W każdej rundzie roboty na przemian atakują, a wynik walki jest wyświetlany po każdej turze.

Dodatkowe funkcjonalności:

Moduł ulepszeń:

• Dodaj klasę Upgrade, która pozwala ulepszać roboty (np. zwiększać zdrowie, siłę ataku, obronę).
• Przykład: „Dodatkowe Pancerze” zwiększają defense, a „Turbo Silnik” zwiększa szybkość ataku.

Różne typy broni:

• Każda broń może mieć dodatkowe efekty, np. laser ignoruje obronę przeciwnika, a rakiety zadają obrażenia obszarowe.
• Dodaj klasę Weapon z atrybutami damage i special_effect.

Tryb turniejowy:

• Dodaj system turniejów, w którym roboty walczą w eliminacjach, aż pozostanie jeden zwycięzca.

Losowe zdarzenia:

• Wprowadź zdarzenia w trakcie walki, np. „Awaria systemu” lub „Podwójne obrażenia”.

Zadanie 5: System Kart Kolekcjonerskich

Opis zadania:

Stwórz system kart kolekcjonerskich, które mogą być zbierane, wymieniane i używane w pojedynkach.

Wymagania:

Klasa Card:

Atrybuty:

• name – nazwa karty.
• attack – siła ataku karty.
• defense – poziom obrony karty.
• rarity – rzadkość karty (np. „Zwykła”, „Rzadka”, „Legendarna”).

Metody:

• compare(card) – porównuje siłę ataku dwóch kart i zwraca zwycięzcę.

Klasa Player:

Atrybuty:

• name – imię gracza.
• deck – talia kart (lista obiektów klasy Card).

Metody:

• add_card(card) – dodaje kartę do talii gracza.
• remove_card(card) – usuwa kartę z talii.
• battle(opponent) – wybiera jedną kartę z talii i walczy z wybraną kartą przeciwnika.

Rozgrywka:

Gracze losują karty z talii i walczą w turach. Wygrywa gracz, którego karty przetrwają najdłużej.

Dodatkowe funkcjonalności:

Tworzenie własnych kart:

• Dodaj system, w którym gracz może stworzyć własną kartę, przypisując jej atak, obronę i rzadkość w ramach określonych limitów.

Efekty specjalne kart:

• Wprowadź karty z efektami, np. „Ognisty Smok” podwaja atak podczas pierwszej tury, a „Magiczna Bariera” neguje pierwszy atak przeciwnika.

Mechanizm wymiany:

• Gracze mogą wymieniać karty między sobą.
• Dodaj opcję targowania się lub ustalania cen wirtualnych.

Rozgrywka wieloosobowa:

• Wprowadź tryb, w którym gracze mogą walczyć z innymi graczami w turniejach online (symulowanych w grze).

Zadanie 6: Gra Słowna z Przeciwnikiem AI

Opis zadania:

Stwórz grę, w której gracz i przeciwnik komputerowy rywalizują, tworząc jak najdłuższe słowa z losowego zestawu liter.

Wymagania:

Klasa WordGame:

Atrybuty:

• letters – lista liter, z których można tworzyć słowa.
• player_score – wynik gracza.
• ai_score – wynik przeciwnika.

Metody:

• generate_letters() – losuje zestaw liter.
• validate_word(word) – sprawdza, czy słowo jest poprawne (np. istnieje w słowniku).
• ai_move() – komputer tworzy losowe poprawne słowo z dostępnych liter.

Rozgrywka:

Gracz wprowadza słowo, a następnie przeciwnik generuje swoje słowo. Punktacja zależy od długości słowa. Gra kończy się po określonej liczbie tur.

Dodatkowe funkcjonalności:

Tryb rywalizacji:

• Dodaj możliwość gry na czas – gracz i AI mają ograniczoną liczbę sekund na wymyślenie słowa.

Poziomy trudności AI:

• Łatwy: AI wybiera krótkie słowa.
• Średni: AI stara się tworzyć średniej długości słowa.
• Trudny: AI generuje najdłuższe możliwe słowa.

System bonusów:

• Dodaj bonusy za użycie trudnych liter (np. „Q” lub „X”) lub za stworzenie słowa dłuższego niż 7 liter.

Ulepszenie liter:

• Gracz może wymienić kilka liter na nowe za stratę punktów.

Zadanie 7: Fantasy Liga e-Sportowa

Opis zadania:

Zaprojektuj system zarządzania drużyną wirtualnych graczy e-sportowych, gdzie każda drużyna rywalizuje w turnieju.

Wymagania:

Klasa Player:

Atrybuty:

• nickname – pseudonim gracza.
• role – rola w grze (np. „Support”, „Carry”).
• skill_level – poziom umiejętności gracza.

Metody:

• train() – zwiększa poziom umiejętności gracza.
• play_match() – zmniejsza zmęczenie gracza (opcjonalnie wprowadź mechanikę kondycji).

Klasa Team:

Atrybuty:

• name – nazwa drużyny.
• players – lista obiektów klasy Player.

Metody:

• add_player(player) – dodaje gracza do drużyny.
• remove_player(player) – usuwa gracza z drużyny.
• team_power() – oblicza łączny poziom umiejętności drużyny.

Turniej:

Stwórz symulację, w której drużyny rywalizują w turnieju, a wyniki zależą od poziomu umiejętności ich graczy. Wyświetlaj wyniki każdej rundy i ogłoś zwycięzcę.

Dodatkowe funkcjonalności:

Personalizacja graczy:

• Dodaj system awatarów, imion drużyn i personalizowanych logo.

Zdarzenia losowe:

• Przykład: „Kontuzja gracza” – gracz musi zostać wymieniony przed kolejnym meczem.
• „Eksplozja formy” – tymczasowy wzrost umiejętności jednego gracza.

Ekonomia drużyny:

• Wprowadź budżet, który pozwala na zatrudnianie lepszych graczy lub inwestowanie w trening.

Symulacja pełnych rozgrywek:

• Stwórz harmonogram meczów między drużynami, a na koniec wyświetlaj tabelę wyników.

Rozgrywka interaktywna:

• Gracz może aktywnie zarządzać strategią podczas meczu (np. wybór taktyki, zmiany w drużynie).

Zadania 8: System Handlu w Grze MMORPG

Opis zadania:

Stwórz symulację handlu w grze, gdzie gracze mogą sprzedawać i kupować przedmioty od siebie.

Wymagania:

Klasa Item:

Atrybuty:

• name – nazwa przedmiotu.
• type – rodzaj przedmiotu (np. „Broń”, „Zbroja”, „Eliksir”).
• price – cena przedmiotu.

Metody:

• discount(percent) – obniża cenę przedmiotu o podany procent.

Klasa Player:

Atrybuty:

• name – imię gracza.
• inventory – lista posiadanych przedmiotów.
• gold – ilość złota gracza.

Metody:

• buy(item) – kupuje przedmiot, o ile gracz ma wystarczająco złota.
• sell(item) – sprzedaje przedmiot i zwiększa ilość złota.

Klasa Marketplace:

Atrybuty:

• items – lista dostępnych przedmiotów.

Metody:

• list_items() – wyświetla dostępne przedmioty na rynku.
• trade(buyer, seller, item) – przeprowadza transakcję między graczami.

Rozgrywka:

Gracze mogą kupować i sprzedawać przedmioty na rynku. Ceny przedmiotów mogą się zmieniać w zależności od podaży i popytu (opcjonalne).

Dodatkowe funkcjonalności:

Dynamiczna ekonomia:

• Ceny przedmiotów zmieniają się w zależności od podaży i popytu na rynku.

Dom aukcyjny:

• Gracze mogą wystawiać przedmioty na aukcje, a inni licytować je w określonym czasie.

System reputacji:

• Gracze mogą zdobywać lub tracić reputację na podstawie uczciwości w handlu.

Rzemiosło:

• Wprowadź możliwość tworzenia nowych przedmiotów z surowców, które gracze mogą kupować, sprzedawać lub zdobywać podczas misji.

Mechanizm kradzieży:

• Dodaj opcję prób kradzieży przedmiotów od innych graczy, ale z ryzykiem utraty reputacji.

TaskQuest 1.5 — zadanie i użytkownik stają się obiektami

taskquest/
├── index.php                        (zmiana: obiekt Uzytkownik, lista zadań to obiekty Zadanie, wyróżnienie zadań po terminie)
├── dodaj-zadanie.php                (zmiana: nowe zadanie to obiekt Zadanie)
├── zaloguj.php                      bez zmian
├── wyloguj.php                      bez zmian
├── diagnostyka.php                  (zmiana: nowe pliki na liście wymaganych, przegląd katalogu classes/)
├── classes/                         NOWY KATALOG — klasy
│   ├── Zadanie.php                  NOWY — klasa Zadanie
│   └── Uzytkownik.php               NOWY — klasa Uzytkownik
├── config/
│   └── config.php                   bez zmian
├── includes/
│   ├── header.php                   (zmiana: styl .po-terminie)
│   ├── footer.php                   (zmiana: "TaskQuest 1.5")
│   ├── funkcje_grywalizacji.php     bez zmian
│   ├── funkcje_tekstowe.php         bez zmian
│   ├── funkcje_terminow.php         bez zmian
│   ├── funkcje_zadan.php            (zmiana: $zadanie['...'] → $zadanie->...())
│   ├── funkcje_sesji.php            bez zmian
│   ├── funkcje_diagnostyczne.php    bez zmian
│   └── funkcje_plikow.php           (zmiana: wczytywanie tworzy obiekty, zapis czyta z obiektów)
└── data/
    └── zadania.csv                  bez zmian (format pliku się nie zmienia!)

<?php

$zadanie = [
    'id' => 1,
    'tytul' => 'Nauczyć się OOP',
    'opis' => 'Klasa, obiekt, metoda',
    'termin' => '2026-10-10',
    'wykonane' => false,
    'xp' => 30
];

echo "<p>Tytuł: " . $zadanie['tytuł'] . "</p>";   // Ola napisała „tytuł” z polską literą

$zadanie['wykonane'] = 'nie';                    // Ola „odznacza” zadanie tekstem

if ($zadanie['wykonane']) {
    echo "<p>Zadanie wykonane!</p>";
}

$zadanie['xp'] = -500;                           // nic tego nie zabrania

$inneZadanie = ['id' => 2, 'tytul' => 'Zadanie bez terminu'];   // brakuje czterech kluczy

echo "<p>Koniec skryptu.</p>";

$poziom = obliczPoziom($xp);
$tytul = pobierzTytul($poziom);
$brakujeXp = ileBrakujeXp($xp, $poziom);     ← trzeba pamiętać, co i w jakiej kolejności podać

$dzisiaj = new DateTime('today');       // new — utwórz obiekt klasy DateTime
echo $dzisiaj->format('Y-m-d');         // -> — poproś obiekt o wykonanie metody format()

$wyjatek = new Exception('Coś poszło nie tak.');
echo $wyjatek->getMessage();

<?php

class Odznaka
{
    public string $nazwa;
    public int $xp;
}

$odznaka = new Odznaka();
$odznaka->nazwa = 'Pierwsze zadanie';
$odznaka->xp = 10;

$druga = new Odznaka();
$druga->nazwa = 'Streak 7 dni';
$druga->xp = 50;

echo "<p>" . $odznaka->nazwa . " — " . $odznaka->xp . " XP</p>";
echo "<p>" . $druga->nazwa . " — " . $druga->xp . " XP</p>";

echo "<pre>";
var_dump($odznaka);
echo "</pre>";

public function opis(): string
{
    return $this->nazwa . " (+" . $this->xp . " XP)";
}

echo "<p>" . $odznaka->opis() . "</p>";
echo "<p>" . $druga->opis() . "</p>";

class Odznaka
{
    public string $nazwa;
    public int $xp;

    public function __construct(string $nazwa, int $xp)
    {
        $this->nazwa = $nazwa;
        $this->xp = $xp;
    }

    public function opis(): string
    {
        return $this->nazwa . " (+" . $this->xp . " XP)";
    }
}

$odznaka = new Odznaka('Pierwsze zadanie', 10);
$druga = new Odznaka('Streak 7 dni', 50);

$odznaka->xp = -500;
echo "<p>" . $odznaka->opis() . "</p>";

Fatal error: Uncaught Error: Cannot access private property Odznaka::$xp

<?php

class Odznaka
{
    private string $nazwa;
    private int $xp;

    public function __construct(string $nazwa, int $xp)
    {
        $this->nazwa = $nazwa;
        $this->xp = $xp;
    }

    public function pobierzNazwe(): string
    {
        return $this->nazwa;
    }

    public function pobierzXp(): int
    {
        return $this->xp;
    }

    public function zwiekszNagrode(int $dodatkoweXp): void
    {
        if ($dodatkoweXp <= 0) {
            throw new Exception('Nagrodę za odznakę można tylko zwiększyć.');
        }

        $this->xp += $dodatkoweXp;
    }
}

$odznaka = new Odznaka('Pierwsze zadanie', 10);
$odznaka->zwiekszNagrode(5);
echo "<p>" . $odznaka->pobierzNazwe() . ": " . $odznaka->pobierzXp() . " XP</p>";   // 15 XP

try {
    $odznaka->zwiekszNagrode(-500);
} catch (Exception $wyjatek) {
    echo "<p>" . $wyjatek->getMessage() . "</p>";
}

echo "<p>Nadal: " . $odznaka->pobierzXp() . " XP</p>";   // 15 XP

new Zadanie(6, 'Test', 'Opis', '2026-10-01', false, 25);   // co to jest 6, a co 25? co znaczy false?

$odznaka = new Odznaka(nazwa: 'Streak 7 dni', xp: 50);
$trzecia = new Odznaka(xp: 100, nazwa: 'Poziom 5');   // kolejność nie ma znaczenia

$odznaki = [
    new Odznaka(nazwa: 'Pierwsze zadanie', xp: 10),
    new Odznaka(nazwa: 'Streak 7 dni', xp: 50),
    new Odznaka(nazwa: 'Poziom 5', xp: 100)
];

$sumaXp = 0;

foreach ($odznaki as $odznaka) {
    $sumaXp += $odznaka->pobierzXp();
}

echo "<p>Odznaki: " . count($odznaki) . ", razem " . $sumaXp . " XP</p>";   // 3, razem 160 XP

Fatal error: Uncaught Error: Cannot use object of type Odznaka as array in ... on line ...

require_once __DIR__ . '/classes/Zadanie.php';

<?php

require_once __DIR__ . '/classes/Zadanie.php';

$zadanie = new Zadanie(
    id: 1,
    tytul: 'Nauczyć się OOP',
    opis: 'Klasa, obiekt, metoda',
    termin: '2026-10-10',
    wykonane: false,
    xp: 30
);

echo "<p>" . $zadanie->pobierzId() . ". " . $zadanie->pobierzTytul() . " — " . $zadanie->pobierzXp() . " XP</p>";
echo "<p>" . $zadanie->pobierzOpis() . " (termin: " . $zadanie->pobierzTermin() . ")</p>";

var_dump($zadanie->czyWykonane());
$zadanie->oznaczJakoWykonane();
var_dump($zadanie->czyWykonane());

<?php

class Zadanie
{
    private int $id;
    // ... pozostałe pięć właściwości ...

    public function __construct(
        int $id,
        string $tytul,
        // ... pozostałe cztery parametry ...
    ) {
        $this->id = $id;
        // ...
    }

    public function pobierzId(): int
    {
        return $this->id;
    }

    // ... pozostałe gettery ...

    public function oznaczJakoWykonane(): void
    {
        // ... zmiana jednej właściwości ...
    }
}

<?php

class Zadanie
{
    private int $id;
    private string $tytul;
    private string $opis;
    private string $termin;
    private bool $wykonane;
    private int $xp;

    public function __construct(
        int $id,
        string $tytul,
        string $opis,
        string $termin,
        bool $wykonane,
        int $xp
    ) {
        $this->id = $id;
        $this->tytul = $tytul;
        $this->opis = $opis;
        $this->termin = $termin;
        $this->wykonane = $wykonane;
        $this->xp = $xp;
    }

    public function pobierzId(): int
    {
        return $this->id;
    }

    public function pobierzTytul(): string
    {
        return $this->tytul;
    }

    public function pobierzOpis(): string
    {
        return $this->opis;
    }

    public function pobierzTermin(): string
    {
        return $this->termin;
    }

    public function czyWykonane(): bool
    {
        return $this->wykonane;
    }

    public function pobierzXp(): int
    {
        return $this->xp;
    }

    public function oznaczJakoWykonane(): void
    {
        $this->wykonane = true;
    }
}

czyPoTerminie(): bool

$pierwsza = new DateTime('2026-09-20');
$druga = new DateTime('2026-09-21');

var_dump($pierwsza < $druga);   // bool(true)

    public function czyPoTerminie(): bool
    {
        if ($this->wykonane) {
            return false;
        }

        $dzisiaj = new DateTime('today');
        $termin = new DateTime($this->termin);

        return $termin < $dzisiaj;
    }

PRZED (Lekcja 14)                          PO (Lekcja 15)
$zadania = [                               $zadania = [
    ['id' => 1, 'tytul' => ..., ...],          obiekt Zadanie (id 1),
    ['id' => 2, 'tytul' => ..., ...],          obiekt Zadanie (id 2),
    ...                                        ...
];                                         ];

$zadanie['tytul']                          $zadanie->pobierzTytul()
$zadanie['wykonane']                       $zadanie->czyWykonane()

require_once __DIR__ . '/classes/Zadanie.php';

Fatal error: Uncaught Error: Cannot use object of type Zadanie as array in ...\includes\funkcje_zadan.php on line ...

            $zadania[] = [
                'id' => (int) $wiersz[0],
                'tytul' => $wiersz[1],
                'opis' => $wiersz[2],
                'termin' => $wiersz[3],
                'wykonane' => $wiersz[4] === '1',
                'xp' => (int) $wiersz[5]
            ];

            $zadania[] = new Zadanie(
                id: (int) $wiersz[0],
                tytul: $wiersz[1],
                opis: $wiersz[2],
                termin: $wiersz[3],
                wykonane: $wiersz[4] === '1',
                xp: (int) $wiersz[5]
            );

<?php

function pobierzWykonaneZadania(array $zadania): array
{
    return array_filter($zadania, function ($zadanie) {
        return $zadanie->czyWykonane();
    });
}


function pobierzAktywneZadania(array $zadania): array
{
    return array_filter($zadania, function ($zadanie) {
        return !$zadanie->czyWykonane();
    });
}


function sumujXp(array $zadania): int
{
    $suma = 0;

    foreach ($zadania as $zadanie) {
        $suma += $zadanie->pobierzXp();
    }

    return $suma;
}


function sortujPoTerminie(array $zadania): array
{
    usort($zadania, function ($a, $b) {
        return $a->pobierzTermin() <=> $b->pobierzTermin();
    });

    return $zadania;
}


function nastepneIdZadania(array $zadania): int
{
    $najwiekszeId = 0;

    foreach ($zadania as $zadanie) {
        if ($zadanie->pobierzId() > $najwiekszeId) {
            $najwiekszeId = $zadanie->pobierzId();
        }
    }

    return $najwiekszeId + 1;
}

// ... walidujNoweZadanie() — bez zmian ...

.zadanie.po-terminie { border: 2px solid #c0392b; }

            $najpilniejsze = $aktywneWgTerminu[0];
            echo "<p>Najpilniejsze zadanie: <strong>" . wyczyscTytul($najpilniejsze->pobierzTytul()) . "</strong> — "
                . komunikatTerminu($najpilniejsze->pobierzTermin()) . "</p>";

        foreach ($zadaniaDoWyswietlenia as $zadanie) {
            $tytulCzysty = wyczyscTytul($zadanie->pobierzTytul());
            $znacznik = $zadanie->czyWykonane() ? "[X]" : "[ ]";
            $klasa = $zadanie->czyWykonane() ? "zadanie wykonane" : "zadanie";

            if ($zadanie->czyPoTerminie()) {
                $klasa = "zadanie po-terminie";
            }

            echo "<div class=\"$klasa\">";
            echo "<p><strong>$znacznik $tytulCzysty</strong> — " . $zadanie->pobierzXp() . " XP</p>";
            echo "<p>" . skrocOpis($zadanie->pobierzOpis(), 50) . "</p>";
            echo "<p>Termin: " . $zadanie->pobierzTermin();

            if (!$zadanie->czyWykonane()) {
                echo " — " . komunikatTerminu($zadanie->pobierzTermin());
            }

            echo "</p>";

            if (stripos($tytulCzysty, 'PHP') !== false) {
                echo "<p>To zadanie dotyczy PHP.</p>";
            }

            echo "</div>";
        }

        fputcsv($plik, [
            $zadanie->pobierzId(),
            $zadanie->pobierzTytul(),
            $zadanie->pobierzOpis(),
            $zadanie->pobierzTermin(),
            $zadanie->czyWykonane() ? 1 : 0,
            $zadanie->pobierzXp()
        ], ';', '"', '');

            $zadania = wczytajZadania(PLIK_ZADAN);

            $zadania[] = new Zadanie(
                id: nastepneIdZadania($zadania),
                tytul: $tytulZadania,
                opis: $opisZadania,
                termin: $terminZadania,
                wykonane: false,
                xp: (int) $xpZadania
            );

            zapiszZadania(PLIK_ZADAN, $zadania);

<?php

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Uzytkownik.php';
require_once __DIR__ . '/includes/funkcje_grywalizacji.php';
require_once __DIR__ . '/includes/funkcje_terminow.php';

$uzytkownik = new Uzytkownik(
    login: 'Kama_2026',
    imieUzytkownika: 'Kama',
    xp: 99,
    streak: 5,
    dataOstatniejAktywnosci: '2026-09-14'
);

echo "<p>" . $uzytkownik->pobierzImie() . " (" . $uzytkownik->pobierzLogin() . ")</p>";
echo "<p>Poziom " . $uzytkownik->pobierzPoziom() . ", " . $uzytkownik->pobierzTytulGracza() . "</p>";
echo "<p>Brakuje: " . $uzytkownik->pobierzBrakujaceXp() . " XP</p>";

$uzytkownik->dodajXp(30);
echo "<p>Po dodaniu: " . $uzytkownik->pobierzXp() . " XP, poziom " . $uzytkownik->pobierzPoziom() . "</p>";

    public function pobierzPoziom(): int
    {
        return obliczPoziom($this->xp);
    }

    public function pobierzTytulGracza(): string
    {
        return pobierzTytul(/* ... poziom tego użytkownika ... */);
    }

    public function aktualizujStreak(bool $zadanieWykonane): void
    {
        $this->streak = aktualizujStreak(/* ... trzy argumenty ... */);
    }

<?php

// Metody korzystają z funkcji z includes/funkcje_grywalizacji.php i includes/funkcje_terminow.php
// (oraz stałej XP_NA_POZIOM) — strona, która tworzy obiekt Uzytkownik, musi je dołączyć.

class Uzytkownik
{
    private string $login;
    private string $imieUzytkownika;
    private int $xp;
    private int $streak;
    private string $dataOstatniejAktywnosci;

    public function __construct(
        string $login,
        string $imieUzytkownika,
        int $xp,
        int $streak,
        string $dataOstatniejAktywnosci
    ) {
        $this->login = $login;
        $this->imieUzytkownika = $imieUzytkownika;
        $this->xp = $xp;
        $this->streak = $streak;
        $this->dataOstatniejAktywnosci = $dataOstatniejAktywnosci;
    }

    public function pobierzLogin(): string
    {
        return $this->login;
    }

    public function pobierzImie(): string
    {
        return $this->imieUzytkownika;
    }

    public function pobierzXp(): int
    {
        return $this->xp;
    }

    public function pobierzStreak(): int
    {
        return $this->streak;
    }

    public function pobierzPoziom(): int
    {
        return obliczPoziom($this->xp);
    }

    public function pobierzTytulGracza(): string
    {
        return pobierzTytul($this->pobierzPoziom());
    }

    public function pobierzXpWAktualnymPoziomie(): int
    {
        return obliczXpWAktualnymPoziomie($this->xp, $this->pobierzPoziom());
    }

    public function pobierzProcentPostepu(): float
    {
        return obliczProcentPostepu($this->pobierzXpWAktualnymPoziomie());
    }

    public function pobierzBrakujaceXp(): int
    {
        return ileBrakujeXp($this->xp, $this->pobierzPoziom());
    }

    public function dodajXp(int $xp): void
    {
        if ($xp <= 0) {
            throw new Exception('Liczba XP do dodania musi być większa od zera.');
        }

        $this->xp += $xp;
    }

    public function aktualizujStreak(bool $zadanieWykonane): void
    {
        $this->streak = aktualizujStreak($this->streak, $this->dataOstatniejAktywnosci, $zadanieWykonane);
    }
}

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Zadanie.php';
require_once __DIR__ . '/classes/Uzytkownik.php';
// ... pliki z includes/ bez zmian ...

// --- użytkownik: dane z sesji + symulowane dane grywalizacji ---
$uzytkownik = new Uzytkownik(
    login: $_SESSION['login'],
    imieUzytkownika: $_SESSION['imie'],
    xp: 99,
    streak: 5,
    dataOstatniejAktywnosci: '2026-09-14'
);

// --- wywołania metod: grywalizacja ---
$poziom = $uzytkownik->pobierzPoziom();
$tytul = $uzytkownik->pobierzTytulGracza();
$xpWAktualnymPoziomie = $uzytkownik->pobierzXpWAktualnymPoziomie();
$procentPostepu = $uzytkownik->pobierzProcentPostepu();
$brakujeXp = $uzytkownik->pobierzBrakujaceXp();

$uzytkownik->aktualizujStreak($zadanieWykonane);

        <p>Zalogowano jako <strong><?= $uzytkownik->pobierzLogin(); ?></strong></p>
        ...
        <h2>Witaj, <?= $uzytkownik->pobierzImie(); ?>!</h2>
        ...
        <p>Łączne XP: <strong><?= $uzytkownik->pobierzXp(); ?></strong></p>
        ...
        <p>Streak: <strong><?= $uzytkownik->pobierzStreak(); ?></strong></p>

<?php

require_once __DIR__ . '/classes/Zadanie.php';

$wczoraj = new DateTime('yesterday');
$dzisiaj = new DateTime('today');
$jutro = new DateTime('tomorrow');

$przypadki = [
    ['niewykonane, termin wczoraj', $wczoraj->format('Y-m-d'), false],
    ['niewykonane, termin dzisiaj', $dzisiaj->format('Y-m-d'), false],
    ['niewykonane, termin jutro', $jutro->format('Y-m-d'), false],
    ['wykonane, termin wczoraj', $wczoraj->format('Y-m-d'), true],
    ['niewykonane, termin 2020-01-01', '2020-01-01', false],
];

foreach ($przypadki as $przypadek) {
    $zadanie = new Zadanie(
        id: 1,
        tytul: 'Test',
        opis: '',
        termin: $przypadek[1],
        wykonane: $przypadek[2],
        xp: 10
    );

    echo "<p>" . $przypadek[0] . ": " . ($zadanie->czyPoTerminie() ? "po terminie" : "w terminie") . "</p>";
}

$zadanie = new Zadanie(id: 2, tytul: 'Zaległe', opis: '', termin: '2020-01-01', wykonane: false, xp: 10);
$zadanie->oznaczJakoWykonane();
echo "<p>Zaległe po wykonaniu: " . ($zadanie->czyPoTerminie() ? "po terminie" : "w terminie") . "</p>";

<?php
require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Uzytkownik.php';
require_once __DIR__ . '/includes/funkcje_grywalizacji.php';
require_once __DIR__ . '/includes/funkcje_terminow.php';

foreach ([0, 1, 99, 100, 199, 200, 250] as $xp) {
    $uzytkownik = new Uzytkownik(
        login: 'Test_1',
        imieUzytkownika: 'Test',
        xp: $xp,
        streak: 0,
        dataOstatniejAktywnosci: '2026-09-14'
    );

    $poziom = obliczPoziom($xp);
    $xpWPoziomie = obliczXpWAktualnymPoziomie($xp, $poziom);

    $zgodne = $uzytkownik->pobierzPoziom() === $poziom
        && $uzytkownik->pobierzTytulGracza() === pobierzTytul($poziom)
        && $uzytkownik->pobierzXpWAktualnymPoziomie() === $xpWPoziomie
        && $uzytkownik->pobierzProcentPostepu() === obliczProcentPostepu($xpWPoziomie)
        && $uzytkownik->pobierzBrakujaceXp() === ileBrakujeXp($xp, $poziom);

    echo "<p>XP $xp: poziom " . $uzytkownik->pobierzPoziom()
        . ", brakuje " . $uzytkownik->pobierzBrakujaceXp() . " XP — "
        . ($zgodne ? "OK" : "BŁĄD") . "</p>";
}

$dzisiaj = new DateTime('today');
$wczoraj = new DateTime('yesterday');
$przedwczoraj = new DateTime('-2 days');
$daty = [$dzisiaj->format('Y-m-d'), $wczoraj->format('Y-m-d'), $przedwczoraj->format('Y-m-d')];

foreach ($daty as $data) {
    foreach ([true, false] as $zadanieWykonane) {
        $uzytkownik = new Uzytkownik(
            login: 'Test_1',
            imieUzytkownika: 'Test',
            xp: 0,
            streak: 5,
            dataOstatniejAktywnosci: $data
        );

        $uzytkownik->aktualizujStreak($zadanieWykonane);
        $oczekiwany = aktualizujStreak(5, $data, $zadanieWykonane);

        echo "<p>$data, " . ($zadanieWykonane ? "wykonane" : "niewykonane") . ": streak "
            . $uzytkownik->pobierzStreak() . " — "
            . ($uzytkownik->pobierzStreak() === $oczekiwany ? "OK" : "BŁĄD") . "</p>";
    }
}

<?php

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Uzytkownik.php';
require_once __DIR__ . '/includes/funkcje_grywalizacji.php';
require_once __DIR__ . '/includes/funkcje_terminow.php';

$uzytkownik = new Uzytkownik(login: 'Test_1', imieUzytkownika: 'Test', xp: 99, streak: 0, dataOstatniejAktywnosci: '2026-09-14');
$uzytkownik->dodajXp(30);
echo "<p>Po +30: " . $uzytkownik->pobierzXp() . "</p>";
$uzytkownik->dodajXp(1);
echo "<p>Po +1: " . $uzytkownik->pobierzXp() . "</p>";

foreach ([0, -50] as $ile) {
    try {
        $uzytkownik->dodajXp($ile);
        echo "<p>Dodano $ile XP</p>";
    } catch (Exception $wyjatek) {
        echo "<p>Dla $ile: " . $wyjatek->getMessage() . "</p>";
    }
}

echo "<p>Na końcu: " . $uzytkownik->pobierzXp() . " XP</p>";

$zadanie->xp = 1000;

Warning: Undefined variable $xp in ...\classes\Zadanie.php on line ...
Fatal error: Uncaught TypeError: Zadanie::pobierzXp(): Return value must be of type int, null returned

Fatal error: Uncaught Error: Typed property Zadanie::$opis must not be accessed before initialization

<?php

require_once __DIR__ . '/classes/Zadanie.php';

// pomyłka 1: zamienione id i xp (oba int)
$pierwsze = new Zadanie(20, 'Test', 'Opis zadania', '2026-10-01', false, 1);
echo "<p>id: " . $pierwsze->pobierzId() . ", xp: " . $pierwsze->pobierzXp() . "</p>";

// pomyłka 2: zamienione opis i termin (oba string)
$drugie = new Zadanie(1, 'Test', '2026-10-01', 'Opis zadania', false, 20);
echo "<p>termin: " . $drugie->pobierzTermin() . "</p>";
var_dump($drugie->czyPoTerminie());

$pierwsze = new Zadanie(xp: 20, id: 1, tytul: 'Test', opis: 'Opis zadania', termin: '2026-10-01', wykonane: false);

<?php

require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Zadanie.php';
require_once __DIR__ . '/includes/funkcje_zadan.php';
require_once __DIR__ . '/includes/funkcje_plikow.php';

$zadania = wczytajZadania(PLIK_ZADAN);
$aktywneZadania = pobierzAktywneZadania($zadania);

echo "<p>Wykonane przed: " . count(pobierzWykonaneZadania($zadania)) . "</p>";

foreach ($aktywneZadania as $zadanie) {
    $zadanie->oznaczJakoWykonane();
}

echo "<p>Wykonane po: " . count(pobierzWykonaneZadania($zadania)) . "</p>";

<?php

require_once __DIR__ . '/classes/Zadanie.php';

$zadanie = new Zadanie(id: '7', tytul: 'Test', opis: '', termin: '2026-10-01', wykonane: 'nie', xp: 10);
var_dump($zadanie->pobierzId(), $zadanie->czyWykonane());

$zadanie = new Zadanie(id: 'siedem', tytul: 'Test', opis: '', termin: '2026-10-01', wykonane: false, xp: 10);

<?php

class Zadanie
{
    private int $id;
    private string $tytul;
    private string $opis;
    private string $termin;
    private bool $wykonane;
    private int $xp;

    public function __construct(
        int $id,
        string $tytul,
        string $opis,
        string $termin,
        bool $wykonane,
        int $xp
    ) {
        $this->id = $id;
        $this->tytul = $tytul;
        $this->opis = $opis;
        $this->termin = $termin;
        $this->wykonane = $wykonane;
        $this->xp = $xp;
    }

    public function pobierzId(): int
    {
        return $this->id;
    }

    public function pobierzTytul(): string
    {
        return $this->tytul;
    }

    public function pobierzOpis(): string
    {
        return $this->opis;
    }

    public function pobierzTermin(): string
    {
        return $this->termin;
    }

    public function czyWykonane(): bool
    {
        return $this->wykonane;
    }

    public function pobierzXp(): int
    {
        return $this->xp;
    }

    public function oznaczJakoWykonane(): void
    {
        $this->wykonane = true;
    }

    public function czyPoTerminie(): bool
    {
        if ($this->wykonane) {
            return false;
        }

        $dzisiaj = new DateTime('today');
        $termin = new DateTime($this->termin);

        return $termin < $dzisiaj;
    }
}

<?php

// Metody korzystają z funkcji z includes/funkcje_grywalizacji.php i includes/funkcje_terminow.php
// (oraz stałej XP_NA_POZIOM) — strona, która tworzy obiekt Uzytkownik, musi je dołączyć.

class Uzytkownik
{
    private string $login;
    private string $imieUzytkownika;
    private int $xp;
    private int $streak;
    private string $dataOstatniejAktywnosci;

    public function __construct(
        string $login,
        string $imieUzytkownika,
        int $xp,
        int $streak,
        string $dataOstatniejAktywnosci
    ) {
        $this->login = $login;
        $this->imieUzytkownika = $imieUzytkownika;
        $this->xp = $xp;
        $this->streak = $streak;
        $this->dataOstatniejAktywnosci = $dataOstatniejAktywnosci;
    }

    public function pobierzLogin(): string
    {
        return $this->login;
    }

    public function pobierzImie(): string
    {
        return $this->imieUzytkownika;
    }

    public function pobierzXp(): int
    {
        return $this->xp;
    }

    public function pobierzStreak(): int
    {
        return $this->streak;
    }

    public function pobierzPoziom(): int
    {
        return obliczPoziom($this->xp);
    }

    public function pobierzTytulGracza(): string
    {
        return pobierzTytul($this->pobierzPoziom());
    }

    public function pobierzXpWAktualnymPoziomie(): int
    {
        return obliczXpWAktualnymPoziomie($this->xp, $this->pobierzPoziom());
    }

    public function pobierzProcentPostepu(): float
    {
        return obliczProcentPostepu($this->pobierzXpWAktualnymPoziomie());
    }

    public function pobierzBrakujaceXp(): int
    {
        return ileBrakujeXp($this->xp, $this->pobierzPoziom());
    }

    public function dodajXp(int $xp): void
    {
        if ($xp <= 0) {
            throw new Exception('Liczba XP do dodania musi być większa od zera.');
        }

        $this->xp += $xp;
    }

    public function aktualizujStreak(bool $zadanieWykonane): void
    {
        $this->streak = aktualizujStreak($this->streak, $this->dataOstatniejAktywnosci, $zadanieWykonane);
    }
}

<?php

function pobierzWykonaneZadania(array $zadania): array
{
    return array_filter($zadania, function ($zadanie) {
        return $zadanie->czyWykonane();
    });
}


function pobierzAktywneZadania(array $zadania): array
{
    return array_filter($zadania, function ($zadanie) {
        return !$zadanie->czyWykonane();
    });
}


function sumujXp(array $zadania): int
{
    $suma = 0;

    foreach ($zadania as $zadanie) {
        $suma += $zadanie->pobierzXp();
    }

    return $suma;
}


function sortujPoTerminie(array $zadania): array
{
    usort($zadania, function ($a, $b) {
        return $a->pobierzTermin() <=> $b->pobierzTermin();
    });

    return $zadania;
}


function nastepneIdZadania(array $zadania): int
{
    $najwiekszeId = 0;

    foreach ($zadania as $zadanie) {
        if ($zadanie->pobierzId() > $najwiekszeId) {
            $najwiekszeId = $zadanie->pobierzId();
        }
    }

    return $najwiekszeId + 1;
}

// ... walidujNoweZadanie() — bez zmian względem Lekcji 13 ...

            $zadania[] = new Zadanie(
                id: (int) $wiersz[0],
                tytul: $wiersz[1],
                opis: $wiersz[2],
                termin: $wiersz[3],
                wykonane: $wiersz[4] === '1',
                xp: (int) $wiersz[5]
            );

        fputcsv($plik, [
            $zadanie->pobierzId(),
            $zadanie->pobierzTytul(),
            $zadanie->pobierzOpis(),
            $zadanie->pobierzTermin(),
            $zadanie->czyWykonane() ? 1 : 0,
            $zadanie->pobierzXp()
        ], ';', '"', '');

<?php

session_start();

// --- pliki aplikacji ---
require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Zadanie.php';
require_once __DIR__ . '/includes/funkcje_tekstowe.php';
require_once __DIR__ . '/includes/funkcje_zadan.php';
require_once __DIR__ . '/includes/funkcje_plikow.php';
require_once __DIR__ . '/includes/funkcje_sesji.php';


// --- tylko dla zalogowanych ---
wymagajLogowania();


// --- dane nowego zadania (na start puste — formularz jeszcze nie został wysłany) ---
$tytulZadania = '';
$opisZadania = '';
$terminZadania = '';
$xpZadania = '';

$bledy = [];
$bladZapisu = null;


// --- obsługa wysłanego formularza (POST) ---
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $tytulZadania = wyczyscTytul($_POST['tytul'] ?? '');
    $opisZadania = trim(preg_replace('/\s+/', ' ', $_POST['opis'] ?? ''));
    $terminZadania = trim($_POST['termin'] ?? '');
    $xpZadania = trim($_POST['xp'] ?? '');

    $bledy = walidujNoweZadanie($tytulZadania, $opisZadania, $terminZadania, $xpZadania);

    if (count($bledy) === 0) {
        try {
            $zadania = wczytajZadania(PLIK_ZADAN);

            $zadania[] = new Zadanie(
                id: nastepneIdZadania($zadania),
                tytul: $tytulZadania,
                opis: $opisZadania,
                termin: $terminZadania,
                wykonane: false,
                xp: (int) $xpZadania
            );

            zapiszZadania(PLIK_ZADAN, $zadania);

            ustawKomunikat('Zadanie zostało dodane.');
            header('Location: index.php');
            exit;
        } catch (Exception $wyjatek) {
            $bladZapisu = $wyjatek->getMessage();
        }
    }
}


// --- prezentacja ---
$nazwaStrony = 'Dodaj zadanie — TaskQuest';
require_once __DIR__ . '/includes/header.php';
?>
        <h2>Nowe zadanie</h2>
        <p><a href="index.php">← Wróć do listy zadań</a></p>

        <?php if (count($bledy) > 0) { ?>
        <div class="blad">
            <p>Popraw formularz:</p>
            <ul>
                <?php foreach ($bledy as $blad) { ?>
                <li><?= $blad; ?></li>
                <?php } ?>
            </ul>
        </div>
        <?php } ?>

        <?php if ($bladZapisu !== null) { ?>
        <p class="blad">Nie udało się dodać zadania: <?= $bladZapisu; ?></p>
        <?php } ?>

        <form method="post" action="dodaj-zadanie.php">
            <label for="tytul">Tytuł *</label>
            <input type="text" id="tytul" name="tytul" maxlength="100" required value="<?= $tytulZadania; ?>">

            <label for="opis">Opis</label>
            <textarea id="opis" name="opis" rows="3" maxlength="300"><?= $opisZadania; ?></textarea>

            <label for="termin">Termin *</label>
            <input type="date" id="termin" name="termin" required value="<?= $terminZadania; ?>">

            <label for="xp">Nagroda XP (1–100) *</label>
            <input type="number" id="xp" name="xp" min="1" max="100" required value="<?= $xpZadania; ?>">

            <button type="submit">Dodaj zadanie</button>
        </form>
<?php
require_once __DIR__ . '/includes/footer.php';

<?php

session_start();

// --- pliki aplikacji ---
require_once __DIR__ . '/config/config.php';
require_once __DIR__ . '/classes/Zadanie.php';
require_once __DIR__ . '/classes/Uzytkownik.php';
require_once __DIR__ . '/includes/funkcje_grywalizacji.php';
require_once __DIR__ . '/includes/funkcje_tekstowe.php';
require_once __DIR__ . '/includes/funkcje_terminow.php';
require_once __DIR__ . '/includes/funkcje_zadan.php';
require_once __DIR__ . '/includes/funkcje_plikow.php';
require_once __DIR__ . '/includes/funkcje_sesji.php';


// --- tylko dla zalogowanych ---
wymagajLogowania();


// --- użytkownik: dane z sesji + symulowane dane grywalizacji ---
$uzytkownik = new Uzytkownik(
    login: $_SESSION['login'],
    imieUzytkownika: $_SESSION['imie'],
    xp: 99,
    streak: 5,
    dataOstatniejAktywnosci: '2026-09-14'
);


// --- dane zadań (z pliku CSV — tablica obiektów Zadanie) ---
$zadania = [];
$bladZadan = null;

try {
    $zadania = wczytajZadania(PLIK_ZADAN);
} catch (Exception $wyjatek) {
    $bladZadan = $wyjatek->getMessage();
}


// --- wywołania metod: grywalizacja ---
$poziom = $uzytkownik->pobierzPoziom();
$tytul = $uzytkownik->pobierzTytulGracza();
$xpWAktualnymPoziomie = $uzytkownik->pobierzXpWAktualnymPoziomie();
$procentPostepu = $uzytkownik->pobierzProcentPostepu();
$brakujeXp = $uzytkownik->pobierzBrakujaceXp();

//pasek postępu
$liczbaAktywnychSegmentow = (int) ($procentPostepu / 10);
$progNastepnegoPoziomu = $poziom * XP_NA_POZIOM;


// --- wywołania funkcji: lista zadań ---
$wykonaneZadania = pobierzWykonaneZadania($zadania);
$aktywneZadania = pobierzAktywneZadania($zadania);

$liczbaWszystkich = count($zadania);
$liczbaWykonanych = count($wykonaneZadania);
$liczbaAktywnych = count($aktywneZadania);

$xpDoZdobycia = sumujXp($aktywneZadania);

$zadaniaWgTerminu = sortujPoTerminie($zadania);
$aktywneWgTerminu = sortujPoTerminie($aktywneZadania);
$wykonaneWgTerminu = sortujPoTerminie($wykonaneZadania);

// uproszczenie (symulacja): aktywność = wykonane jakiekolwiek zadanie z listy
$zadanieWykonane = $liczbaWykonanych > 0;

$uzytkownik->aktualizujStreak($zadanieWykonane);


// --- widok listy: z adresu strony (GET) albo zapamiętany w ciasteczku ---
$filtr = $_GET['filtr'] ?? $_COOKIE['filtr'] ?? 'wszystkie';

if ($filtr !== 'aktywne' && $filtr !== 'wykonane') {
    $filtr = 'wszystkie';
}

if (isset($_GET['filtr'])) {
    setcookie('filtr', $filtr, time() + CZAS_PAMIETANIA_WIDOKU);
}

$zadaniaDoWyswietlenia = match ($filtr) {
    'wszystkie' => $zadaniaWgTerminu,
    'aktywne' => $aktywneWgTerminu,
    'wykonane' => $wykonaneWgTerminu
};


// --- komunikat jednorazowy (z sesji) ---
$komunikat = pobierzKomunikat();


// --- prezentacja ---
$nazwaStrony = 'TaskQuest';
require_once __DIR__ . '/includes/header.php';
?>
        <?php if ($komunikat !== '') { ?>
        <p class="sukces"><?= $komunikat; ?></p>
        <?php } ?>

        <p>Zdobywaj punkty za wykonane zadania!</p>

        <p>Zalogowano jako <strong><?= $uzytkownik->pobierzLogin(); ?></strong></p>
        <form method="post" action="wyloguj.php">
            <button type="submit">Wyloguj</button>
        </form>

        <h2>Witaj, <?= $uzytkownik->pobierzImie(); ?>!</h2>

        <p>Poziom: <strong><?= $poziom; ?></strong></p>
        <p>Tytuł: <strong><?= $tytul; ?></strong></p>
        <p>Łączne XP: <strong><?= $uzytkownik->pobierzXp(); ?></strong></p>

        <h3>
            <?= "Masz $xpWAktualnymPoziomie XP z " . XP_NA_POZIOM . " XP potrzebnych do poziomu " . ($poziom + 1) . " (" . round($procentPostepu, 2) . "%)"; ?>
        </h3>

        <div class="pasek-xp">
            <?php
            for ($segment = 1; $segment <= 10; $segment++) {
                if ($segment <= $liczbaAktywnychSegmentow) {
                    echo "█";
                } else {
                    echo "░";
                }
            }
            ?>
        </div>

        <p>Kolejny próg: <?= $progNastepnegoPoziomu; ?> XP</p>
        <p>Brakuje XP: <strong><?= $brakujeXp; ?></strong></p>
        <p>Streak: <strong><?= $uzytkownik->pobierzStreak(); ?></strong></p>

        <h2>Twoje zadania</h2>

        <p><a href="dodaj-zadanie.php">+ Dodaj zadanie</a></p>

        <?php if ($bladZadan !== null) { ?>
        <p class="blad">Nie udało się wczytać zadań: <?= $bladZadan; ?></p>
        <?php } else { ?>

        <p>
            Wszystkie: <strong><?= $liczbaWszystkich; ?></strong> |
            Wykonane: <strong><?= $liczbaWykonanych; ?></strong> |
            Aktywne: <strong><?= $liczbaAktywnych; ?></strong>
        </p>
        <p>XP do zdobycia z aktywnych zadań: <strong><?= $xpDoZdobycia; ?></strong></p>

        <?php
        if ($liczbaWszystkich === 0) {
            echo "<p>Brak zadań.</p>";
        } elseif ($liczbaAktywnych === 0) {
            echo "<p>Wszystkie zadania wykonane — świetna robota!</p>";
        } else {
            if ($xpDoZdobycia >= $brakujeXp) {
                echo "<p class=\"awans\">Wykonując aktywne zadania, awansujesz na poziom " . ($poziom + 1) . "!</p>";
            } else {
                echo "<p>Aktywne zadania nie wystarczą jeszcze na awans — brakuje " . ($brakujeXp - $xpDoZdobycia) . " XP.</p>";
            }

            $najpilniejsze = $aktywneWgTerminu[0];
            echo "<p>Najpilniejsze zadanie: <strong>" . wyczyscTytul($najpilniejsze->pobierzTytul()) . "</strong> — "
                . komunikatTerminu($najpilniejsze->pobierzTermin()) . "</p>";
        }

        echo "<h3>Lista zadań (wg terminu)</h3>";
        echo "<p>Pokaż: <a href=\"index.php?filtr=wszystkie\">wszystkie</a> | "
            . "<a href=\"index.php?filtr=aktywne\">aktywne</a> | "
            . "<a href=\"index.php?filtr=wykonane\">wykonane</a></p>";
        echo "<p>Widok: <strong>$filtr</strong></p>";

        if ($liczbaWszystkich > 0 && count($zadaniaDoWyswietlenia) === 0) {
            echo "<p>Brak zadań w tym widoku.</p>";
        }

        foreach ($zadaniaDoWyswietlenia as $zadanie) {
            $tytulCzysty = wyczyscTytul($zadanie->pobierzTytul());
            $znacznik = $zadanie->czyWykonane() ? "[X]" : "[ ]";
            $klasa = $zadanie->czyWykonane() ? "zadanie wykonane" : "zadanie";

            if ($zadanie->czyPoTerminie()) {
                $klasa = "zadanie po-terminie";
            }

            echo "<div class=\"$klasa\">";
            echo "<p><strong>$znacznik $tytulCzysty</strong> — " . $zadanie->pobierzXp() . " XP</p>";
            echo "<p>" . skrocOpis($zadanie->pobierzOpis(), 50) . "</p>";
            echo "<p>Termin: " . $zadanie->pobierzTermin();

            if (!$zadanie->czyWykonane()) {
                echo " — " . komunikatTerminu($zadanie->pobierzTermin());
            }

            echo "</p>";

            if (stripos($tytulCzysty, 'PHP') !== false) {
                echo "<p>To zadanie dotyczy PHP.</p>";
            }

            echo "</div>";
        }
        ?>
        <?php } ?>
<?php
require_once __DIR__ . '/includes/footer.php';

.zadanie.po-terminie { border: 2px solid #c0392b; }

        <p>TaskQuest 1.5</p>
    </div>
</body>
</html>

$poziom, $tytul, $xpWAktualnymPoziomie, $procentPostepu, $brakujeXp   // te same nazwy — wartości z metod obiektu $uzytkownik
$liczbaAktywnychSegmentow, $progNastepnegoPoziomu, $zadanieWykonane
$zadania, $bladZadan, $wykonaneZadania, $aktywneZadania, $liczbaWszystkich, $liczbaWykonanych,
$liczbaAktywnych, $zadaniaWgTerminu, $aktywneWgTerminu, $wykonaneWgTerminu, $xpDoZdobycia   // tablice — teraz z obiektami Zadanie
$filtr, $zadaniaDoWyswietlenia, $komunikat, $nazwaStrony
// dodaj-zadanie.php: $tytulZadania, $opisZadania, $terminZadania, $xpZadania, $bledy, $bladZapisu
// zaloguj.php: $login, $imieUzytkownika (dane z formularza — bez zmian)
define('XP_NA_POZIOM', ...), define('PLIK_ZADAN', ...), define('CZAS_PAMIETANIA_WIDOKU', ...)

wszystkie funkcje z Lekcji 1–14 (kod bez zmian poza odwołaniami do danych zadania w funkcje_zadan.php i funkcje_plikow.php)
format data/zadania.csv, sesja (login, imie, komunikat), cookie filtr, obsługa awarii pliku, walidacja formularzy

// classes/Zadanie.php (nowy plik, nowy katalog classes/)
class Zadanie
    // właściwości private: $id, $tytul, $opis, $termin, $wykonane, $xp
    __construct(int $id, string $tytul, string $opis, string $termin, bool $wykonane, int $xp)
    pobierzId(), pobierzTytul(), pobierzOpis(), pobierzTermin(), czyWykonane(), pobierzXp()
    oznaczJakoWykonane()      // jedyny sposób zmiany stanu zadania
    czyPoTerminie()           // niewykonane i termin przed dzisiaj

// classes/Uzytkownik.php (nowy plik)
class Uzytkownik
    // właściwości private: $login, $imieUzytkownika, $xp, $streak, $dataOstatniejAktywnosci
    __construct(string $login, string $imieUzytkownika, int $xp, int $streak, string $dataOstatniejAktywnosci)
    pobierzLogin(), pobierzImie(), pobierzXp(), pobierzStreak()
    pobierzPoziom(), pobierzTytulGracza(), pobierzXpWAktualnymPoziomie(), pobierzProcentPostepu(), pobierzBrakujaceXp()
                              // wywołują funkcje z funkcje_grywalizacji.php
    dodajXp(int $xp)          // tylko dodatnie XP, inaczej Exception
    aktualizujStreak(bool $zadanieWykonane)   // wywołuje funkcję aktualizujStreak() i zapisuje wynik w obiekcie

// index.php
$uzytkownik               // obiekt Uzytkownik (dane z sesji + symulowane XP/streak/data)

// includes/header.php: styl .zadanie.po-terminie

[ ] Nadal rozwijam ten sam projekt TaskQuest (nie zaczynam nowego).
[ ] Potrafię wyjaśnić różnicę między klasą a obiektem na przykładzie Zadanie.
[ ] Wiem, co oznacza $this i dlaczego metoda pobierzXp() nie potrzebuje parametru.
[ ] Wiem, po co jest konstruktor i co się dzieje, gdy nie ustawi którejś właściwości.
[ ] Potrafię wyjaśnić, po co właściwości są private, a metody public.
[ ] Wiem, dlaczego Zadanie ma oznaczJakoWykonane(), a nie ma „ustaw XP”.
[ ] Potrafię utworzyć obiekt z argumentami nazwanymi i wiem, przed jaką pomyłką chronią.
[ ] Mam classes/Zadanie.php z czyPoTerminie(); Test 1 się zgadza.
[ ] Mam classes/Uzytkownik.php; Test 2 i Test 3 dają same OK / oczekiwane wartości.
[ ] W całym projekcie nie ma już odwołań $zadanie['...'].
[ ] Strona wygląda jak po Lekcji 14, zadania po terminie mają czerwoną ramkę (Testy 4–6).
[ ] diagnostyka.php pokazuje 17 razy [OK].
[ ] Potrafię wyjaśnić, co pokazał Eksperyment 5 (obiekt to nie kopia) i Eksperyment 7 (typy a walidacja).
[ ] Usunęłam/usunąłem brudnopisy.

class BladPlikuZadan extends Exception
{
}

new Uzytkownik(..., xp: 99, streak: 5, dataOstatniejAktywnosci: '2026-09-14')   ← wpisane w kod, takie samo dla każdego
data/zadania.csv                                                                 ← jedna lista dla wszystkich użytkowników
zapiszZadania()                                                                  ← nadpisuje cały plik przy każdej zmianie

PODSUMOWANIE LEKCJI

W skrócie

Klasa i obiekt

• Klasa to plan, obiekt to egzemplarz zbudowany według planu. Z jednej klasy powstaje dowolnie wiele niezależnych obiektów.
• Obiekt tworzy new NazwaKlasy(...). Do właściwości i metod sięgamy przez -> — bez $ po strzałce ($zadanie->tytul, nie $zadanie->$tytul).
• Nazwa klasy wielką literą, jedna klasa = jeden plik o tej samej nazwie, plik trzeba dołączyć (require_once), zanim użyjemy new.

Właściwości, metody, $this

• Właściwość to zmienna należąca do obiektu, metoda to funkcja zapisana w klasie i wywoływana na obiekcie.
• Wewnątrz metody do własnych danych sięgamy tylko przez $this-> — samo $xp to zwykła zmienna lokalna, której zwykle nie ma.
• Metoda nie potrzebuje parametrów, żeby poznać dane swojego obiektu — dlatego $uzytkownik->pobierzPoziom() zastępuje obliczPoziom($xp).
• Metoda, która ma zmienić stan obiektu, musi zapisać wynik w $this->... — samo wywołanie funkcji w środku niczego nie zapamiętuje.

Konstruktor

• __construct — dwa podkreślniki. PHP wywołuje go automatycznie przy new, dzięki czemu obiekt jest kompletny od chwili powstania.
• Brakujący argument to natychmiastowy ArgumentCountError. Konstruktor, który nie ustawi którejś właściwości (albo nazwany _construct), daje błąd dopiero przy odczycie: must not be accessed before initialization.

Hermetyzacja

• Reguła TaskQuest: właściwości private, metody public. Obiekt ukrywa dane i udostępnia tylko operacje, na które się zgadza.
• private — dostęp tylko z metod tej klasy; protected — także z klas dziedziczących; public — zewsząd.
• Nie każda właściwość potrzebuje gettera, a tym bardziej metody zmieniającej. Zadanie ma oznaczJakoWykonane(), bo tylko to wolno z nim zrobić — nie ma „ustaw XP” ani „odznacz”.
• Nazewnictwo: pobierz...() zwraca daną, czy...() zwraca true/false, czasownik (dodajXp(), oznaczJakoWykonane()) zmienia stan.

Rzeczy, które zaskakują

• Obiekt to nie kopia. $b = $a; dla obiektów daje dostęp do tego samego obiektu — zmiana przez $b widoczna jest w $a. Dla tablic byłaby to kopia.
• Typy właściwości nie zastępują walidacji. new Zadanie(id: '7', wykonane: 'nie', ...) przejdzie (PHP przekonwertuje tekst na int/bool), więc dane z pliku i formularza nadal trzeba sprawdzać.
• Tablica obiektów to nadal tablica. count(), foreach, array_filter(), usort() działają jak dotąd — zmienia się tylko odczyt elementu: $element['xp'] → $element->pobierzXp().
• Potraktowanie obiektu jak tablicy przerywa skrypt: Cannot use object of type ... as array.

Poza TaskQuestem (teoria z lekcji)

• extends — dziedziczenie, tylko po jednej klasie; final blokuje nadpisanie metody (lub dziedziczenie klasy).
• const i static należą do klasy, nie do obiektu: w środku self::, na zewnątrz NazwaKlasy:: — bez $this.
• Klasa abstrakcyjna — nie da się z niej utworzyć obiektu, może mieć pola i gotowe metody, dziedziczy się ją raz. Interfejs — same deklaracje metod publicznych, ale klasa może implementować wiele interfejsów.

Co trzeba umieć na INF.03?

• czytać i pisać zapis new Klasa(...) oraz $obiekt->metoda() — bez tego nie da się użyć DateTime, wyjątków ani obiektowego połączenia z bazą,
• rozpoznać w kodzie, czy dana rzecz jest funkcją (funkcja($x)), metodą obiektu ($obiekt->metoda()), czy elementem klasy (Klasa::STALA, Klasa::metoda()),
• odczytać dane z obiektu zwróconego przez bibliotekę i wypisać je na stronie (to samo, co robimy z wierszami z bazy),
• poprawnie łączyć podejście proceduralne i obiektowe — na egzaminie wolno pisać skrypty proceduralnie, byle działały i miały znaczące nazwy zmiennych,
• rozpoznać typowe komunikaty błędów (Class "..." not found, Cannot access private property, Cannot use object of type ... as array) i wiedzieć, co je powoduje — to oszczędza czas przy debugowaniu na egzaminie praktycznym.

Minimum, które powinno wejść w pamięć

Jeżeli masz zapamiętać tylko kilka rzeczy z tej lekcji, zapamiętaj te:

1. Klasa to plan, obiekt to egzemplarz. new tworzy obiekt, -> sięga do jego właściwości i metod (po strzałce nie ma $).
2. $this to „ten obiekt”. Wewnątrz metody zawsze $this->wlasciwosc.
3. __construct (dwa podkreślniki) wykonuje się automatycznie przy new i ma zrobić obiekt kompletnym.
4. Właściwości private, metody public. Dane czytamy getterem, zmieniamy tylko metodą, która pilnuje reguł.
5. Argumenty nazwane (new Zadanie(id: 1, tytul: 'A', ...)) przy wielu parametrach — kolejność przestaje mieć znaczenie.
6. Obiekt przypisany do drugiej zmiennej to ten sam obiekt, nie kopia.
7. Typ właściwości to nie walidacja — dane z pliku i formularza nadal sprawdzamy sami.
8. Klasa musi być dołączona (require_once), inaczej Class "..." not found.
9. extends — jedna klasa bazowa; implements — wiele interfejsów.
10. const i static wywołujemy przez self:: (w klasie) lub NazwaKlasy:: (poza nią) — nie przez $this.

Ściągawka – najważniejsze polecenia i składnia

Klasa, obiekt, właściwości

class Odznaka
{
    private string $nazwa;     // właściwość z typem, tylko dla metod tej klasy
    private int $xp = 0;       // wartość domyślna

    public function __construct(string $nazwa, int $xp)
    {
        $this->nazwa = $nazwa; // $nazwa — parametr, $this->nazwa — właściwość obiektu
        $this->xp = $xp;
    }

    public function pobierzXp(): int          // getter
    {
        return $this->xp;
    }

    public function czyCenna(): bool          // metoda zwracająca true/false
    {
        return $this->xp >= 50;
    }

    public function zwiekszNagrode(int $dodatkoweXp): void   // zmiana stanu wg reguły
    {
        if ($dodatkoweXp <= 0) {
            throw new Exception('Nagrodę można tylko zwiększyć.');
        }

        $this->xp += $dodatkoweXp;
    }
}

$odznaka = new Odznaka('Streak 7 dni', 50);
$odznaka = new Odznaka(nazwa: 'Streak 7 dni', xp: 50);   // argumenty nazwane (PHP 8)
echo $odznaka->pobierzXp();

Modyfikatory dostępu

Obiekty w tablicy

$odznaki = [new Odznaka('A', 10), new Odznaka('B', 50)];

$suma = 0;
foreach ($odznaki as $odznaka) {
    $suma += $odznaka->pobierzXp();     // było: $odznaka['xp']
}

Klasa w osobnym pliku

require_once __DIR__ . '/classes/Zadanie.php';
$zadanie = new Zadanie(id: 1, tytul: 'A', opis: '', termin: '2026-10-01', wykonane: false, xp: 10);

Dziedziczenie i final

class Postac { protected int $hp = 100; public function czyMartwy(): bool { return $this->hp <= 0; } }
class Wojownik extends Postac { }          // dziedziczy hp i czyMartwy()

class Profil { final public function nazwa(): string { return 'Użytkownik'; } }
// klasa potomna nie nadpisze nazwa() — Fatal error: Cannot override final method

Stałe i elementy statyczne

class Konfiguracja
{
    const MAX_GRACZY = 100;
    public static int $licznik = 0;

    public function limit(): int { return self::MAX_GRACZY; }   // w klasie: self::
}

echo Konfiguracja::MAX_GRACZY;   // poza klasą: NazwaKlasy::
Konfiguracja::$licznik++;        // bez tworzenia obiektu

Klasa abstrakcyjna i interfejs

abstract class PostacGry {
    abstract public function atak(): string;      // brak ciała — musi pojawić się w klasie potomnej
}

interface Zniszczalny {
    public function znisz(): void;                // zawsze public, zawsze bez ciała
}

class Mag extends PostacGry implements Zniszczalny { /* musi mieć atak() i znisz() */ }

Metody magiczne

public function __construct() { }   // przy new
public function __destruct() { }    // gdy obiekt przestaje istnieć (unset() lub koniec skryptu)

Komunikaty błędów i ich przyczyny

Quiz – sprawdź się

1. Co wyświetli kod?

class Odznaka {
    private int $xp = 10;
    public function pobierzXp(): int { return $this->xp; }
}

$o = new Odznaka();
echo $o->pobierzXp() + 5;

2. Która z linii A–C spowoduje błąd i jaki?

$zadanie = new Zadanie(id: 1, tytul: 'Nauka', opis: '', termin: '2026-10-01', wykonane: false, xp: 10);

echo $zadanie->pobierzTytul();                      // A
echo $zadanie->tytul;                               // B
echo $zadanie->czyWykonane() ? 'tak' : 'nie';       // C

3. Znajdź błąd. Kiedy się ujawni?

class Odznaka {
    private string $nazwa;
    public function _construct(string $nazwa) { $this->nazwa = $nazwa; }
    public function pobierzNazwe(): string { return $this->nazwa; }
}

$o = new Odznaka('Pierwsze zadanie');
echo $o->pobierzNazwe();

4. Co wyświetli ostatnia linia?

class Licznik {
    public static int $ile = 0;
    public function __construct() { self::$ile++; }
}

new Licznik();
new Licznik();
echo Licznik::$ile;

5. Uzupełnij metodę klasy Zadanie tak, aby zwracała true dla zadania niewykonanego z nagrodą większą niż zero:

public function czyDoZrobienia(): bool
{
    return ______ && ______;
}

6. Dlaczego ta metoda nie działa i jak ją poprawić?

public function opis(): string
{
    return $nazwa . ' (+' . $xp . ' XP)';
}

7. Co wyświetli kod? Co się zmieni, jeżeli w klasie Profil dopiszemy final przed public function nazwa()?

class Profil { public function nazwa(): string { return 'Użytkownik'; } }
class ProfilPremium extends Profil { public function nazwa(): string { return 'Premium'; } }

$p = new ProfilPremium();
echo $p->nazwa();

8. Która wersja tworzy obiekt poprawnie?

a) new Zadanie($id: 1, $tytul: 'A', $opis: '', $termin: '2026-10-01', $wykonane: false, $xp: 10);
b) new Zadanie(id: 1, tytul: 'A', opis: '', termin: '2026-10-01', wykonane: false, xp: 10);
c) new Zadanie(id => 1, tytul => 'A', opis => '', termin => '2026-10-01', wykonane => false, xp => 10);

9. Ten kod nie działa. Popraw jedną linię:

class Konfiguracja {
    const MAX_GRACZY = 100;
    public function limit(): int { return $this->MAX_GRACZY; }
}

10. Prawda czy fałsz?

• a) Klasa może implementować wiele interfejsów.
• b) Klasa może dziedziczyć po wielu klasach.
• c) Można utworzyć obiekt klasy abstrakcyjnej.
• d) Metody zadeklarowane w interfejsie są publiczne.

11. Co wypisze ten fragment i dlaczego?

$a = new Odznaka(nazwa: 'A', xp: 10);
$b = $a;
$b->zwiekszNagrode(5);
echo $a->pobierzXp();

12. Po zamianie tablic na obiekty ta pętla przerywa skrypt. Podaj komunikat błędu i popraw kod:

foreach ($zadania as $zadanie) {
    echo $zadanie['tytul'] . ' — ' . $zadanie['xp'] . ' XP<br>';
}

13. Zadanie praktyczne. Dopisz do klasy Zadanie metodę czyPilne(int $dni): bool, która zwraca true, gdy zadanie nie jest wykonane, a jego termin przypada najpóźniej za $dni dni (termin na dzisiaj też jest pilny). Wykorzystaj DateTime z Lekcji 7.