PHP Classes/Objects

Last modified on: October 20, 2024

<div class="flex-shrink-0 flex flex-col relative items-end">
<div>
<div class="pt-0">
<div class="gizmo-bot-avatar flex h-8 w-8 items-center justify-center overflow-hidden rounded-full">
<div class="relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8">&nbsp;</div>
</div>
</div>
</div>
</div>
<div class="group/conversation-turn relative flex w-full min-w-0 flex-col agent-turn">
<div class="flex-col gap-1 md:gap-3">
<div class="flex max-w-full flex-col flex-grow">
<div class="min-h-[20px] text-message flex w-full flex-col items-end gap-2 whitespace-normal break-words [.text-message+&amp;]:mt-5" dir="auto" data-message-author-role="assistant" data-message-id="d8431590-2986-408b-9566-7bb06b44165b">
<div class="flex w-full flex-col gap-1 empty:hidden first:pt-[3px]">
<div class="result-streaming markdown prose w-full break-words dark:prose-invert light">
<h3>PHP Classes and Objects</h3>
<p>In PHP, <strong>classes</strong> are blueprints for creating objects. They define the properties (variables) and methods (functions) that an object will have. <strong>Objects</strong> are instances of a class and allow you to access the class&rsquo;s properties and methods.</p>
<hr />
<h3>1. Defining a Class</h3>
<p>A class defines a template for objects and can contain properties and methods.</p>
<h4>Example: Basic Class Definition</h4>
<pre class="language-php"><code>class Car {
    // Properties
    public $brand;
    public $model;

// Constructor method (called when an object is created)
    public function __construct($brand, $model) {
        $this-&gt;brand = $brand;
        $this-&gt;model = $model;
    }

// Method to get car info
    public function getCarInfo() {
        return "This car is a " . $this-&gt;brand . " " . $this-&gt;model;
    }
}</code></pre>
<hr />
<h3>2. Creating Objects</h3>
<p>Once a class is defined, you can create objects from it using the <code>new</code> keyword.</p>
<h4>Example: Creating an Object</h4>
<pre class="language-php"><code>// Creating a new object of the Car class
$car1 = new Car("Toyota", "Corolla");
echo $car1-&gt;getCarInfo(); // Output: This car is a Toyota Corolla</code></pre>
<h3>3. Accessing Properties and Methods</h3>
<p>After creating an object, you can access its properties and methods using the arrow (<code>-&gt;</code>) operator.</p>
<h4>Example: Accessing Object Properties and Methods</h4>
<pre class="language-php"><code>$car1-&gt;brand = "Honda";  // Changing the property value
$car1-&gt;model = "Civic";  // Changing another property value
echo $car1-&gt;getCarInfo(); // Output: This car is a Honda Civic</code></pre>
<hr />
<h3>4. Constructors and Destructors</h3>
<ul>
<li><strong>Constructor</strong>: A special method that is automatically called when an object is created.</li>
<li><strong>Destructor</strong>: A special method that is automatically called when an object is destroyed.</li>
</ul>
<h4>Example: Constructor and Destructor</h4>
<pre class="language-php"><code>class Car {
    public $brand;
    public $model;

// Constructor method
    public function __construct($brand, $model) {
        $this-&gt;brand = $brand;
        $this-&gt;model = $model;
        echo "Car created: " . $this-&gt;brand . " " . $this-&gt;model . "\n";
    }

// Destructor method
    public function __destruct() {
        echo "Car object is destroyed.\n";
    }
}

$car1 = new Car("Ford", "Mustang");  // Output: Car created: Ford Mustang
// Destructor will automatically run at the end of the script.</code></pre>
<hr />
<h3>5. Object-Oriented Principles in Classes</h3>
<h4>a. <strong>Encapsulation</strong>: Bundling of properties and methods within a class and restricting direct access to them.</h4>
<ul>
<li><strong>Public</strong>: Accessible anywhere.</li>
<li><strong>Private</strong>: Accessible only within the class.</li>
<li><strong>Protected</strong>: Accessible within the class and by derived classes (inheritance).</li>
</ul>
<h4>Example: Encapsulation with Visibility Modifiers</h4>
<pre class="language-php"><code>class BankAccount {
    private $balance;

public function __construct($balance) {
        $this-&gt;balance = $balance;
    }

// Public method to get balance
    public function getBalance() {
        return $this-&gt;balance;
    }

// Public method to deposit money
    public function deposit($amount) {
        $this-&gt;balance += $amount;
    }
}

$account = new BankAccount(1000);
$account-&gt;deposit(500);
echo $account-&gt;getBalance(); // Output: 1500</code></pre>
<h4>b. <strong>Inheritance</strong>: Allows one class to inherit properties and methods from another class.</h4>
<pre class="language-php"><code>class Vehicle {
    public $type = "Car";
    
    public function start() {
        return "Starting the vehicle";
    }
}

class Car extends Vehicle {
    public $brand;

public function __construct($brand) {
        $this-&gt;brand = $brand;
    }

public function getBrand() {
        return $this-&gt;brand;
    }
}

$myCar = new Car("BMW");
echo $myCar-&gt;start();  // Output: Starting the vehicle (Inherited method)
echo $myCar-&gt;getBrand(); // Output: BMW</code></pre>
<h4>c. <strong>Polymorphism</strong>: Allows objects of different classes to be treated the same way through method overriding.</h4>
<h4>Example: Polymorphism (Method Overriding)</h4>
<pre class="language-php"><code>class Animal {
    public function makeSound() {
        return "Some sound";
    }
}

class Dog extends Animal {
    public function makeSound() {
        return "Bark";  // Overriding the method
    }
}

$dog = new Dog();
echo $dog-&gt;makeSound(); // Output: Bark</code></pre>
<hr />
<h3>6. Static Properties and Methods</h3>
<p>Static properties and methods belong to the class itself, rather than instances of the class. They can be accessed using the scope resolution operator (<code>::</code>).</p>
<h4>Example: Static Properties and Methods</h4>
<pre class="language-php"><code>class MathOperations {
    public static $pi = 3.1416;

public static function add($a, $b) {
        return $a + $b;
    }
}

// Accessing static property and method without creating an object
echo MathOperations::$pi; // Output: 3.1416
echo MathOperations::add(10, 20); // Output: 30</code></pre>
<hr />
<h3>7. Abstract Classes</h3>
<p>An abstract class cannot be instantiated directly and is meant to be extended by other classes. It can contain abstract methods, which must be implemented by the child classes.</p>
<h4>Example: Abstract Class</h4>
<pre class="language-php"><code>abstract class Shape {
    // Abstract method
    abstract public function area();
}

class Circle extends Shape {
    private $radius;

public function __construct($radius) {
        $this-&gt;radius = $radius;
    }

public function area() {
        return 3.1416 * $this-&gt;radius * $this-&gt;radius;
    }
}

$circle = new Circle(5);
echo $circle-&gt;area(); // Output: 78.54</code></pre>
<hr />
<h3>8. Complete Example: PHP Classes and Objects</h3>
<p>Here's a more complete example demonstrating the creation of objects and the use of different OOP concepts.</p>
<h4>Example: Full Script</h4>
<pre class="language-php"><code>class Person {
    public $name;
    public $age;

public function __construct($name, $age) {
        $this-&gt;name = $name;
        $this-&gt;age = $age;
    }

public function introduce() {
        return "Hi, I'm " . $this-&gt;name . " and I'm " . $this-&gt;age . " years old.";
    }
}

class Employee extends Person {
    public $jobTitle;

public function __construct($name, $age, $jobTitle) {
        parent::__construct($name, $age);
        $this-&gt;jobTitle = $jobTitle;
    }

public function introduce() {
        return parent::introduce() . " I work as a " . $this-&gt;jobTitle . ".";
    }
}

$employee = new Employee("Alice", 30, "Software Engineer");
echo $employee-&gt;introduce();  // Output: Hi, I'm Alice and I'm 30 years old. I work as a Software Engineer.</code></pre>
<hr />
<h3>&nbsp;</h3>
</div>
</div>
</div>
</div>
</div>
</div>

Web Technology View More