Web Database Applications With Php And Mysql (2nd Edition) [Electronic resources] نسخه متنی

14.3 Abstract Classes and Interfaces

When developing class hierarchies, it's often useful
to insert extra classes to help logically organize code or to provide
a base for polymorphic behavior.

14.3.1 The abstract keyword

Abstract classes are available in PHP5.

In Example 14-1, we defined a set of related classes
to describe shapes that includes a base class
Shape and its two member functions
color( ) and sides( ).
Let's suppose we want to add a function
area( ) that calculates the area of a shape. If
we want to allow the area to be calculated for all
Shape objects, then the function must be made
available in the Shape class.

However, unlike the color( ) and
sides( ) functions, the area(
) function can only be implemented in the descendant
classes because area calculations vary from shape to shape. The area
of a circle is calculated using the radius, while a rectangle uses
height and width, and so on. Using the abstract
keyword, PHP5 allows you to define member functions without having to
define an implementation. However, a class that contains an abstract
function can't be used to create objects, and must
also be defined as abstract. Example 14-2 shows how
the Shapes class is redefined to include the
abstract area( ) function.

Example 14-2. An abstract base class

<?php
abstract class Shape
{
var $color;
var $sides;
function color( ) 
{ 
return $this->color; 
}
function sides( )
{
return $this->sides;
}
abstract function area( );
function _  _construct($color, $sides)
{
$this->color = $color;
$this->sides = $sides;
}
}
class Circle extends Shape
{
var $radius;
function area( )
{
return 2 * pi( ) * $this->radius;
}
function _  _construct($color, $radius)
{
$this->radius = $radius;
parent::_  _construct($color, 1);
}
}
class Rectangle extends Shape
{
var $width;
var $height;
function area( )
{
return $this->width * $this->height;
}
function _  _construct($color, $width, $height)
{
$this->width = $width;
$this->height = $height;
parent::_  _construct($color, 4);
}
}
class Triangle extends Shape
{
// The length of each side
var $a;
var $b;
var $c;
function area( )
{
// Area using Heron's formula
$s = ($this->a + $this->b + $this->c)/2;
$area = sqrt(
$s * ($s - $this->a) * ($s - $this->b) * ($s - $this->c)
);
return $area;
}
function _  _construct($color, $a, $b, $c)
{
$this->a = $a;
$this->b = $b;
$this->c = $c;
parent::_  _construct($color, 3);
}
}
?>

Example 14-2 includes three
classesCircle,
Rectangle, and
Trianglethat extend the abstract
Shape class and provide shape specific
implementations of the abstract function area(
). (We have also removed the Polygon
class and the angles( ) function to help
simplify the example.)

The following fragment shows which classes from Example 14-2 can be used:

require 'example.14-2.php';
$t = new Triangle("yellow", 2, 3, 4);
$c = new Circle("blue", 5);
$r = new Rectangle("green", 2, 4);
print "Area of our triangle = {$t->area( )} sq units\n";
print "Area of our circle = {$c->area( )} sq units\n";
print "Area of our rectangle = {$r->area( )} sq units\n";
// The following line causes a fatal error because Shape is abstract
$s = new Shape("green", 5);

Before the fatal error caused by the attempt to create an object from
the abstract class Shape, the previous example
prints:

Area of our triangle = 2.9047375096556 sq units
Area of our circle = 31.415926535898 sq units
Area of our rectangle = 8 sq units

There are a few rules to observe when defining abstract classes and
functions:

An abstract member function can't contain a body
definition.

A class must be declared as abstract if it contains any abstract
functions.

You can declare protected and public functions as abstract, however,
it is an error to declare a private function as abstract.

Any descendant classes that don't implement an
abstract function defined in a base class must also be declared as
abstract.

14.3.2 Interfaces

Interfaces
are available in PHP5.

Interfaces provide another way of describing functionality in a class
hierarchy. An interface defines member functions
without providing any implementation, and class definitions
implement those functions. Interfaces are
defined using the interface keyword, and class
definitions use interfaces with the implements
keyword. An example is shown in Example 14-3:

Example 14-3. Using Interfaces

<?php
interface Audible
{
function sound( );
}
class Animal implements Audible
{
var $name;
var $says;
var $legs;
function sound( )
{
return $this->says;
}
function name( )
{
return $this->name;
}
function numberOfLegs( )
{
$this->legs;
}
function _  _construct($name, $says, $legs)
{
$this->name = $name;
$this->says = $says;
$this->legs = $legs;
}
}
?>

The Audible interface defined in Example 14-3 acts like an abstract base class for the
Animal class: you can't create
Audible objects directly, but an
Animal object can be used as if it were an
Audible object. Classes that specify an
interface with the implements keyword must
implement all the functions from the interface.

Interfaces are useful for implementing polymorphic behavior and are
commonly used to relate classes that otherwise would not be related.
For example, a Trumpet class
wouldn't necessarily be related to the
Animal class, however we may want to generically
process objects from both classes as Audible:

// access to the Audible interface
require "example.14-3.php";
class Trumpet implements Audible
{
function sound( )
{
return "Toot";
}
// Other functions that support a Trumpet 
// ...
function orchestraSection( )
{
return "Brass";
}
}

To further illustrate the point, we can implement the
sound( ) function for the
Triangle class we defined earlier:

// access to the Shape class
require "example.14-1.php";
// access to the Audible interface
require "example.14-3.php";
class Triangle extends Shape implements Audible
{
// The length of each side
var $a;
var $b;
var $c;
function sound( )
{
return "Ding";
}
function area( )
{
// Area using Heron's formula
$s = ($this->a + $this->b + $this->c)/2;
$area = sqrt(
$s * ($s - $this->a) * ($s - $this->b) * ($s - $this->c)
);
return $area;
}
function _  _construct($color, $a, $b, $c)
{
$this->a = $a;
$this->b = $b;
$this->c = $c;
parent::_  _construct($color, 3);
}
}

Now Animal, Trumpet, and
Triangle objects can all be treated as
Audible objects:

// Create an empty array to hold some objects
$things = array( );
// Add some objects
// An Animal is constructed with a name, sound, and leg count
$things[] = new Animal("Cow", "Moo", 4);
// A Trumpet is constructed without any parameters
$things[] = new Trumpet;
// A Triangle is constructed with a color, and the 
// length of the three sides
$things[] = new Triangle("Silver", 3, 3, 3);
// A Circle is constructed with a color and a radius
$things[] = new Circle("Blue", 5);
// Check out the sound
foreach ($things as $t)
{
if ($t instanceof Audible)
print $t->sound( );
}

Interfaces also provide a mechanism for exposing subsets of a
class's functionality. When a
Triangle is being used as an
Audible object, we only care about the
sound( ) member function. The code in the above
example would still work even if we change the names of the other
Triangle member functions: because
Triangle implements
Audible, we can be sure that a
Triangle can be used as an
Audible object.

Functions can intentionally limit how an object is used using class
type hints. Consider a function that works with
Audible objects:

// return a formatted string to represent sound
function showSound(Audible $obj)
{
return "!! {$obj->sound( )} !!";
}

The function showSound( ) can only use
$obj parameter if it's an
Audible object because the parameter is declared
as Audible. An interface acts like a contract:
classes that implement an interface are guaranteed to support a
defined set of functions, while users of an interface warrant only to
use those functions.

PHP allows multiple interfaces to be implemented in a class
definition by including a comma-separated list of interface names
after the implements keyword. This allows a class
definition to use interfaces to formally describe how it can be used
in different circumstances. We have shown how several different
classes can implement the Audible interface; we
can just as easily add other interfaces such as a
WebDisplayable interfaces that defines functions
for rendering the object as HTML. Of course, each class that
implements an interface must support the functions it
describes.