Exploring Classes in PHP: Properties, Methods, and Constructors

Introduction: Building Blocks of Objects – Properties, Methods, and Constructors in PHP Classes

Exploring Classes in PHP: Properties, Methods, and Constructors : In our previous blog post, we introduced the fundamental concepts of Object-Oriented Programming (OOP) in PHP, highlighting the importance of classes and objects. Now, let’s dive deeper into the anatomy of a PHP class, focusing on its core components: properties (attributes), methods (behaviors), and constructors (special initialization methods). Understanding these elements is crucial for effectively designing and implementing object-oriented solutions in PHP.

Properties (Attributes): Defining the State of Objects

Properties, also known as attributes or members, are variables that are declared within a class. They represent the data or state of an object that is created from that class. Each object of a class will have its own set of these properties, which can hold different values.  

Declaring Properties:

You declare properties within a class using the public, private, or protected keywords, followed by the $ symbol and the property name. You can optionally assign a default value to a property during its declaration.

class Car {
    public $make;
    public $model;
    public $color = 'white'; // Default value
    private $engineStarted = false;
    protected $fuelLevel;
}

In this Car class example, we have five properties: $make, $model, $color, $engineStarted, and $fuelLevel. The keywords public, private, and protected are access modifiers that control the visibility and accessibility of the property from different parts of the code.

Access Modifiers:

  • public: Public properties can be accessed from anywhere – inside the class, outside the class, and by child classes (in case of inheritance).  
  • private: Private properties can only be accessed from within the class where they are declared. They are not accessible from outside the class or by child classes.  
  • protected: Protected properties can be accessed from within the class where they are declared and by its child classes (in case of inheritance). They are not accessible from outside the class directly.  
Working with Properties:

You access the properties of an object using the object operator -> followed by the property name.

$myCar = new Car();
$myCar->make = 'Toyota'; // Accessing a public property and setting its value
$myCar->model = 'Camry';
echo $myCar->color;      // Accessing a public property's value (output: white)

// Trying to access a private or protected property from outside the class will result in an error.
// echo $myCar->engineStarted; // This would cause a fatal error
// echo $myCar->fuelLevel;   // This would also cause a fatal error
Methods (Behaviors): Defining the Actions of Objects

Methods are functions that are defined within a class. They represent the behaviors or actions that an object of that class can perform. Methods can operate on the object’s properties and can also interact with other objects or parts of the program.  

Declaring Methods:

You declare methods within a class using the public, private, or protected keywords (for access modifiers), followed by the function keyword, the method name, a pair of parentheses () for parameters (if any), and a block of code enclosed in curly braces {}.

class Car {
    // ... (properties from before) ...

    public function startEngine() {
        $this->engineStarted = true;
        return "Engine started.";
    }

    public function stopEngine() {
        $this->engineStarted = false;
        return "Engine stopped.";
    }

    private function isEngineRunning() {
        return $this->engineStarted;
    }

    protected function setFuelLevel($level) {
        $this->fuelLevel = $level;
    }

    public function checkEngineStatus() {
        if ($this->isEngineRunning()) {
            return "Engine is running.";
        } else {
            return "Engine is off.";
        }
    }
}

In this updated Car class, we have several methods: startEngine(), stopEngine(), isEngineRunning(), setFuelLevel(), and checkEngineStatus(). Notice the access modifiers used for each method, controlling their accessibility similar to properties.

Calling Methods:

You call the methods of an object using the object operator -> followed by the method name and parentheses ().

$myCar = new Car();
echo $myCar->startEngine();      // Output: Engine started.
// $myCar->isEngineRunning();   // This would cause a fatal error as it's a private method
// $myCar->setFuelLevel(50);     // This would cause a fatal error as it's a protected method
echo $myCar->checkEngineStatus(); // Output: Engine is running.
echo $myCar->stopEngine();       // Output: Engine stopped.
echo $myCar->checkEngineStatus(); // Output: Engine is off.

The $this Keyword:

As seen in the method examples, the $this keyword is used within a method to refer to the instance of the class that the method is being called on. It allows you to access the object’s properties and call other methods of the same object.

Constructors: Initializing Objects

A constructor is a special method within a class that is automatically called when a new object of that class is created. Its primary purpose is to initialize the object’s properties or perform any other setup that is needed when an object is instantiated.  

Defining Constructors:

In PHP, you define a constructor method using a special name: __construct().

class Car {
    public $make;
    public $model;
    public $color;
    private $engineStarted = false;
    protected $fuelLevel;

    public function __construct($make, $model, $color = 'white', $initialFuel = 0) {
        $this->make = $make;
        $this->model = $model;
        $this->color = $color;
        $this->fuelLevel = $initialFuel;
    }

    // ... (other methods from before) ...
}

In this example, the __construct() method takes four parameters: $make, $model, $color (with a default value of ‘white’), and $initialFuel (with a default value of 0). When a new Car object is created, these values can be passed as arguments to the constructor, which then uses them to initialize the object’s properties.

Using Constructors:

When you create a new object of a class that has a constructor, you provide the initial values for the properties as arguments to the constructor.  

$mySportsCar = new Car("Porsche", "911", "Red", 30);
$myFamilyCar = new Car("Honda", "Civic"); // Uses default color and fuel level

echo $mySportsCar->make;    // Output: Porsche
echo $myFamilyCar->color;  // Output: white (default value)

Constructors are a powerful tool for ensuring that your objects are properly initialized with the necessary data when they are created.

Conclusion: The Core of PHP Classes

Properties, methods, and constructors form the fundamental building blocks of classes in PHP. Properties define the data that objects hold, methods define the actions that objects can perform, and constructors ensure that objects are properly set up when they are created. By understanding and effectively using these components, you can create well-structured and robust object-oriented PHP applications. In our next blog post, we will continue our exploration of OOP in PHP by looking at the concepts of inheritance and how it promotes code reusability. Stay tuned for more in our “PHP A to Z” series! Sources and related content

Related Posts

Scroll to Top