Question

So I have understood how interfaces and abstraction work in PHP, I just don’t see the point for example, of having a interface if it just sets a guide and requires implemented objects to have certain methods. Especially since the interface is not even getting instantiated.

This also goes with abstraction, I just can’t apply it to my code and see it as such a great thing. When I am trying to create objects on a bigger scale to interact with each other in order to figure out interfaces, each class ends up passing information back and forth, but never is the interface touched.

So what I’m asking is if you guys have any advice or links to outside sources that is good at explaining this kind of thing.

Answer 1

Here’s one simple example. Creating interfaces and abstract classes allows you to ensure an object adhears to a common API. See the example below.

interface iCar
{
    function drive();
}

abstract class Car implements iCar
{
    public $make = 'Generic';

    public function drive()
    {
        printf("I'm driving in my %s%s", $this->make, PHP_EOL);
    }
}

class FordTruck extends Car
{
    public $make = "Ford";
}

class Porsche extends Car
{
    public $make = 'Porsche';
    public function drive()
    {
        printf("I'm speeding around in my %s%s", $this->make, PHP_EOL);
    }
}

class Yugo extends Car
{
    public $make = 'Yugo';

    public function drive()
    {
        printf("I'm pushing my %s around town%s", $this->make, PHP_EOL);
    }
}

function drive(iCar $car)
{
    $car->drive();
}

$car1 = new FordTruck;
$car2 = new Porsche;
$car3 = new Yugo;


drive($car1);
drive($car2);
drive($car3);

Even if you don’t specify the type of input parameter on the drive() function, you can check if the input is an instanceof an iCar

function drive($car)
{
    if ($car instanceof iCar)
        $car->drive();
}

Another example would be building a caching interface in your application. You can specify that all cache engines support the same methods for reading/writing/invalidating objects in the cache without knowing (or caring) about the actual implementation of a particular cache engine.