Interfaces: You are doing them wrong.

Jan 16: Interfaces: You are doing them wrong.

Normally I don't do any sort of Introduction to Object Oriented Programming posts because to be honest, it's been a long time since I read chapter one and thinking in objects comes naturally to me. Today I happened across the Interfaces section of the PHP manual; the examples and comments on that page were so brutal I thought maybe I should do a public service and write something about how to create a clear object model using a couple of rules of thumb.

In my opinion, one of the most misunderstood OOP mechanisms in the PHP world is the Interface. Unfortunately, the manual seems to support my opinion. In the first example we have the class Template implementing the interface iTemplate. What is an iTemplate? The rest of the examples are even worse: class a implements b. No wonder developers struggle with interfaces when the people that literally wrote the book for them don't seem to get it. Even worse are the comments though, class Rain extends Weather and implements Water? What? Maybe if they mean water as in the sense of watering your lawn. Even so, there has got to be a better name for it than that. The way that interfaces are done in the Zend Framework offers a real-world example of bad interface design. Take a look at the following sentence and let's see if you can make sense of what the involved components are:

Zend_Validate_Date is a Zend_Validate_Abstract and can Zend_Validate_Interface

Now to be completely fair, these class names do get ugly as a result of having to bear the weight of pseudo-namespacing, but if your interface is actually called "Interface" you know you have a problem. Let's look at it again but this time we will be using PHP 5.3+ (which you should be using because it's awesome) and Zend Framework 2.0 - which may have namespace support:

Date is an Abstract and can Interface

This does not describe what type of an object the Date is. Is it a calendar date? Is it a fruit that can be dried and old people drink to help them go #2 more regularly? Or maybe it is a meeting involving two or more people in order to determine if their physical proximity elicits a chemical response. Who knows? And don't even get me started on "can Interface"! Maybe that's what happens if there is chemistry between the people on the Date? Now if you are an experienced OOP developer, you will know that Abstract is the home of some common functionality that all child classes share and that the Interface defines the contract that any objects implementing it must fulfill. But it doesn't tell you anything about what type of functionality is common to the children of the abstract or what types of behavior must be implemented by objects implementing the interface.

Designing objects can be fairly easy for the most part if you take the stance that your objects are nouns and your interfaces are adjectives. Until you get better at it, try to add the suffix "able" to indicate that objects implementing it are capable of doing something. Try this version of the Zend Framework validation action:

Date is a Validator and is Validatable

You won't always be able to use the "able" rule of thumb, but going through the process of trying to think of one will help you arrive at a better object model. Take a look at a few more examples:

A Circle is a Shape and is Drawable
A TeddyBear is a Toy and is Huggable
A CardDeck is an ArrayObject and is both Countable and Sortable

So hopefully these examples help give you an idea how easy it is to create good code. As always when it comes to designing objects, your best tool is simply reading the objects out loud. The better your design, the less like Yoda you will sound. Of course I couldn't leave this post without throwing down some code, and since I was most appalled by the Weather examples in the manual comments I thought I would do my own weather example. The real key here is to note that not only do weather conditions such as the amount of clouds and the UV index rating affect what the actual temperature feels like, so can what you wear. In other words, weather can use objects of completely different types to do work because it knows that those objects are capable of doing a particular thing.

/**
 * Represents a temperature in degrees Celsius
 */
class Temperature
{
    protected $degrees;

public function __construct($degrees)
    {
        if (!is_numeric($degrees)) {
            throw new InvalidArgumentException('Temperature must be numeric');
        }

$this->degrees = $degrees;
    }

public function decreaseByPercentage($percentage)
    {
        if (!is_numeric($percentage)) {
            throw new InvalidArgumentException('Percentage to decrease must be numeric');
        }

$amount = $this->degrees * ($percentage / 100);

return new Temperature($this->degrees - $amount);
    }

public function increaseByPercentage($percentage)
    {
        if (!is_numeric($percentage)) {
            throw new InvalidArgumentException('Percentage to increase must be numeric');
        }

$amount = $this->degrees * ($percentage / 100);

return new Temperature($this->degrees + $amount);
    }

public function getDegrees()
    {
        return $this->degrees;
    }

public function __toString()
    {
        return (string) number_format($this->getDegrees(), 1) . ' degrees Celsius';
    }
}

/**
 * A decorator for Temperature to convert it to Fahrenheit
 */
class Fahrenheit
{
    protected $temperature;

public function __construct(Temperature $temperature)
    {
        $this->temperature = $temperature;
    }

protected function convertFromCelsius($degreesCelsius)
    {
        $degreesFahrenheit = ($degreesCelsius * (9/5)) + 32;

return $degreesFahrenheit;
    }

public function getDegrees()
    {
        $degrees = $this->temperature->getDegrees();

return $this->convertFromCelsius($degrees);
    }

public function __toString()
    {
        return (string) number_format($this->getDegrees(), 1) . ' degrees Fahrenheit';
    }
}

/**
 * Something that can affect a temperature
 */
interface TemperatureAffectable
{
    public function affectTemperature(Temperature $startingTemperature);
}

/**
 * Represents the sum of all weather conditions and effects
 */
class Weather extends ArrayObject
{
    protected $name;
    protected $temperature;
    protected $feelsLike;

public function __construct($name, Temperature $temperature)
    {
        $this->name = $name;
        $this->temperature = $temperature;
    }

public function addEffect(TemperatureAffectable $effect)
    {
        $this->append($effect);

// blow away the feels like cached value
        $this->feelsLike = null;

return $this;
    }

public function feelsLike()
    {
        if (is_null($this->feelsLike)) {
            $this->feelsLike = clone $this->temperature;

foreach ($this->getIterator() as $effect) {
                $this->feelsLike = $effect->affectTemperature($this->feelsLike);
            }
        }

return $this->feelsLike;
    }

public function __toString()
    {
        $string = "A {$this->name} ";

$effects = array();
        foreach ($this->getIterator() as $effect) {
            $effects[] = (string) $effect;
        }

$lastEffect = array_pop($effects);

$string .= implode(', ', $effects);
        $string .= " and $lastEffect ";

$string .= " feels like {$this->feelsLike()} ";
        $string .= " (" . (string) new Fahrenheit($this->feelsLike()) . ")\n";

return $string;
    }
}

/**
 * Represents a generic amount of clouds in the sky
 */
class CloudLevel implements TemperatureAffectable
{
    protected $temperatureAdjustment = 0;
    protected $stringTemplate = "with %s clouds";
    protected $description = "some";

public function affectTemperature(Temperature $startingTemperature)
    {
        return $startingTemperature->decreaseByPercentage($this->temperatureAdjustment);
    }

public function __toString()
    {
        return sprintf($this->stringTemplate, $this->description);
    }
}

/**
 * 100% cloud coverage
 *
 * Tends to make the temperature feel much cooler than it is
 */
class VeryCloudy extends CloudLevel
{
    protected $temperatureAdjustment = 25;
    protected $description = "many";
}

/**
 * Very few clouds in the sky
 *
 * Provides occasional shade which can make the temperature feel a little cooler
 */
class SparseClouds extends CloudLevel
{
    protected $temperatureAdjustment = 5;
    protected $description = "few";
}

/**
 * Not a cloud in the sky
 *
 * Actually makes the temperature feel a little warmer than it is
 */
class NoClouds extends CloudLevel
{
    protected $temperatureAdjustment = 5;
    protected $description = "no";

/**
     * Having no clouds increases temperature
     */
    public function affectTemperature(Temperature $startingTemperature)
    {
        return $startingTemperature->increaseByPercentage($this->temperatureAdjustment);
    }
}

/**
 * Represents a generic UV Index reading
 */
class UvIndex implements TemperatureAffectable
{
    protected $stringTemplate = "with a %s UV index";
    protected $description = "missing";

public function affectTemperature(Temperature $startingTemperature)
    {
        return $startingTemperature->increaseByPercentage($this->temperatureAdjustment);
    }

public function __toString()
    {
        return sprintf($this->stringTemplate, $this->description);
    }
}

/**
 * High index reading
 *
 * Makes the temperature feel much warmer than is really is. Anyone have some butter?
 */
class HighUvIndex extends UvIndex
{
    protected $temperatureAdjustment = 25;
    protected $description = 'high';
}

/**
 * Very low index reading
 *
 * Makes little difference to how the temperature feels
 */
class LowUvIndex extends UvIndex
{
    protected $temperatureAdjustment = 0;
    protected $description = 'low';
}

/**
 * Represents a generic article of clothing
 */
class Clothing implements TemperatureAffectable
{
    protected $stringTemplate = "wearing a %s";
    protected $description = "clothing article";

public function affectTemperature(Temperature $startingTemperature)
    {
        return $startingTemperature->increaseByPercentage($this->temperatureAdjustment);
    }

public function __toString()
    {
        return sprintf($this->stringTemplate, $this->description);
    }
}

/**
 * A sweater
 *
 * Makes the temperature feel much warmer than is really is.
 */
class Sweater extends Clothing
{
    protected $temperatureAdjustment = 25;
    protected $description = 'sweater';
}

/**
 * T-Shirt
 *
 * Doesn't change how warm it feels very much
 */
class TShirt extends Clothing
{
    protected $temperatureAdjustment = 5;
    protected $description = 't-shirt';
}

// Take the objects for a spin

$warmDay = new Weather('warm day', new Temperature(25));
$warmDay->addEffect(new NoClouds)
        ->addEffect(new HighUvIndex);

echo "$warmDay<br/>";
// A warm day with no clouds and with a high UV index feels like 32.8 degrees Celsius (91.1 degrees Fahrenheit)

$coolDay = new Weather('cool day', new Temperature(25));
$coolDay->addEffect(new VeryCloudy)
        ->addEffect(new LowUvIndex);

echo "$coolDay<br/>";

// A cool day with many clouds and with a low UV index feels like 18.8 degrees Celsius (65.8 degrees Fahrenheit)

$coolDayWithSweater = new Weather('cool day', new Temperature(25));
$coolDayWithSweater->addEffect(new VeryCloudy)
                   ->addEffect(new LowUvIndex)
                   ->addEffect(new Sweater);

echo "$coolDayWithSweater<br/>";

// A cool day with many clouds, with a low UV index and wearing a sweater feels like 23.4 degrees Celsius (74.2 degrees Fahrenheit)

Don't hate me because it's beautiful

Posted by Matthew Purdon in PHP Comment: (1) Trackbacks: (0)

Trackbacks

Trackback specific URI for this entry

No Trackbacks

Comments

Display comments as (Linear | Threaded)

#1 - Brian DeShong said:
2010-01-17 07:06 - (Reply)

Great post! So true on the poorly-named interfaces and classes, too. And yes, the less you sound like Yoda, the better your design is!

Many years ago, I read "The Object-Oriented Thought Process," which is a great book with well-named, practical examples that anyone can relate to (i.e. class "Ford" implements "Car"). I'd highly recommend it to anyone starting out in OOP design. It's also a great book to re-read every year or two.

http://www.amazon.com/Object-Oriented-Thought-Process-3rd/dp/0672330164/ref=sr_1_1?ie=UTF8&s=books&qid=1263740608&sr=8-1

Add Comment

Name
Email
Homepage
In reply to
Comment	Standard emoticons like :-) and ;-) are converted to images.
	Remember Information? Subscribe to this entry

Interfaces: You are doing them wrong.

Code Naked

Jan 16: Interfaces: You are doing them wrong.

Subscribe

Archives

Categories

Blog Administration

Recommended Reading

Feedburner