Php Classes And Objects Complete Guide

PHP Classes and Objects

Defining a Class: A class in PHP serves as a blueprint for creating objects. It encapsulates data properties and functions that manipulate the data, providing a way to structure your code.

class Vehicle {
    // Properties
    public $color;
    protected $brand;
    private $model;

    // Methods
    public function setColor($color) {
        $this->color = $color;
    }

    public function getColor() {
        return $this->color;
    }

    protected function setBrand($brand) {
        $this->brand = $brand;
    }

    protected function getBrand() {
        return $this->brand;
    }

    private function setModel($model) {
        $this->model = $model;
    }

    private function getModel() {
        return $this->model;
    }
}

• Public: Accessible from anywhere.
• Protected: Accessible within the class and by inheriting classes.
• Private: Accessible only within the class it is declared.

Creating an Object: Objects are instances of a class. You can create objects using the new keyword.

$car = new Vehicle();

Setting and Getting Values: To interact with a class’s properties, you typically use its methods.

$car->setColor('Blue');
echo $car->getColor(); // Output: Blue

Constructor Method: A constructor is a method called when an object is instantiated. It’s defined using the __construct() magic method.

class Vehicle {
    public $color;
    protected $brand;
    private $model;

    public function __construct($color, $brand, $model) {
        $this->color = $color;
        $this->setBrand($brand);
        $this->setModel($model);
    }

    // Rest of the class methods remain unchanged
}

$car = new Vehicle('Blue', 'Toyota', 'Corolla');

Magic Methods: PHP has several magic methods that start with double underscores (__). They perform special operations when specific conditions occur.

• __construct(): Constructor method, called when an object is created.
• __destruct(): Destructor method, called when an object is destroyed or script execution ends.
• __get(), __set(): Used to handle getting and setting inaccessible properties.
• __toString(): Invoked during string conversion, allows defining object behavior when cast to a string.
• __invoke(): Allows an object to be treated like a function.
• __call(), __callStatic(): Triggered when attempting to call an undefined or inaccessible method.

Inheritance: Classes can inherit properties and methods from a parent class using the extends keyword.

class Car extends Vehicle {
    public function displayInfo() {
        echo "Car Color: " . $this->color . "\n";
        echo "Car Brand: " . $this->getBrand() . "\n"; // Works because this class inherits from Vehicle
        // Cannot access $this->model directly due to private visibility in Vehicle
    }
}

$myCar = new Car('Red', 'Honda', 'Civic');
$myCar->displayInfo();

Abstract Classes: An abstract class cannot be instantiated on its own but must be inherited. Such classes often contain one or more abstract methods which do not have a body and must be implemented in the child classes.

abstract class Animal {
    abstract protected function makeSound();

    public function run() {
        echo "Animal is running.";
    }
}

class Dog extends Animal {
    protected function makeSound() {
        echo "Woof Woof!";
    }
}

$dog = new Dog();
$dog->makeSound(); // Output: Woof Woof!
$dog->run();        // Output: Animal is running.

Interfaces: Interfaces declare methods that a class must implement, without defining how these methods should work (method bodies). Use the implements keyword to inherit from an interface.

interface Playable {
    public function play();
}

class Piano implements Playable {
    public function play() {
        echo "Piano is playing music.";
    }
}

$piano = new Piano();
$piano->play(); // Output: Piano is playing music.

Static Properties and Methods: Static properties and methods belong to the class rather than an instance of the class.

class Counter {
    public static $count = 0; // Static property

    public static function increment() { // Static method
        self::$count++;
    }
}

Counter::increment();
echo Counter::$count; // Output: 1

• self:: keyword refers to the current class within a class context.

Class Constants: Constants are declared inside a class with the const keyword and are accessed using the :: scope resolution operator.

class Product {
    const TAX_RATE = 0.07;

    public function calculateTax($price) {
        return $price * self::TAX_RATE;
    }
}

echo Product::TAX_RATE; // Output: 0.07
$product = new Product();
echo $product->calculateTax(100); // Output: 7

Encapsulation: Encapsulation limits the accessibility of certain parts of the code. It keeps the internal state of an object hidden and protected from the outside world, only exposing necessary functionality through public methods.

Polymorphism: Polymorphism allows methods to do different things based on the object it is acting upon. Most commonly seen through method overriding — where a child class redefines the functionality of a method inherited from its parent.

class Animal {
    public function speak() {
        echo "Some generic animal sound.";
    }
}

class Cat extends Animal {
    public function speak() {
        echo "Meow!";
    }
}

$animal = new Animal();
$cat = new Cat();

echo $animal->speak(); // Output: Some generic animal sound.
echo $cat->speak();    // Output: Meow!

Access Modifiers:

• Public: The method or property can be accessed from anywhere.
• Protected: Accessible within the class and all classes derived from it.
• Private: Accessible only within the class it is declared.

Final Keyword: When used before a method, it prevents the method from being overridden in any class which inherits it. When used before a class, it prevents other classes from extending from it.

class Base {
    final public function greet() {
        echo "Hi from Base class.";
    }
}

class Derivative extends Base {
    // public function greet() {} // Error: Cannot override final method from Base
}

Traits: Traits provide a mechanism for code reuse in single inheritance languages like PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies.

trait MyTrait {
    public function sayHello() {
        echo "Hello from Trait!";
    }
}

class MyClass {
    use MyTrait;
}

$obj = new MyClass();
$obj->sayHello(); // Output: Hello from Trait!

Namespace: Namespaces help avoiding name collisions when combining libraries and projects developed independently. Each namespace begins with the namespace keyword.

namespace Vehicles;

class Motorcycle {
    // Motorcycle class details
}

// Usage
$motorcycle = new Vehicles\Motorcycle();

Autoloading Classes: PHP provides mechanisms for automatically loading classes using spl_autoload_register and require_once.

spl_autoload_register(function ($class_name) {
    include $class_name . '.php';
});

$obj = new MyClass(); // MyClass.php will be loaded automatically

Reflection API: PHP provides a Reflection API that gives you information about methods, properties, and other aspects of PHP classes and objects at runtime.

$reflectionClass = new \ReflectionClass('Vehicle');
$properties = $reflectionClass->getProperties();
foreach($properties as $property) {
    echo $property->getName() . "\n";
}

Reflection API Example: Retrieve all properties, including their visibilities and values of an object.

$vehicle = new Vehicle('Gray', 'Ford', 'Mustang');

$reflectionVehicle = new ReflectionObject($vehicle);

$properties = $reflectionVehicle->getProperties();
foreach ($properties as $prop) {
    if (!$prop->isPublic()) {
        $prop->setAccessible(true);
    }
    echo $prop->getName() . ": " . $prop->getValue($vehicle) . "\n";
}
// Output:
// color: Gray
// brand: Ford
// model: Mustang

Error Handling: PHP provides built-in error handling mechanisms for managing exceptions when they occur. Classes can throw exceptions and catch them using try/catch blocks.

class User {
    private $name;

    public function setName($name) {
        if (!is_string($name)) {
            throw new Exception("Invalid name format.");
        }
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

try {
    $usr = new User();
    $usr->setName(123); // Not a string
} catch(Exception $e) {
    echo "Exception Caught: " . $e->getMessage();
}
// Output: Exception Caught: Invalid name format.

Important Information:

• PHP treats variables and objects differently. When assigning a variable to another variable or passing it to a function, PHP copies the variable. However, objects are treated as references, meaning both variables will point to the same instance.
• Classes can be documented using DocBlock annotations, assisting tools like IDEs in generating code documentation and improving navigation.
• Magic methods should be used judiciously to avoid obfuscating your code.
• OOP principles such as Encapsulation, Inheritance, Polymorphism, and Abstraction should be adhered to in designing your application architecture.