* Unit test case writing becomes much easier

* UI tools for different OS

* Dependency injection in java hides the service class dependencies that can lead to runtime errors that would have been caught at compile time.

* While the pattern is great when creating predefined objects, adding the new ones might be challenging.

* The code becomes more complicated than it should be since a lot of new interfaces and classes are introduced along with the pattern.

*[Abstract Factory Pattern Tutorial](https://www.journaldev.com/1418/abstract-factory-design-pattern-in-java)

* you need to use several existing subclasses, but it's impractical to adapt their interface by subclassing every one. An object adapter can adapt the interface of its parent class.

* most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

Class and object adapters have different trade-offs. A class adapter

*adapts Adaptee to Target by committing to a concrete Adaptee class. As a consequence, a class adapter won’t work when we want to adapt a class and all its subclasses.

*makes it harder to override Adaptee behavior. It will require subclassing Adaptee and making Adapter refer to the subclass rather than the Adaptee itself.

*[java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)

*[java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)

* The algorithm for creating a complex object should be independent of the parts that make up the object and how they're assembled

* The construction process must allow different representations for the object that's constructed

*[java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)

*[java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-) as well as similar buffers such as FloatBuffer, IntBuffer and so on.

* You want to issue a request to one of several objects without specifying the receiver explicitly.

* The set of objects that can handle a request should be specified dynamically.

*[java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29)

*[Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html)

changes. The Command pattern offers a way to model transactions. Commands have a common interface,

letting you invoke all transactions the same way. The pattern also makes it easy to extend the

system with new transactions.

* Keep a history of requests.

* Implement callback functionality.

* Implement the undo functionality.

## Typical Use Case

* To keep a history of requests

* Implement callback functionality

* Implement the undo functionality

## Real-world examples

## Known uses

* [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)

* [org.junit.runners.model.Statement](https://github.com/junit-team/junit4/blob/master/src/main/java/org/junit/runners/model/Statement.java)