PHP OOps

Object-Oriented Programming (OOP) in PHP allows you to create modular, reusable code through the use of objects and classes. Below are the core concepts of OOP in PHP with examples:

1. Classes and Objects
2. Properties and Methods
3. Constructors and Destructors
4. Inheritance
5. Access Modifiers
6. Static Methods and Properties
7. Interfaces
8. Abstract Classes

1. Classes and Objects

A class is a blueprint for creating objects. An object is an instance of a class.

<?php
class Car {
    // Properties
    public $color;
    public $model;
    
    // Methods
    public function __construct($color, $model) {
        $this->color = $color;
        $this->model = $model;
    }

    public function message() {
        return "My car is a " . $this->color . " " . $this->model . ".";
    }
}

$myCar = new Car("red", "Toyota");
echo $myCar->message();
?>

Output:

My car is a red Toyota.

2. Properties and Methods

Properties are variables within a class, and methods are functions within a class.

<?php
class Person {
    public $name;
    public $age;

    public function setName($name) {
        $this->name = $name;
    }

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

$person = new Person();
$person->setName("John");
echo $person->getName();
?>

Output:

John

3. Constructors and Destructors

Constructors are special methods that are called when an object is instantiated. Destructors are called when the object is destroyed.

<?php
class Animal {
    public function __construct() {
        echo "An animal has been created.<br>";
    }

    public function __destruct() {
        echo "An animal has been destroyed.<br>";
    }
}

$animal = new Animal();
?>

Output:

An animal has been created.
An animal has been destroyed.

4. Inheritance

Inheritance allows a class to inherit the properties and methods of another class.

<?php
class ParentClass {
    public function parentMethod() {
        echo "This is a method from the parent class.<br>";
    }
}

class ChildClass extends ParentClass {
    public function childMethod() {
        echo "This is a method from the child class.<br>";
    }
}

$child = new ChildClass();
$child->parentMethod();
$child->childMethod();
?>

Output:

This is a method from the parent class.
This is a method from the child class.

5. Access Modifiers

Access modifiers define the visibility of properties and methods. PHP has three access modifiers: public, protected, and private.

<?php
class Test {
    public $publicProperty = "Public";
    protected $protectedProperty = "Protected";
    private $privateProperty = "Private";

    public function publicMethod() {
        echo $this->publicProperty . "<br>";
        echo $this->protectedProperty . "<br>";
        echo $this->privateProperty . "<br>";
    }
}

$test = new Test();
echo $test->publicProperty . "<br>"; // Works
// echo $test->protectedProperty; // Error
// echo $test->privateProperty; // Error
$test->publicMethod();
?>

Output:

Public
Public
Protected
Private

6. Static Methods and Properties

Static methods and properties belong to the class itself rather than any object.

<?php
class StaticExample {
    public static $staticProperty = "I'm static";

    public static function staticMethod() {
        return "I'm a static method";
    }
}

echo StaticExample::$staticProperty . "<br>";
echo StaticExample::staticMethod();
?>

Output:

I'm static
I'm a static method

7. Interfaces

Interfaces allow you to define methods that must be implemented in any class that implements the interface.

<?php
interface AnimalInterface {
    public function makeSound();
}

class Dog implements AnimalInterface {
    public function makeSound() {
        echo "Woof!<br>";
    }
}

class Cat implements AnimalInterface {
    public function makeSound() {
        echo "Meow!<br>";
    }
}

$dog = new Dog();
$dog->makeSound();

$cat = new Cat();
$cat->makeSound();
?>

Output:

Woof!
Meow!

8. Abstract Classes

Abstract classes cannot be instantiated and are meant to be extended by other classes. They can have abstract methods that must be implemented in the child classes.

<?php
abstract class Vehicle {
    abstract public function startEngine();

    public function describe() {
        echo "This is a vehicle.<br>";
    }
}

class Car extends Vehicle {
    public function startEngine() {
        echo "Starting car engine.<br>";
    }
}

$car = new Car();
$car->describe();
$car->startEngine();
?>

Output:

This is a vehicle.
Starting car engine.

These are the fundamental concepts of PHP's object-oriented programming. Using these, you can create well-structured, modular, and reusable code.