Understanding Classes in PHP: A Comprehensive Guide for Beginners

What is class?

In PHP, a class is a blueprint for creating objects, which are instances of that class. It defines a set of properties (variables) and methods (functions) that the objects created from the class can have. Classes are a fundamental concept in object-oriented programming (OOP), where the goal is to model real-world entities as objects.

Key Concepts of a Class in PHP

Properties: These are variables defined inside the class, representing the characteristics of the class. They hold the data or state for objects created from the class.

Methods: These are functions defined inside the class that describe the behaviors or actions an object can perform.

Object: An instance of a class. Once a class is defined, you can create an object from that class using the new keyword.

Visibility Modifiers:

• public: Can be accessed from anywhere, inside or outside the class.
• private: Can only be accessed from within the class itself.
• protected: Can be accessed within the class and by classes derived from it (subclasses).

Constructor: A special method that is automatically called when an object is instantiated. It is often used to initialize properties.

Destructor: A special method that is automatically called when an object is destroyed or goes out of scope.

Inheritance: A class can inherit properties and methods from another class. The class that inherits is called a child (or subclass), and the class that is inherited from is called a parent (or superclass).

Static Properties/Methods: Static properties and methods belong to the class itself rather than to any specific object created from the class. They are accessed using the self:: or ClassName:: syntax.

Class Syntax in PHP

<?php
class Car {
    // Properties
    public $brand;
    public $model;
    private $year;

    // Constructor
    public function __construct($brand, $model, $year) {
        $this->brand = $brand;
        $this->model = $model;
        $this->year = $year;
    }

    // Methods
    public function startEngine() {
        return "The engine of " . $this->brand . " " . $this->model . " is started.";
    }

    // Getter for private property
    public function getYear() {
        return $this->year;
    }

    // Setter for private property
    public function setYear($year) {
        $this->year = $year;
    }
}

// Creating an object (an instance of the class)
$car1 = new Car("Toyota", "Corolla", 2022);

// Accessing methods
echo $car1->startEngine();  // Output: The engine of Toyota Corolla is started.

// Accessing public property
echo $car1->brand;  // Output: Toyota

// Accessing private property using a getter method
echo $car1->getYear();  // Output: 2022

// Setting private property using a setter method
$car1->setYear(2023);
echo $car1->getYear();  // Output: 2023
?>

Explanation of Code:

Class Declaration:

• The class Car is declared using the class keyword.
• It has three properties: $brand, $model, and $year. $brand and $model are public, meaning they can be accessed from outside the class, while $year is private.

Constructor:

• The __construct() method is a special method that gets executed whenever a new object is created from the class. It takes parameters to initialize the object's properties.

Method Declaration:

• startEngine() is a public method that returns a string indicating the engine has started.
• getYear() and setYear() methods are used to access and modify the private property $year. 

Creating Objects:

• $car1 is an instance of the Car class. The constructor initializes the brand, model, and year properties.

Accessing Properties/Methods:

• You can access public properties directly, but for private properties, you need getter and setter methods.
• Methods like startEngine() are called on the object using the -> operator.
  
  

Inheritance Example

<?php
class Vehicle {
    public $fuel;

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

    public function refuel() {
        return "Refueling with " . $this->fuel;
    }
}

// Car inherits from Vehicle
class Car extends Vehicle {
    public $brand;
    public $model;

    public function __construct($brand, $model, $fuel) {
        parent::__construct($fuel);  // Call parent constructor
        $this->brand = $brand;
        $this->model = $model;
    }

    public function startEngine() {
        return "Starting the engine of " . $this->brand . " " . $this->model;
    }
}

// Creating an object of the subclass
$car2 = new Car("Honda", "Civic", "Gasoline");
echo $car2->startEngine();  // Output: Starting the engine of Honda Civic
echo $car2->refuel();       // Output: Refueling with Gasoline
?>

Explanation:

• Inheritance: The Car class extends the Vehicle class, inheriting its properties and methods.
• parent::__construct(): The constructor of the parent class is called using parent::__construct($fuel) to ensure the inherited fuel property is initialized.
  
  

Key OOP Concepts Related to Classes:

Encapsulation: Bundling data (properties) and methods that operate on the data into a single unit (class), restricting direct access to some components using private/protected visibility.

Abstraction: Hiding complex implementation details and exposing only the necessary aspects of an object.

Polymorphism: The ability to use a method in different ways, often seen with method overriding in inherited classes.

Inheritance: A mechanism where one class (child) inherits the properties and methods of another class (parent).

Static Properties and Methods

<?php
class Calculator {
    public static $pi = 3.14159;

    public static function square($number) {
        return $number * $number;
    }
}

// Accessing static property and method without creating an object
echo Calculator::$pi;  // Output: 3.14159
echo Calculator::square(5);  // Output: 25
?>

In the example above, Calculator::$pi and Calculator::square() are accessed directly from the class without creating an object. This is possible because they are declared as static.

Conclusion

A class in PHP allows you to define properties and methods that model real-world objects. By using classes, you can create reusable and organized code that follows the principles of object-oriented programming, making your application easier to maintain and scale.

Thank You!