Let's suppose we have a class called
User. Users have an Address that our application mails packages to via a PackageShipper:class Address {
// ... setters and getters for address fields ...
}
class User {
protected $address;
public function setAddress(Address $address) {
$this->address = $address;
}
public function getAddress() {
return $this->address;
}
// ... other user logic ...
}
class PackageShipper {
public function shipTo(User $user) {
$address = $user->getAddress();
// ... do shipping code using $address ...
}
}
Our application is happily shipping packages, until one day a new requirement comes in that we need to be able to ship packages to Companies as well. We create a new
Company class to handle this:class Company {
protected $address;
public function setAddress(Address $address) {
$this->address = $address;
}
public function getAddress() {
return $this->address;
}
// ... other company logic ...
}
Now we have a problem. The PackageShipper class only knows how to handle Users. What we need is for the PackageShipper class to handle anything that has an Address.
We could make a base class that both Users and Companies inherit from and have the PackageShipper accept any class that descends from the base class. This is an unsatisfying solution. Semantically, Users and Companies are different entities, and there may not be enough common functionalty to move to a base class that both inherit. They may not have much in common besides the fact that they both have an address. Also, either class may already extend another class, and we cannot extend more than one class since PHP has a single-inheritance object model.
Instead, we can use an interface to define the common parts of Users and Companies that PackageShipper needs to deal with. Then, Users and Companies can implement that interface, and PackageShipper only has to deal with objects that implement the interface.
inteface Addressable {
public function setAddress(Address $address);
public function getAddress();
}
class User implements Addressable {
protected $address;
public function setAddress(Address $address) {
$this->address = $address;
}
public function getAddress() {
return $this->address;
}
// ... other user logic ...
}
class Company implements Addressable {
protected $address;
public function setAddress(Address $address) {
$this->address = $address;
}
public function getAddress() {
return $this->address;
}
// ... other company logic ...
}
class PackageShipper {
public function shipTo(Addressable $entity) {
$address = $entity->getAddress();
// ... do shipping code using $address ...
}
}
A class can implement many different interfaces, and classes with different bases can still implement the same interface.
But there is still a problem. Both Company and User implement the
Addressable interface using the same code. It is not required to do this; as long as the constraints of the interface are met, the implementation does not have to be the same for every class that implements the interface. But in this case, they both implement the interface in the same way, and we have duplicated code. If a third Addressable class came along, it is possible that it would also implement the interface the same way, leading to even more duplication.If you are using PHP 5.3 or less, there is little that can be done about this situation. But if you are using PHP 5.4, there is a new construct that is made to handle exactly these types of code duplication scenarios: traits.
A trait is similar to a class in that they both implement methods and have properties. The difference is that classes can be instantiated, but traits cannot. Instead, traits are added to class definitions, giving that class all the methods and properties that are defined in the trait.
A helpful way to think about traits is like a macro: using a trait in a class is the same as if the code in the trait were copied into the class.
Using traits, we can clean up the code duplication and still meet the contract defined by the Addressable interface:
trait AddressAccessor {
protected $address;
public function setAddress(Address $address) {
$this->address = $address;
}
public function getAddress() {
return $this->address;
}
}
class User implements Addressable {
use AddressAccessor;
// ... other user logic ...
}
class Company implements Addressable {
use AddressAccessor;
// ... other company logic ...
}
Now, any class can immediately implement the Addressable interface by simply using the
AddressAccessor trait. All the duplicated code has been moved to a single place.The trait itself does not implement Addressable. This is because only classes can implement interfaces. Remember that traits are nothing more than code that gets copied into a class, they are not classes on their own.
Interfaces in PHP are a useful feature for enforcing code correctness. And when interfaces are combined with traits, they form a powerful tool which allows for faster development, decreased code duplication, greater readbility, and better maintainability.
Here is all the final code for the package shipping application:
class Address {
// ... setters and getters for address fields ...
}
inteface Addressable {
public function setAddress(Address $address);
public function getAddress();
}
trait AddressAccessor {
protected $address;
public function setAddress(Address $address) {
$this->address = $address;
}
public function getAddress() {
return $this->address;
}
}
class User implements Addressable {
use AddressAccessor;
// ... other user logic ...
}
class Company implements Addressable {
use AddressAccessor;
// ... other company logic ...
}
class PackageShipper {
public function shipTo(Addressable $entity) {
$address = $entity->getAddress();
// ... do shipping code using $address ...
}
}
