Abstract

Abstract Classes focus on a kind of things similarity.

People are considered of type mammal and as such would not be considered of type vehicle.

Interface

Interfaces focus on collation of similar function.

For example: You are a human being and are of type mammal. If you want to fly then you will need to implement a flying Interface. If you want to shoot while flying, then you also need to implement the gun Interface.

See the examples below:

abstract class Mammal { protected $age_; //below are functions I think all mammals will have,including people abstract public function setAge($age); abstract public function getAge(); abstract public function eat($food); } class Person extends Mammal { protected $job_; //Person's feature public function setAge($age){ $this->age_ = $age; } public function getAge(){ return $this->age_; } public function eat($food){ echo 'I eat ' ,$food ,'today'; } //People only attribute public function setJob($job){ $this->job_ = $job; } public function getJob(){ echo 'My job is ' , $this->job_; } } //Now a person wants to fly, but they are typically not able to do so. //So we implement an interface interface Plane{ public function Fly(); } //I also want shoot enemy interface Gun{ public function shoot(); } class Person2 extends Mammal implements Plane,Gun{ protected $job_;//Person feature public function setAge($age){ $this->age_ = $age; } public function getAge(){ return $this->age_; } public function eat($food){ echo '<br/>I eat ' ,$food ,' today<br/>'; } //Only a person has this feature. public function setJob($job){ $this->job_ = $job; } public function getJob(){ echo 'My job is ' , $this->job_; } //----------------------------------------- //below implementations from interfaces function. (features that humans do not have). //Person implements from other class public function fly(){ echo '<br/>I use plane,so I can fly<br/>'; } public function shoot(){ echo 'I use gun,so I can shoot<br/>'; } } $People = new Person(); echo '<pre>'; print_r( get_class_methods('People')); echo '</pre>'; echo '<pre>'; print_r( get_class_methods('People2')); echo '</pre>'; $People2 = new Person2(); $People2->setAge(24); echo $People2->getAge(); $People2->eat('egg'); $People2->setJob('PHP devepop'); echo $People2->getJob(); $People2->fly(); $People2->shoot(); 

Briefly speaking, interface is to standardize a set of functions，while abstract class is to define a basic skeleton for classes to derive from.

I have thought about this before, and the best I could conclude was that interfaces are a logically convenient abstraction of a pure abstract class (c++).

As for why you would choose interfaces over abstract classes, I quote (a c++ source but the concepts are the same):

Note that there is a great temptation to add concrete member functions and data to pure abstract base classes. This must be resisted, in general it is a sign that the interface is not well factored. Data and concrete member functions tend to imply a particular implementation and as such can inherit from the interface but should not be that interface. Instead if there is some commonality between concrete classes, creation of abstract class which inherits its interface from the pure abstract class and defines the common data and member functions of the concrete classes works well.

The thing is, when using interfaces, the first thing that comes to mind is decoupling. When using an interface, the user and the implementing-class are totally decoupled. The same applies for when you're using a pure abstract class which is basically an interface.