所有这四种模式都涉及到用外部对象/类包装内部对象/类，因此它们在结构上非常相似。我将通过目的来概述不同之处:

代理将访问从外部封装到内部。 装饰器用外部修改或扩展内部的行为。 适配器转换接口从内部到外部。 桥将行为的不变部分(外部)与变量或平台依赖部分(内部)分开。

通过内外物体之间的界面变化:

在代理接口中是相同的。 在Decorator接口中是相同的。 在适配器接口形式上不同，但实现相同的目的。 桥接接口在概念上是不同的。

在许多GoF模式中有大量的重叠。它们都建立在多态性的力量之上，有时只是意图不同。(战略vs.国家)

在阅读了头部优先设计模式之后，我对模式的理解增加了100倍。

我强烈推荐!

我想为Bill Karwing的回答补充一些例子(顺便说一句，这很好)。 我还补充了一些执行上的关键差异，我觉得这是我所缺失的

引用部分来自[https://stackoverflow.com/a/350471/1984346] (Bill Karwing)的回答

代理、装饰器、适配器和桥接器都是“包装”类的变体。 但它们的用途不同。 当您希望延迟实例化对象时，可以使用代理 隐藏您正在调用远程服务或控制访问的事实 对物体。

ProxyClass和被代理的ObjectClass应该实现相同的接口，因此它们是可交换的

示例- proxy昂贵对象

class ProxyHumanGenome implements GenomeInterface  {
    private $humanGenome = NULL; 

    // humanGenome class is not instantiated at construct time
    function __construct() {
    }

    function getGenomeCount() {
        if (NULL == $this->humanGenome) {
            $this->instantiateGenomeClass(); 
        }
        return $this->humanGenome->getGenomeCount();
    }
} 
class HumanGenome implement GenomeInterface { ... }

Decorator也称为“智能代理”。这是在你需要的时候使用的 向一个对象添加功能，但不是通过扩展该对象的功能 类型。这允许您在运行时这样做。

DecoratorClass应该(可以)实现ObjectClass的扩展接口。所以ObjectClass可以被DecoratorClass替换，反之则不行。

示例-添加附加功能

class DecoratorHumanGenome implements CheckGenomeInterface  {

    // ... same code as previous example

    // added functionality
    public function isComplete() {
        $this->humanGenome->getCount >= 21000
    }
}

interface CheckGenomeInterface extends GenomeInterface {

    public function isComplete();

}

class HumanGenome implement GenomeInterface { ... }

适配器用于当您有一个抽象接口，并且您想要 将该接口映射到具有类似功能的另一个对象 角色，但是不同的接口。

实现差异代理，装饰器，适配器

Adapter为其主题提供了不同的接口。Proxy提供相同的接口。Decorator提供了增强的接口。

Bridge is very similar to Adapter, but we call it Bridge when you define both the abstract interface and the underlying implementation. I.e. you're not adapting to some legacy or third-party code, you're the designer of all the code but you need to be able to swap out different implementations. Facade is a higher-level (read: simpler) interface to a subsystem of one or more classes. Suppose you have a complex concept that requires multiple objects to represent. Making changes to that set of objects is confusing, because you don't always know which object has the method you need to call. That's the time to write a Facade that provides high-level methods for all the complex operations you can do to the collection of objects. Example: a Domain Model for a school section, with methods like countStudents(), reportAttendance(), assignSubstituteTeacher(), and so on.

这个答案中的大部分信息来自https://sourcemaking.com/design_patterns，我推荐它作为设计模式的优秀资源。

Design pattern is not mathematics, it is combination of art and software engineering. There is nothing like for this requirment you have to use proxy, bridge etc. Design patterns are created to solve the problems. If you anticipate a design problem, then use it. Based on experience, you will come to know for specific problem, which pattern to use. If you are good in solid design principles, you would have implemented design pattern without knowing it is pattern. Common example is statergy and factory patterns

因此，更多地集中在坚实的设计原则，干净的编码原则和ttd

代理、装饰器、适配器和桥接器都是“包装”类的变体。但它们的用途不同。

Proxy could be used when you want to lazy-instantiate an object, or hide the fact that you're calling a remote service, or control access to the object. Decorator is also called "Smart Proxy." This is used when you want to add functionality to an object, but not by extending that object's type. This allows you to do so at runtime. Adapter is used when you have an abstract interface, and you want to map that interface to another object which has similar functional role, but a different interface. Bridge is very similar to Adapter, but we call it Bridge when you define both the abstract interface and the underlying implementation. I.e. you're not adapting to some legacy or third-party code, you're the designer of all the code but you need to be able to swap out different implementations. Facade is a higher-level (read: simpler) interface to a subsystem of one or more classes. Suppose you have a complex concept that requires multiple objects to represent. Making changes to that set of objects is confusing, because you don't always know which object has the method you need to call. That's the time to write a Facade that provides high-level methods for all the complex operations you can do to the collection of objects. Example: a Domain Model for a school section, with methods like countStudents(), reportAttendance(), assignSubstituteTeacher(), and so on.

说到细节实现，我发现代理和Decorator，适配器，Facade之间的区别…在这些模式的常见实现中，有一个被封闭对象包裹的目标对象。客户端使用外围对象而不是目标对象。目标对象实际上在一些封闭对象的方法中扮演着重要的角色。

而对于Proxy，外围对象可以自己扮演一些方法，它只是在客户端调用一些需要目标对象参与的方法时对目标对象进行初始化。这是惰性初始化。对于其他模式，封闭对象实际上是基于目标对象的。目标对象总是和构造函数/setter中的封闭对象一起初始化。

另一件事，代理所做的正是目标所做的，而其他模式则为目标添加了更多功能。