PHP OOP

<!-- Alright, here we are, PHP. PHP stands for Hypertext Preprocessor, it's a server-side back-end language that runs on the server, not the browser. -->
<!-- You already know it, anyways, we have some demonstration of OOP in PHP.. -->

<!-- You are able to use PHP along with HTML without a problem. Just use opening tags <?php ?> and a question mark with > to end your PHP code, if you don't end it, then the rest of your file is PHP. -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>OOP</title>
</head>
<body>

</body>
</html>

<?php
interface Vehicle { // Programming languages that support OOP and interfaces will have the same concept as this, but what is the concept?
    // We first need to talk about what is OOP, OOP stands for "Object Oriented Programming", with OOP, we can create objects using classes or metatables in LUA, each object can have properties which are like variables and methods which are like funcitons.
    // We are looking into PHP's implementation of OOP.
    public function __construct($name, $color, $speed); // We will start with interfaces. When another class implements an interface class, they will be forced to use their own concepts of methods while also using all of the implemented interface's assigned methods.
    // When we have an interface, we can't instantiate that interface as an object, but rather the other classes below that implement the interface, think of it like this:
    // A vehicle is something that is used for travelling, each vehicle has their own way of travelling, like planes, cars, etc, so each class that implements from an interface must have their own unique way of driving.
    // So what is a constructor? When I wrote __construct, it basically means what happens when we create an object, or creating a vehicle.
    public function displayInfo(); // This is one of the methods that belongs to an object, we can make it belong to a class instead (like method called "displayVehicleCount"), so making it display the vehicle count using an object doesn't make sense, we can make it static to do that.

    public function drive(); // Same thing here.
}

class Vehicle2 { // This is not an interface, this is just a normal class, it does not implement the methods and properties of an interface.
    public $name; // We define each of the properties that a class would have, like the name of the vehicle, the color and speed.
    public $color; // Make it "private" so that it can't regularly be accessible outside the class, but we can use getters and setters, although it's not necessary.
    public $speed;

    public function __construct($name, $color, $speed) { // We are allowed to make a new vehicle unlike an interface. Though I wouldn't recommend it, that's why interfaces exist.
        $this -> name = $name; // $this means the object, we can create more than 1 object, $this tells us we are accessing/setting an attribute that belongs to an object.
        $this -> color = $color; // Now you might be wondering, what is that little arrow up there? This just tells it that the "color" or any other property belongs to the object, which is $this.
        $this -> speed = $speed; // We can use the arrow for calling a function when we have an object, we will get to that soon.
    }

    public function displayInfo() { // This is a method, it is something that belongs to the object.
        echo "-- {$this -> name}'s Information --"; // echo is like printing, it outputs a string to the browser, it can also output HTML and CSS if we would like.
        echo "<br>";
        echo "Color: {$this -> color}"; // Now we are finally using $this.
        echo "<br>";
        echo "Speed: {$this -> speed}MPH";
    }

    public function drive() {
        echo "{$this -> name} is driving.";
    }
}

class Car implements Vehicle { // Here is an example of a class that implements from an interface.
    public $name;
    public $color;
    public $speed;
    static $amountOfCars = 0; // We are finally using static, it belongs to the class, not the object ($this). It makes more sense right?

    public function __construct($name, $color, $speed) { // One of the more logical reasons to use interfaces is that it forces a class that implements from it to write their own constructor.
        $this -> name = $name;
        $this -> color = $color;
        $this -> speed = $speed;

        Car::$amountOfCars += 1; // So because of this, we can increase the amount of cars, since this is a static variable, we can access it from the class, not $this, we use :: to reference to a static variable or a constant in a class. Though that won't matter for now.
    }

    public function displayInfo() { // When we implement, we must implement every function that's inside the interface that isn't static.
        echo "-- {$this -> name}'s Information --";
        echo "<br>";
        echo "Color: {$this -> color}";
        echo "<br>";
        echo "Horsepower: {$this -> speed}MPH";
    }

    public function drive() { // The example I mentioned in line 23, each vehicle drives in a different way, imagine this is a real world example.
        echo "{$this -> name} is driving at {$this -> speed}MPH.";
    }
}

class Car2 extends Vehicle2 { // We are introduced to inheritance, because we put 'extends {CLASS_NAME}'
    public $engine; // Since the parent class (the class we are inheriting from) already has the name and speed attribute defined, we can make more from here if we need to.
    // This is considered a child class since we are inheriting from a parent class, which is Vehicle2.

    public function __construct($name, $color, $speed, $engine = "V8") { // A default property of a V8 engine, doesn't V8 seem familiar?
        parent::__construct($name, $color, $speed); // We are calling the constructor of the parent class, we are giving it the required parameters.
        $this -> engine = $engine;
    }
}

$toyota = new Car("Toyota", "Red", 120); // Now this is how to make a new object, we give it the necessary parameters, like we defined in the "Vehicle" class.
echo "There are " . Car::$amountOfCars . " car(s).";
echo "<br>"; // If you don't add a "br", it will all stay on the same line.
echo $toyota -> name; // The name attribute belongs to the object, which is toyota, that's why we used the little arrow.
echo "<br>";
echo $toyota -> color;
echo "<br>";
$toyota -> drive();
echo "<br>";
$toyota -> displayInfo();
echo "<br>";
// I don't realy need to say more.
$BMW = new Car2("BMW", "Blue", 135);
echo $BMW -> name;
echo "<br>";
echo $BMW -> color;
echo "<br>";
$BMW -> drive();
echo "<br>";
$BMW -> displayInfo();

// Always use OOP, it saves time.