PHP Academy · Lekcja

Właściwości i metody statyczne

Używaj elementów statycznych i poznaj sytuacje, w których można wywołać je bez instancji

Właściwości i metody statyczne to bezpłatna lekcja PHP Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej PHP Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs PHP Academy zawiera 4 lekcji w sumie.

Wprowadzenie: właściwości i metody statyczne

Elementy statyczne należą do samej klasy, a nie do konkretnej instancji. Dostęp do nich uzyskuje się za pomocą ClassName::member lub self:: wewnątrz klasy. Są współdzielone przez wszystkie instancje.

Podstawowe pojęcia

Najważniejsze pojęcia dotyczące właściwości i metod statycznych:

Deklaruje się je za pomocą słowa kluczowego static
Dostęp uzyskuje się za pomocą :: (operatora rozwiązywania zakresu)
self:: stosuje się wewnątrz klasy, a ClassName:: — poza nią
Późne wiązanie statyczne wykorzystuje static::

Właściwość statyczna

Przykład:

<?php
class AppConfig {
    private static array $settings = [];

    public static function set(string $key, mixed $val): void {
        self::$settings[$key] = $val;
    }

    public static function get(string $key, mixed $default = null): mixed {
        return self::$settings[$key] ?? $default;
    }
}

AppConfig::set('debug', true);
echo AppConfig::get('debug') ? 'debug on' : 'debug off';

Metoda statyczna

Ciąg dalszy:

<?php
class MathHelper {
    public static function clamp(float $v, float $min, float $max): float {
        return max($min, min($max, $v));
    }

    public static function lerp(float $a, float $b, float $t): float {
        return $a + ($b - $a) * $t;
    }
}

echo MathHelper::clamp(150, 0, 100); // 100
echo MathHelper::lerp(0, 100, 0.5);  // 50

Wzorzec Singleton

Ćwiczenie:

<?php
class Database {
    private static ?Database $instance = null;

    private function __construct() {
        echo 'Connected to DB';
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$db1 = Database::getInstance();  // 'Connected to DB'
$db2 = Database::getInstance();  // no output — same instance
echo ($db1 === $db2) ? 'same' : 'different'; // same

Licznik statyczny

Więcej szczegółów:

<?php
class EventEmitter {
    private static int $instanceCount = 0;

    public function __construct() {
        self::$instanceCount++;
    }

    public static function count(): int {
        return self::$instanceCount;
    }
}

new EventEmitter();
new EventEmitter();
new EventEmitter();
echo EventEmitter::count();  // 3

Późne wiązanie statyczne

Użycie zaawansowane:

<?php
class ParentClass {
    public static function create(): static {
        return new static();  // resolves to calling subclass
    }

    public function getClass(): string {
        return static::class;  // late static binding
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::create();
echo $obj->getClass();  // ChildClass

Fabryka statyczna

Wzorzec stosowany w praktyce:

<?php
class Response {
    private function __construct(
        private int   $status,
        private mixed $body
    ) {}

    public static function ok(mixed $data): self {
        return new self(200, $data);
    }

    public static function notFound(): self {
        return new self(404, ['error' => 'Not Found']);
    }

    public function toJson(): string {
        return json_encode(['status' => $this->status, 'body' => $this->body]);
    }
}

echo Response::ok(['users' => []])->toJson();

Właściwości statyczne a instancje — kompromisy

Najlepsze praktyki:

<?php
// Static: no object needed, but harder to test/mock
class Validator {
    public static function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}

// Instance: injectable dependency, testable
class ValidatorService {
    public function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}
// Prefer instance classes in larger applications

Wzorzec praktyczny

Połączmy wszystkie elementy, korzystając z praktycznego wzorca dotyczącego właściwości i metod statycznych.

Typowe pułapki

Unikaj tych typowych błędów związanych z właściwościami i metodami statycznymi:

Elementy statyczne są współdzielone przez wszystkie instancje
W klasach przeznaczonych do dziedziczenia preferuj późne wiązanie statyczne (static::) zamiast self::
Singletony są powszechnym, lecz czasami nadużywanym wzorcem
Metody statyczne trudniej mockować w testach jednostkowych

Szybkie sprawdzenie

Jakie słowo kluczowe umożliwia dostęp do właściwości statycznej wewnątrz klasy z uwzględnieniem dziedziczenia (późnego wiązania statycznego)?

Podsumowanie: właściwości i metody statyczne

Omówiliśmy właściwości i metody statyczne. Najważniejsze informacje:

Elementy statyczne są współdzielone przez wszystkie instancje
W klasach przeznaczonych do dziedziczenia preferuj późne wiązanie statyczne (static::) zamiast self::
Singletony są powszechnym, lecz czasami nadużywanym wzorcem
Metody statyczne trudniej mockować w testach jednostkowych

Często zadawane pytania

Czy lekcja „Właściwości i metody statyczne” jest bezpłatna?

Tak — pełny tekst „Właściwości i metody statyczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu PHP Academy, przejdź na CoddyKit PRO. Kurs PHP Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Właściwości i metody statyczne”?

Używaj elementów statycznych i poznaj sytuacje, w których można wywołać je bez instancji Ćwiczysz PHP Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć PHP Academy?

Nie wymagamy żadnego doświadczenia. PHP Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Właściwości i metody statyczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji PHP Academy?

Tak. Każda lekcja PHP Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do PHP Academy