Metode și proprietăți statice

Pe lângă metodele și proprietățile obișnuite cu diferiți modificatori de acces, o clasă poate conține metode și proprietăți statice. Aceste metode și proprietăți sunt marcate cu cuvântul cheie static.

Metodele și proprietățile statice sunt create o singură dată pentru întreaga clasă și aparțin întregii clase, în timp ce pentru proprietățile și metodele nestatice este creată o copie separată pentru fiecare obiect.

<?php
class Person
{
   public $name, $age;
   static $retirementAge = 65;
   function __construct($name, $age)
   {
       $this->name = $name;
       $this->age = $age;
   }
   function sayHello()
   {
       echo "Salut, mă numesc $this->name<br>";
   }
   static function printPerson($person)
   {
       echo "Nume: $person->name Vârstă: $person->age<br>";
   }
}
?>

Aici este definită o proprietate statică retirementAge, care stochează vârsta de pensionare. Dacă vârsta este un indicator specific unei persoane și poate fi diferit pentru diferite persoane, vârsta de pensionare este de obicei stabilită la un nivel general pentru toți.

Prin urmare, această proprietate poate fi făcută statică - ea aparține întregii clase Person, nu este setată separat pentru fiecare obiect. Pentru a declara o proprietate statică, înainte de numele acesteia se pune modificatorul static:

static $retirementAge = 65;

De asemenea, în clasă este definită o metodă statică printPerson(), care afișează informații despre persoana care este transmisă ca parametru metodei. Această metodă nu depinde de un anumit obiect al clasei Person, ci aparține întregii clase Person. Pentru a declara o metodă statică, înainte de cuvântul function se pune modificatorul static:

static function printPerson($person)
{
   echo "Nume: $person->name Vârstă: $person->age<br>";
}

Când apelăm metode și proprietăți statice, folosim numele clasei și operatorul ::, în locul operatorului de acces ->, deoarece metoda statică aparține întregii clase, nu unui anumit obiect al acestei clase.

<?php
class Person
{
   public $name, $age;
   static $retirementAge = 65;
   function __construct($name, $age)
   {
       $this->name = $name;
       $this->age = $age;
   }
   function sayHello()
   {
       echo "Salut, mă numesc $this->name<br>";
   }
   static function printPerson($person)
   {
       echo "Nume: $person->name Vârstă: $person->age<br>";
   }
}
$tom = new Person("Tom", 36);
// apelarea metodei nestatice
$tom->sayHello();

// apelarea metodei statice
Person::printPerson($tom);
// accesarea proprietății statice
echo "Vârsta de pensionare: " . Person::$retirementAge . "<br>";
?>

Rezultatul programului:

Salut, mă numesc Tom
Nume: Tom Vârstă: 36
Vârsta de pensionare: 65

Pentru a accesa proprietățile și metodele statice din interiorul clasei, în locul numelui clasei poate fi folosit cuvântul cheie self. De exemplu, adăugăm în clasa Person o metodă care va calcula cât mai are o persoană până la pensionare:

<?php
class Person
{
   public $name, $age;
   static $retirementAge = 65;
   function __construct($name, $age)
   {
       $this->name = $name;
       $this->age = $age;
   }
   function sayHello()
   {
       echo "Salut, mă numesc $this->name<br>";
   }
   static function printPerson($person)
   {
       echo "Nume: $person->name Vârstă: $person->age<br>";
   }
   function checkAge()
   {
       if($this->age >= self::$retirementAge)
           echo "Este timpul pentru pensionare<br>";
       else
           echo "Mai sunt " . (Person::$retirementAge - $this->age) . " ani până la pensionare<br>";
   }
}
$tom = new Person("Tom", 36);
$tom->checkAge();
?>

Rezultatul programului:

Mai sunt 29 ani până la pensionare

Este de menționat că în metodele statice putem accesa doar proprietăți și metode statice. Nu putem accesa proprietăți și metode nestatice prin $this. De exemplu:

static function printPerson($person)
{
   echo "Nume: $person->name Vârstă: $person->age<br>";
   // în metodele statice putem accesa metode și proprietăți statice
   echo "Vârsta de pensionare: " . self::$retirementAge . "<br>";
   // dar nu putem accesa metode și proprietăți nestatice
   // echo "Nume: " . $this->name . "<br>";    // nu este permis
   // $this->sayHello();    // nu este permis
}

Aici, în metoda statică printPerson(), putem accesa variabila statică retirementAge:

echo "Vârsta de pensionare: " . self::$retirementAge . "<br>";

Dar nu putem accesa proprietăți și metode nestatice:

// echo "Nume: " . $this->name . "<br>";    // nu este permis
// $this->sayHello();    // nu este permis

În același timp, metodele și proprietățile statice pot avea și modificatori de acces. De exemplu, să modificăm clasa Person astfel:

<?php
class Person
{
   public $name;
   private $id;
   private static $counter = 0;
     
   function __construct($name)
   {
       self::$counter++;
       $this->id = self::$counter;
       $this->name = $name;
   }
   
   static function getCounter()
   {
       return self::$counter;
   }
   function getId()
   {
       return $this->id;
   }
}
$tom = new Person("Tom");
$bob = new Person("Bob");
echo "$tom->name are id: " . $tom->getId() . "<br>";
echo "$bob->name are id: " . $bob->getId() . "<br>";
echo "Număr total de utilizatori: " .  Person::getCounter();
?>

În clasa Person este definită proprietatea $id, care reprezintă identificatorul utilizatorului. De asemenea, este definită o proprietate statică privată $counter, care stochează numărul total de utilizatori creați. În constructor, mărim variabila statică cu o unitate și apoi setăm valoarea acesteia pentru proprietatea $id.

Numărul total de utilizatori creați este un atribut general pentru întreaga clasă, care nu depinde de un anumit obiect. Totuși, nu este de dorit ca această valoare să poată fi modificată din exterior. De aceea, proprietatea $counter este definită ca privată. Pentru a vedea valoarea acesteia, este definită metoda statică getCounter().

Rezultatul programului:

Tom are id: 1
Bob are id: 2
Număr total de utilizatori: 2