Adapter Pattern:
The Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to work together without modifying their source code. This pattern involves a single class, called the adapter, which is responsible for communication between the object and the system. The adapter acts as a bridge between the two interfaces, allowing them to communicate. In other words, a separate Adapter class is created that converts the interface of one class into an interface expected by the clients.

The adapter pattern has three components:
1. Target interface:
This is the interface that the client expects to work with. It defines a specific interface that isn't compatible with the existing object (the Adaptee). The Adapter uses this interface when dealing with the client.

2. Adaptee:
This is the existing object that needs adapting. The Adaptee is the class or interface that the Adapter wraps around. The Adaptee has its own functionality, but its interface is not compatible with the client.

3. Adapter:
This is the class that's created to bridge the gap between the Target interface and the Adaptee. The Adapter contains an instance of the Adaptee and transforms the Adaptee's interface into an interface that the client can use. This transformation is typically done by implementing the Target interface and using an instance of the Adaptee to provide the actual functionality.

Suppose you have an old logging system that your code uses to print logs, and it only supports writing logs to the console. Now you want to upgrade your logging system to support writing logs to a file. However, the interface to write logs to a file is different from the one your old logging system uses. You can't change your existing codebase; instead, you can use an Adapter to bridge the gap.

Implementation in Go: