The Point of Interfaces

kebbelj

I'm working my way through a Design Patterns manual, and I got stuck at the definition of "interface." I read half a dozen descriptions of interfaces on the web and PHP books I have at home. I grasp what interfaces are, and how they differ from abstract classes, but for the life of me, I cannot figure out why you would use interfaces.

What's the point of listing a bunch of function signatures with no code to implement? If you're going to write the implementation code inside a class anyway, why bother listing it in the interface? (Especially if listing it in the interface is going to give you fatal errors until you implement it in the class?)
If anyone can point me towards a source that explains WHY you would use interfaces, I would greatly appreciate it. Thanks.

Kudose

Function prototypes and requirements.

kebbelj

But why bother? The prototypes aren't required; you can create and run the methods in the classes without the prototypes. I could see the point if there were code you were sharing between unrelated classes--sort of a secondary, lateral inheritance instead of vertical inheritance--but creating shared prototypes that will crash the program if they're not implemented? I'm just not getting it. Sorry. (Evidently, they ARE important for something because the author of http://www.developer.com/java/other/article.php/1015511 says "[T]here is little if anything useful that can be done in Java without understanding and using interfaces.")

laserlight

I'm working my way through a Design Patterns manual, and I got stuck at the definition of "interface." I read half a dozen descriptions of interfaces on the web and PHP books I have at home. I grasp what interfaces are, and how they differ from abstract classes, but for the life of me, I cannot figure out why you would use interfaces.

No, when you read about "interfaces", do not only think of interface constructs. An interface is some non-private (and some say "published") set of declarations, typically functions, that a user of the interface can rely on.

So, a concrete class defines an interface consisting of its public members. A user of that class can use those public members and be certain that even if the implementation changes, those members will still be there. The class defines an interface for its derived classes consisting of its public members and protected members. The derived classes can use those protected members and be certain that even if the implementation changes, those members will still be there.

Now, an interface construct is used to specify a pure interface: effectively a class that has no implementation. An abstract base class typically has some implementation, but some parts of the class is left to derived classes to implement.

Note that a library of functions, with no classes involved, also specifies an interface: one that consists of those functions that are declared to be the interface of that library.

But why bother? The prototypes aren't required; you can create and run the methods in the classes without the prototypes.

The idea is to program to an interface, not an implementation.

NogDog

One effect of the interface construct is to allow type-hinting which will allow a number of different objects to be passed as arguments to a method, while guaranteeing that only objects which implement that interface are allowed. So if I have an interface named "Example" and two classes named "Foo" and "Bar" which implement that interface and a third class named "NoGo" which does not, then...

class Sample
{
   private $obj;
   public function __construct(Example $obj)
   {
      $this->obj = $obj;
   }
}

$test1 = new Sample(new Foo());  // OK
$test2 = new Sample(new Bar());  // OK
$test3 = new Sample(new NoGo()); // throws error since NoGo is not an "Example"

The Sample class can then know that any object passed as the argument to its constructor is guaranteed to implement all the methods of the Example interface.

kebbelj

If I'm reading you right ...

INTERFACE (Construct)

interface is a keyword in the programming language
Similar to an abstract class
Contains constants and method protoypes
Classes that implement an interface must implement all the interface functions (or their sub-classes must)
Adding a new method to an interface will instaneously break all client classes because they do not yet contain the mehtod implementation (since there is no record of which classes use the interface, adding a method could be disastrous

INTERFACE (Published Declaration)

An interface is a contract about what is in a program and how--at the most generic level--the program will work
Methods and classes are mentioned, but at sort of a black box level. Classes and their methods can be significantly altered--both as far as algorithms within a language or even the programming language itself--as long as their prototypes remain constant. (Function calls will send and recieve the expected information)

NogDog

I believe you are on the right track, except that an interface (construct) only contains method prototypes.

To date in my still relative n00bness as far as OOP goes, I have not yet run into a situation where I've used the interface keyword, so I suspect it's more likely to be used in larger applications than I've dealt with so far -- or perhaps they're not so common when you develop with abstract classes and composition?

laserlight

I believe you are on the right track, except that an interface (construct) only contains method prototypes.

Yeah, PHP differs from Java in that respect, probably because there is no equivalent to static const/final data members.

or perhaps they're not so common when you develop with abstract classes and composition?

In Java, interfaces can be used to specify the data member type. The data member is then instantiated with a concrete type, so if you do need to change what exactly is the type of the data member, you can just instantiate another type that implements the same interface. Also, since you only expose the interface type for return values and such, this means flexibility.

But PHP is dynamically typed, so this kind of options do not make that much sense unless there is more type hinting with return values and member variables.