Facade Pattern

Youtube Video  Paid Video

The Facade Pattern provides a unified interface to a set of interfaces in a sub-sytem. Facade defines a higher level interface that makes the subsystem easier to use.

The Law of Demeter (LoD) or principle of least knowledge is a design guideline for developing software, particularly object-oriented programs. In its general form, the LoD is a specific case of loose coupling. The guideline was proposed by Ian Holland at Northeastern University towards the end of 1987, and can be succinctly summarized in each of the following ways:

• Each unit should have only limited knowledge about other units: only units “closely” related to the current unit.
• Each unit should only talk to its friends; don’t talk to strangers.
• Only talk to your immediate friends.

When applied to object-oriented programs, the Law of Demeter can be more precisely called the “Law of Demeter for Functions/Methods” (LoD-F). In this case, an object A can request a service (call a method) of an object instance B, but object A should not “reach through” object B to access yet another object, C, to request its services. Doing so would mean that object A implicitly requires greater knowledge of object B‘s internal structure. Instead, B‘s interface should be modified if necessary so it can directly serve object A‘s request, propagating it to any relevant subcomponents. Alternatively, A might have a direct reference to object C and make the request directly to that. If the law is followed, only object B knows its own internal structure.

More formally, the Law of Demeter for functions requires that a method m of an object O may only invoke the methods of the following kinds of objects:^[2]Dzone

1. O itself
2. m‘s parameters
3. Any objects created/instantiated within m
4. O‘s direct component objects
5. A global variable, accessible by O, in the scope of m

In particular, an object should avoid invoking methods of a member object returned by another method.

Link Real world example

How do you turn on the computer? “Hit the power button” you say! That is what you believe because you are using a simple interface that computer provides on the outside, internally it has to do a lot of stuff to make it happen. This simple interface to the complex subsystem is a facade.

In plain words

Facade pattern provides a simplified interface to a complex subsystem.

Wikipedia says

A facade is an object that provides a simplified interface to a larger body of code, such as a class library.

Programmatic Example

Taking our computer example from above. Here we have the computer class

class Computer {  public function getElectricShock()  {  echo "Ouch!";  }  public function makeSound()  {  echo "Beep beep!";  }  public function showLoadingScreen()  {  echo "Loading..";  }  public function bam()  {  echo "Ready to be used!";  }  public function closeEverything()  {  echo "Bup bup bup buzzzz!";  }  public function sooth()  {  echo "Zzzzz";  }  public function pullCurrent()  {  echo "Haaah!";  } }

Here we have the facade

class ComputerFacade {  protected $computer;  public function __construct(Computer $computer)  {  $this->computer = $computer;  }  public function turnOn()  {  $this->computer->getElectricShock();  $this->computer->makeSound();  $this->computer->showLoadingScreen();  $this->computer->bam();  }  public function turnOff()  {  $this->computer->closeEverything();  $this->computer->pullCurrent();  $this->computer->sooth();  } }

Now to use the facade

$computer = new ComputerFacade(new Computer()); $computer->turnOn(); // Ouch! Beep beep! Loading.. Ready to be used! $computer->turnOff(); // Bup bup buzzz! Haah! Zzzzz