Facade is unified interace to access multiple classes. The client need not be bothered about multiple classes to accompolish the task. The client just needs to interact with the Facade to get the job done.

For example when the client wants to ship a order in a order management system. Ordering involves calls to multiple classes. This calls can be encapsulated in a facade. The client can then invoke the facade method so that the overall complexity in getting the job done will be reduced. All the complicated logic will reside in the facade. Any future changes in the logic entils to change only in the facade and not in the client.

Facade discusses encapsulating a complex subsystem within a single interface object. This reduces the learning curve necessary to successfully leverage the subsystem. It also promotes decoupling the subsystem from its potentially many clients. On the other hand, if the Facade is the only access point for the subsystem, it will limit the features and flexibility that "power users" may need.The Facade object should be a fairly simple advocate or facilitator. It should not become an all-knowing oracle or "god" object.

In short, it is the same age-old concept of Abstraction and Encapsulation.

All well defined objects are facades in a sense. They encapsulate their data and and the actual implementation from the callers and provide services as an abstraction. For example, a Stack object lets the caller push and pop objects without worrying about how it is implemented internally.

The Facade pattern extends the same concept to a higher level. Here, the entire complex inner-workings of a subsystem are encapsulated and a simple abstraction is presented to the outer world as the facade.

The whole JDBC mechanism in Java can be considered a facade. The caller will do something as simple as

PreparedStatement.executeUpdate()

and doesn't worry about the actual complexities of database access, connection pooling etc.

A facade is a simpler mask given to a complex entity. A facade pattern is based on the basic principle that all the complexities are to be hidden behind a simpler interface.

A very appropriate example from JDK itself is the JDBC. JDBC is an abstraction over database-access mechanisms. While a developer is not at all exposed to the nitty-gritties of as to how the databse specific driver classes internally connect to and read data from the database.

All that the developer is exposed is the interfaces like Connection, ResultSet, Statement. Their implementation classes hide all the complexities behind this simple interface we know as JDBC and hence is a facade.

facade pattern is used to give the client a urified interface.for example suppose client has to interact with different independent class to perform several task,for this , the client has to know and remember aboutdetail of each and every class , so to avoid thiswe introduce a facade ( a class) which aggregate all the other classes, and provide the simpler functionin it (which internally call the class's orignal method)

so in that case the client has to know only about one class . and which is easy for him to remember and use.

by providing facade it does not mean that now clientwill not be able to use other classes, if he want he can.but if he want ease he can use facade .