Klasa 2 · rozdział 7

Programowanie obiektowe w PHP

Tablica asocjacyjna trzyma dane pod kluczami. Gdy do danych dochodzą czynności („dodaj punkty”, „policz brutto”), zapisujesz je razem: klasa to wzorzec, obiekt to jeden konkretny egzemplarz.

Po tym rozdziale powinieneś umieć

  • odróżnić klasę (wzorzec) od obiektu (jednego egzemplarza);
  • napisać klasę z właściwościami, konstruktorem i metodą oraz utworzyć obiekt przez new;
  • wyjaśnić, że $this to ten obiekt, na którym właśnie wywołano metodę;
  • ukryć pole słowem private i wystawić je przez getter albo setter;
  • rozszerzyć klasę przez extends i wywołać konstruktor rodzica;
  • odróżnić składnik static (należy do klasy) od pola jednego obiektu.

1. Klasa i obiekt

Formularz „karta ucznia” jest jeden: ma rubryki imię i punkty. Wypełnionych kart jest wiele — Ania ma 86 punktów, Bartek 40. Rubryki się nie zmieniają, wartości tak. W programie formularz to klasa, wypełniona karta to obiekt.

Klasa Obiekt
Co to jest Wzorzec: jakie pola i jakie czynności Jeden konkretny egzemplarz wzorca
Ile ich jest Zwykle jedna definicja w pliku Tyle, ile razy napiszesz new
Przykład class Uczen $ania, $bartek
Dane Nazwy pól: imię, punkty Wartości: „Ania”, 86

Dwa obiekty tej samej klasy nie dzielą wartości. Dopisanie punktów Ani nie zmienia punktów Bartka. To najważniejsza różnica wobec jednej tablicy $uczen, w której mieści się tylko jeden rekord. Listę uczniów da się trzymać w tablicy obiektów — każdy element to osobna karta.

Słownictwo Właściwość (pole) — dana w obiekcie, np. imię.
Metoda — funkcja zapisana w klasie, np. „czy zaliczony”.
Instancja — inna nazwa obiektu utworzonego z klasy.

Ten sam pomysł jest w JavaScript (class, new, this). Zapis w PHP ma dolara przy zmiennych i strzałkę -> przy polu. W JS piszesz this.imie, w PHP $this->imie.

2. Właściwości, metody, new

Klasę otwierasz słowem class i nazwą. Nazwa zwykle z wielkiej litery: Uczen, nie uczen. W środku są pola i metody. Na start pole jest public — da się je odczytać spoza klasy. Widoczność (private) jest w dalszej sekcji.

class Uczen {
    public $imie;
    public $punkty;

    public function czyZaliczony() {
        return $this->punkty >= 50;
    }
}

new Uczen tworzy obiekt. Potem do pól wchodzisz strzałką ->. To nie jest => z tablicy asocjacyjnej. Przy właściwości nie ma nawiasu. Przy metodzie nawias jest — tak jak przy zwykłej funkcji.

$ania = new Uczen();
$ania->imie = "Ania";
$ania->punkty = 86;

$bartek = new Uczen();
$bartek->imie = "Bartek";
$bartek->punkty = 40;

echo $ania->imie;                         // Ania
var_dump($ania->czyZaliczony());        // true
var_dump($bartek->czyZaliczony());      // false

Jedna metoda czyZaliczony obsługuje obie karty. Przy $ania->czyZaliczony() w środku $this->punkty to 86. Przy $bartek->czyZaliczony() to 40. $this znaczy: ten obiekt, na którym właśnie wywołano metodę.

Strzałka, nie tablica Pole obiektu: $ania->imie. Klucz tablicy: $ania["imie"] — tak było w poprzednim rozdziale. Na obiekcie nawias kwadratowy nie czyta właściwości.

3. Konstruktor i $this

Ustawianie pól po new łatwo pominąć: obiekt bez imienia i bez punktów. Konstruktor to metoda __construct, którą PHP woła samo w momencie new. Argumenty z nawiasu przy new trafiają do konstruktora.

class Uczen {
    public $imie;
    public $punkty;

    public function __construct($imie, $punkty) {
        $this->imie = $imie;
        $this->punkty = $punkty;
    }

    public function czyZaliczony() {
        return $this->punkty >= 50;
    }

    public function dodajPunkty($ile) {
        $this->punkty = $this->punkty + $ile;
    }
}

$ania = new Uczen("Ania", 86);
$bartek = new Uczen("Bartek", 40);
$bartek->dodajPunkty(15);

Ślad new Uczen("Ania", 86):

  1. PHP tworzy pusty obiekt klasy Uczen.
  2. Woła __construct("Ania", 86). W tym wywołaniu $this to właśnie ten nowy obiekt.
  3. $this->imie = $imie wpisuje „Ania” w pole tego obiektu, nie w zmienną lokalną, która zniknie.
  4. new oddaje gotowy obiekt do $ania.

Po $bartek->dodajPunkty(15) Bartek ma 55 punktów. Ania nadal 86. Metoda zmienia tylko obiekt przed strzałką.

echo $ania->punkty;      // 86
echo $bartek->punkty;    // 55
Dwa dolary $this — obiekt, na którym stoisz.
$this->punkty — pole tego obiektu. Po strzałce nie piszesz drugiego dolara: $this->$punkty szukałoby pola o nazwie trzymanej w zmiennej $punkty.

Parametr konstruktora i pole mogą nazywać się tak samo ($imie i $this->imie). Bez $this-> przypisanie $imie = $imie nic nie zapisuje w obiekcie — przestawiasz parametr na samego siebie.

4. public, private, protected

Słowo przed polem albo metodą mówi, kto może do tego sięgnąć.

Z zewnątrz ($ania->…) W metodzie tej klasy W klasie potomnej
public tak tak tak
protected nie tak tak
private nie tak nie
class Uczen {
    public $imie;
    private $punkty;

    public function __construct($imie, $punkty) {
        $this->imie = $imie;
        $this->punkty = $punkty;
    }

    public function czyZaliczony() {
        return $this->punkty >= 50;
    }
}

$ania = new Uczen("Ania", 86);
echo $ania->imie;                  // Ania
var_dump($ania->czyZaliczony());   // true — metoda wolno, ona czyta private
// echo $ania->punkty;           ← błąd: pole prywatne

Metoda czyZaliczony jest w klasie, więc widzi $this->punkty. Kod strony, poza klasą, już nie. Dzięki temu nikt nie wpisze punktów „z boku”, omijając zasadę, którą trzymasz w metodzie.

protected przyda się przy dziedziczeniu: klasa potomna może czytać pole, a kod strony nadal nie. Przykład jest w sekcji o extends.

5. Gettery, settery, hermetyzacja

Pole private nie znika. Wystawiasz je metodami: getter czyta, setter zapisuje. Hermetyzacja znaczy: dane są schowane, a zmiana idzie przez metodę, w której stoi reguła (np. „saldo nie spada poniżej zera”).

class Konto {
    private $saldo;

    public function __construct($saldo) {
        $this->setSaldo($saldo);
    }

    public function getSaldo() {
        return $this->saldo;
    }

    public function setSaldo($saldo) {
        if ($saldo < 0) {
            $saldo = 0;
        }
        $this->saldo = $saldo;
    }
}

$k = new Konto(100);
$k->setSaldo(-20);
echo $k->getSaldo();    // 0

Konstruktor woła setSaldo, więc ta sama reguła działa przy tworzeniu i przy późniejszej zmianie. Zapis $k->saldo = -20 kończy się błędem: pole jest prywatne, spoza klasy go nie widać.

Getter bywa jedyną metodą, gdy pole tylko czytasz (imię ustawione w konstruktorze i już). Setter dodajesz, gdy wolno wartość zmienić i chcesz ją sprawdzić.

class Uczen {
    private $imie;
    private $punkty;

    public function __construct($imie, $punkty) {
        $this->imie = $imie;
        $this->setPunkty($punkty);
    }

    public function getImie() {
        return $this->imie;
    }

    public function getPunkty() {
        return $this->punkty;
    }

    public function setPunkty($punkty) {
        if ($punkty < 0) {
            $punkty = 0;
        }
        if ($punkty > 100) {
            $punkty = 100;
        }
        $this->punkty = $punkty;
    }
}
Po co chować pole Przy public $punkty każda linia skryptu może wpisać 999 albo −5. Przy private i setPunkty zakres 0–100 jest w jednym miejscu. Reszta kodu woła metodę i nie powtarza warunku.

6. Dziedziczenie: extends i parent

Nowa klasa może przejąć pola i metody istniejącej. extends znaczy „jest rodzajem”. Uczen jest rodzajem Osoba: ma imię jak każda osoba i dodatkowo punkty. Klasa po lewej (potomek) dostaje to, co ma klasa po prawej (rodzic), i może dodać własne.

class Osoba {
    protected $imie;

    public function __construct($imie) {
        $this->imie = $imie;
    }

    public function przedstawSie() {
        return "Jestem " . $this->imie;
    }
}

class Uczen extends Osoba {
    private $punkty;

    public function __construct($imie, $punkty) {
        parent::__construct($imie);
        $this->punkty = $punkty;
    }

    public function opis() {
        return $this->imie . " — " . $this->punkty . " pkt";
    }
}

$ania = new Uczen("Ania", 86);
echo $ania->przedstawSie();   // Jestem Ania — metoda z rodzica
echo $ania->opis();            // Ania — 86 pkt

parent::__construct($imie) woła konstruktor Osoba, żeby imię zapisało się w polu rodzica. Bez tej linii potomek miałby punkty, a imię zostałoby puste. parent:: to „metoda rodzica”, nie obiekt.

$this->imie w opis działa, bo pole jest protected: potomek je widzi. Z zewnątrz $ania->imie już nie. Gdyby w Osoba pole było private, nawet Uczen nie mógłby napisać $this->imie — zostałby getter w rodzicu, np. $this->przedstawSie().

Kiedy dziedziczyć „Uczen jest osobą” — tak, wspólne imię i przedstawienie się. „Uczen jest punktami” — nie. Punkty to pole, nie druga klasa w hierarchii. Jeśli dwie klasy tylko przypadkiem mają po jednym polu o podobnej nazwie, nie łącz ich przez extends.

7. static i stałe klasy

Zwykłe pole żyje w jednym obiekcie: Ania ma swoje punkty, Bartek swoje. Składnik static należy do klasy. Jest jeden na wszystkich uczniów, np. licznik „ilu uczniów już utworzono”.

class Uczen {
    public static $ile = 0;
    public $imie;

    public function __construct($imie) {
        $this->imie = $imie;
        self::$ile++;
    }
}

$ania = new Uczen("Ania");
$bartek = new Uczen("Bartek");
echo Uczen::$ile;     // 2

Z zewnątrz: Uczen::$ile — nazwa klasy, dwa dwukropki, dolar przy polu. W metodzie: self::$ile — „ta klasa”, nie „ten obiekt”. $ania->ile nie jest sposobem na pole statyczne.

Stała klasy też należy do wzorca, nie do jednej karty. Nie ma przy niej dolara. Wartości nie zmieniasz w trakcie skryptu.

class Cennik {
    public const VAT = 23;

    public function brutto($netto) {
        return $netto * (1 + self::VAT / 100);
    }
}

echo Cennik::VAT;                              // 23
$c = new Cennik();
echo $c->brutto(100);                        // 123
Co gdzie trzymać Inna wartość u każdego obiektu (imię, saldo) → zwykłe pole i $this. Jedna liczba dla całej klasy (ile obiektów powstało, stawka VAT) → static albo const. const, gdy wartość stoi. static, gdy skrypt ją zmienia (licznik).

Ćwiczenia do samodzielnego wykonania

Pliki w C:\xampp\htdocs\cwiczenia-php, http://localhost/cwiczenia-php/…. Apache włączony. Klasy możesz trzymać w tym samym pliku co stronę albo w require_once.

Ćwiczenie 1. Dwie karty łatwe

Klasa Uczen z publicznymi polami $imie i $punkty. Utwórz dwa obiekty, ustaw pola po new i wypisz imiona. Zmień punkty tylko pierwszego. W komentarzu: czemu drugi obiekt został przy swojej liczbie.

Ćwiczenie 2. Konstruktor i metoda łatwe

Te same dane wstawiaj w __construct. Metoda czyZaliczony zwraca prawdę przy punktach ≥ 50. Wypisz wynik dla ucznia poniżej progu i powyżej. echo zostaw poza metodą.

Ćwiczenie 3. Pole prywatne średnie

Punkty zrób private. Odczyt przez getPunkty. Sprawdź w przeglądarce, co się dzieje przy echo $uczen->punkty (komunikat błędu) i jak działa getter. Imię może zostać publiczne.

Ćwiczenie 4. Setter z regułą średnie

setPunkty przycina wartość do zakresu 0–100. Konstruktor ma wołać setter, nie wpisywać pola z boku. Przetestuj −5, 40 i 150. W komentarzu: czemu reguła nie jest powtórzona w trzech miejscach skryptu.

Ćwiczenie 5. extends trudne

Klasa Osoba z protected $imie i metodą przedstawSie. Klasa Uczen extends Osoba dokłada punkty. Konstruktor ucznia woła parent::__construct. Na stronie wypisz przedstawienie i opis z punktami. Spróbuj odczytać $imie spoza klas i zapisz w komentarzu, czemu chroni je protected.

Ćwiczenie 6. Dwie klasy trudne

Produkt (nazwa, cena netto, metoda brutto ze stawką). Osobno stała VAT albo pole static z liczbą utworzonych produktów, zwiększana w konstruktorze. Utwórz dwa produkty i wypisz licznik oraz brutto jednego z nich. W komentarzu: co jest wspólne dla wszystkich produktów, a co ma każdy z osobna, i czemu cena nie jest static.

Licznik: self::$ile++ w konstruktorze, odczyt Produkt::$ile. Cena zostaje zwykłym polem, bo każdy produkt ma inną.

Sprawdź się

1. Klasa i obiekt:
2. $this w metodzie dodajPunkty:
3. new Uczen("Ania", 86) przy konstruktorze __construct($imie, $punkty):
4. Pole private $punkty:
5. parent::__construct($imie) w klasie potomnej:
6. public static $ile zwiększane w konstruktorze:

Wymagania na ocenę

Ocena wyższa zawiera wymagania na oceny niższe.

Ocena Uczeń
2 Odróżnia klasę od obiektu. W gotowym kodzie wskazuje $this i mówi, że to ten obiekt, na którym wywołano metodę.
3 Definiuje class z konstruktorem i metodą. Tworzy obiekt przez new i wywołuje metodę.
4 Stosuje public i private. Używa $this w kilku metodach. Dwa obiekty tej samej klasy mają osobne wartości pól.
5 Stosuje extends i parent::__construct. Pisze getter albo setter. Uzasadnia, po co pole jest prywatne. Odróżnia static od pola obiektu.
6 Dzieli zadanie na więcej niż jedną klasę i uzasadnia, co jest wspólne (stała, licznik), a co należy do jednego obiektu (cena, imię).

Lista „już umiem”