Właściwości i metody w programowaniu obiektowym w PHP

Właściwości w programowaniu obiektowym to ten tajemniczy składnik, który sprawia, że obiekty w PHP mają swój indywidualny charakter. Zastanawialiście się kiedyś, co odróżnia obiekt od zwykłej zmiennej? Oto odpowiedź: to właśnie właściwości!
Można je porównać do cech postaci w książce – to, jak wyglądają, jakie mają umiejętności czy cechy charakterystyczne. W programowaniu obiektowym właściwości są często określane jako atrybuty lub pola, a ich kluczowa rola sprowadza się do przechowywania stanu obiektu.

Zacznijmy od definicji. W PHP, właściwości są zmiennymi zdefiniowanymi wewnątrz klasy. Każda właściwość może mieć przypisaną wartość, która definiuje konkretne atrybuty danego obiektu. Przykładowo, jeśli mamy klasę Samochod, możemy zdefiniować właściwości takie jak:

• marka
• model
• rok_produkcji

Właściwości te będą przechowywały konkretne informacje dotyczące obiektów stworzonych na podstawie tej klasy.

Definiowanie właściwości w PHP jest wyjątkowo proste. Użyjemy przedrostków public, protected lub private, aby określić zakres dostępności tych właściwości. Na przykład, jeśli właściwość ma być dostępna dla wszystkich, użyjemy public. Natomiast w przypadku, gdy chcemy, aby była dostępna wyłącznie w obrębie klasy bądź jej podklas, użyjemy protected lub private. Przykład definicji właściwości w klasie mógłby wyglądać tak:

class Cart {
    public string $brand;
    protected string $model;
    private string $year;
}

W tym przykładzie marka jest właściwością publiczną, co oznacza, że można się do niej odnosić zewsząd. Z kolei model jest tylko w obrębie klas dziedziczących, a rok_produkcji jest ukryty przed publicznym dostępem. To świetny sposób na zarządzanie danymi w obiektach i utrzymanie porządku w naszej aplikacji.

Właściwości w klasach PHP nie tylko przechowują dane, ale także mogą zmieniać stany obiektów. Wyobraźcie sobie, że mamy klasę Gracz, która ma właściwość punkty. Kiedy gracz zdobywa punkty, po prostu aktualizujemy tę właściwość, co wpływa na stan i zachowanie obiektu. Prosty sposób, nieprawdaż? Oto przykład:

class Player {
    public int $points;
    public function addPoints(int $points): void 
    {
        $this->points += $points;
    }
}
$gamer1 = new Gamer();
$gamer1->points = 0;
$gamer1->addPoints(10); // Add 10 points

Jak widać, właściwości są kluczowe dla obiektów, a na dodatek znacząco ułatwiają organizację kodu oraz jego czytelność. Dzięki nim możemy skupić się na logice działania programu, a nie na zarządzaniu pojedynczymi zmiennymi. Zrozumienie właściwości w programowaniu obiektowym to również krok w stronę dobrego stylu kodowania. Dobrze zdefiniowane atrybuty to nie tylko elegancja kodu, ale również ułatwienie w jego późniejszej konserwacji.

Oczywiście, oprócz właściwości mamy również metody, które można traktować jako działania, jakie mogą być wykonywane na naszych obiektach. Ale o tym więcej w następnej części, bo naprawdę jest o czym pisać. Już wkrótce podzielimy się z Wami jak właściwości i metody współdziałają ze sobą w PHP, tworząc prawdziwy duet marzeń na polu programowania obiektowego. A teraz, przyjrzyjmy się bliżej metodom, jakie można wykorzystać zdefiniowane wcześniej właściwości.

Budowa metody w PHP

W programowaniu obiektowym w PHP, metody to nic innego jak funkcje zdefiniowane w ramach klasy. Metody opisują działania, które obiekt może wykonywać. Są one kluczowym elementem każdej klasy, ponieważ umożliwiają interakcję z obiektem oraz manipulację jego danymi. Przyjrzyjmy się bliżej budowie metody, typowaniu parametrów, wyników oraz bardziej zaawansowanym przykładom.

Budowa metody
Metoda w PHP składa się z kilku elementów:

• Access modifier: Określa dostęp do metody (np. public, protected, private).
• Return type: Określa, jaki typ danych metoda zwróci (np. string, int, bool, void).
• Parameters: Możemy przekazać metodzie różne dane w postaci parametrów. Parametry można typować i definiować ich domyślne wartości.

Zobaczmy przykład prostej metody z parametrem i typowaniem wyniku:

// Example of a class with a typed method
class MathOperations {
    // Method that adds two numbers
    public function addNumbers(int $num1, int $num2): int {
        return $num1 + $num2;
    }
}
// Create an object of the class
$math = new MathOperations();
echo $math->addNumbers(5, 10); // Outputs: 15

W powyższym przykładzie metoda addNumbers przyjmuje dwa parametry typu int i zwraca wynik również jako int.

Metoda z wieloma parametrami i domyślnymi wartościami
Możemy zdefiniować metody z wieloma parametrami, a niektóre z nich mogą mieć domyślne wartości. Dzięki temu, jeśli użytkownik nie poda wartości dla parametru, używana jest wartość domyślna.

// Example of a method with default parameter values
class Greeting {
    // Method that generates a greeting message
    public function createGreeting(string $name, string $title = "Mr./Ms."): string {
        return "Hello, " . $title . " " . $name . "!";
    }
}

// Create an object of the class
$greet = new Greeting();
echo $greet->createGreeting("John"); // Outputs: Hello, Mr./Ms. John!
echo $greet->createGreeting("Jane", "Dr."); // Outputs: Hello, Dr. Jane!

W powyższym przykładzie parametr $title ma domyślną wartość "Mr./Ms.". Jeśli użytkownik jej nie poda, zostanie użyta ta wartość.

Metoda zwracająca różne typy danych
PHP pozwala na zdefiniowanie metody, która może zwracać różne typy danych za pomocą deklaracji | (union types). Na przykład metoda może zwracać string lub bool w zależności od warunku.

// Example of a method with union return type
class User {
    // Method to find user by ID
    public function findUserById(int $id): bool|string {
        if ($id === 1) {
            return "User found: John Doe";
        }
        return false; // User not found
    }
}

// Create an object of the class
$user = new User();
$result = $user->findUserById(1);
if ($result !== false) {
    echo $result; // Outputs: User found: John Doe
} else {
    echo "User not found.";
}

W tym przykładzie metoda findUserById zwraca string, gdy użytkownik zostanie znaleziony, lub false, gdy go nie znajdzie.

Metody w obiektowym PHP – co warto wiedzieć?

Przechodząc do serca programowania obiektowego w PHP, nie możemy zapomnieć o metodach. Są one niczym magiczne klucze, które otwierają drzwi do funkcjonalności obiektów. A jeśli myślisz, że metody występują tylko w domenie czarodziejów lub filmów fantasy, to czas wyjść ze swojej baśniowej krainy. Metody w PHP to zdecydowanie coś więcej niż tylko czyszczenie magicznego ekwipunku. W końcu, chodzi tu o wyprawy po gziki w nieznane obszary kodu.

W programowaniu obiektowym mamy do czynienia z trzema głównymi typami metod: publiczne, prywatne i chronione. Każda z tych metod ma swoje unikalne właściwości, które wpływają na to, w jaki sposób obiekty i klasy współdziałają ze sobą w PHP.

Publiczne metody są jak otwarte drzwi do domu – każdy może do nich wejść. Definiując metodę jako publiczną, dajesz jej dostęp z zewnątrz, co oznacza, że można ją wywoływać wszędzie tam, gdzie dostępny jest obiekt danej klasy. Dzięki nim możemy interakcjonować z obiektem z różnych miejsc w naszym kodzie. Na przykład:

// Class definition
class User {
    public string $name;
    public function __construct(string $name) {
        $this->name = $name;
    }
    public function greet(): string
    {
        return "Hello, my name is " . $this->name;
    }
}
// Creating an object
$user = new User("Alice");
// Calling a public method
echo $user->greet(); // Outputs: Hello, my name is Alice

Powyższy przykład doskonale ilustruje, jak publiczne metody ułatwiają komunikację z obiektem. Wystarczy, że stworzymy instancję klasy, a następnie wywołamy metodę. Proste i przyjemne, prawda?

Teraz przejdźmy do prywatnych metod. Wyobraź sobie, że masz prawdziwy skarbiec pełen złota, który tylko Ty możesz otworzyć. Prywatne metody działają na tej samej zasadzie. Zdefiniowane w klasie, są dostępne tylko wewnątrz tej klasy i nie można ich bezpośrednio wywoływać spoza niej. To doskonały sposób na ukrycie logiki, która nie powinna być dostępna na zewnątrz. Zobaczmy, jak to wygląda:

// Class definition
class User {
    private int $age;
    public function __construct(int $age) {
        $this->age = $age;
    }
    private function getAge(): int
    {
        return $this->age;
    }
    public function displayAge(): string
    {
        return "I am " . $this->getAge() . " years old.";
    }
}
// Creating an object
$user = new User(30);
// Trying to call a private method will throw an error
// echo $user->getAge(); // Uncommenting this will cause an error
// Calling a public method
echo $user->displayAge(); // Outputs: I am 30 years old.

No dobrze, a co z metodami chronionymi? Wyobraź sobie, że masz drzwi, które możesz otworzyć, ale tylko pewne osoby mają do nich klucz. Chronione metody w PHP umożliwiają dostęp do metod zarówno z danej klasy, jak i jej podklas. Owszem, to jakby otworzyć drzwi dla rodziny i bliskich przyjaciół, ale zamknąć je przed obcymi. Zobaczmy przykład:

// Base class
class User {
    protected string $name;
    public function __construct(string $name) {
        $this->name = $name;
    }
    protected function getName() {
        return $this->name;
    }
}
// Derived class
class Admin extends User {
    public function displayName(): string
    {
        return "Admin name: " . $this->getName();
    }
}
// Creating an object
$admin = new Admin("Bob");
// Calling a method from derived class
echo $admin->displayName(); // Outputs: Admin name: Bob

Jak widać, chronione metody to świetny sposób na rozszerzanie funkcjonalności, jednocześnie zachowując pewne ograniczenia. Dzięki nim możemy tworzyć hierarchię klas, w której podklasy dziedziczą możliwości ze swoich nadklas.

Właściwe zrozumienie i umiejętność korzystania z metod publicznych, prywatnych oraz chronionych to klucz, który otworzy przed Tobą nowe drzwi w świecie programowania obiektowego w PHP. Dzięki nim nasza aplikacja staje się bardziej zorganizowana i bardzo czytelna – a to zawsze mile widziane!