策略设计模式和抽象工厂模式有什么区别？
有人可以一劳永逸地向我解释这两者之间的区别，并尝试为何时使用它们提供一种指导吗？例子真的很好。
Can someone once and for all explain to me the difference between these two and try to give a sort of guideline for when to use each one of them? Examples would be really nice.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（3）
除了结构和实现细节之外，意图有所不同。一旦你掌握了意图的重要性这一基本理念，那么你就会走在正确的道路上。
了解意图在设计模式中的作用
战略意图。这是一种行为模式
抽象工厂的意图。这是一种创建模式，
The INTENT is different other than structural and implementation details. As soon as you grasp this fundamental idea that INTENT is of significance, then you will be on the right path.
Understand the role of intent in design patterns
Intent for Strategy. This is a Behavioral Pattern
Intent for Abstract Factory. This is a Creational Pattern
策略是针对没有一流函数的语言的一种解决方法。您传入一个策略对象，该对象决定您希望与其余代码分开的某些策略。想想 Java 中的排序以及它们如何使用比较器，比较器是一个策略对象，它允许您独立于排序算法指定排序策略。这允许您通过加入不同的策略来重用代码。
抽象工厂是一个用于创建其他对象的对象，抽象部分是您有一个返回工厂实现的工厂，工厂的用户通过接口访问它。因此，可以将一种工厂实现替换为另一种工厂实现，而无需更改工厂的用户，因为这些用户仅依赖于对象的接口。
Strategy is a workaround for languages that don't have first-class functions. You pass in a strategy object that decides some policy that you want separated from the rest of the code. Think of sorting in Java and how they use Comparators, a Comparator is a strategy object that allows you to specify the policy for sorting separately from the sorting algorithm. That allows you to reuse the code by dropping in different strategies.
Abstract Factory is an object used to create other objects, with the abstract part being that you have a factory that returns an implementation of the factory, where users of the factory access it through an interface. So one factory implementation can be swapped out for another with no changes to users of the factories, because those users are depending on the objects' interfaces only.
工厂设计模式充当工厂，并根据您的请求在运行时生成不同类型的对象。因此，控制是在运行时进行的，您可以在运行时决定所需的对象。这样对象之间的耦合就会减少。
另一方面，策略设计模式允许您通过使用“有一个”关系而不是“是一个”关系来更好地控制层次结构。因为如果我们试图在更复杂的场景中使用继承 (is a)，那么我们可能必须重写几代继承的方法，从而避免代码重用。
假设您创建了一个 Animal 类（或接口）并且其中有一个 move 方法。
您希望通过扩展它来创建一个鸟类类。因此，您将在 move() 方法下添加飞行功能。但企鹅的情况又如何呢？他们将具有步行功能。
因此，每次通过扩展 Animal 类创建动物时，您都必须一次又一次地重写 move() 方法。您可以清楚地了解 move() 方法更容易受到更改，因此最佳实践是将更改部分与核心代码分开。
我们可以简单地为 move() 方法创建一个单独的层次结构。您可以通过 setter 方法将相关的 move() 方法分配给对象。因此控制权被传递给运行时。下图说明了这一事实；
以下是我的 2 篇博客文章，如果您愿意，可以参考它们以获取更多详细信息。
工厂设计模式
策略设计模式
Factory Design pattern act as a factory and generates different kinds of objects at run time as per your request. So control is at run time and you get to decide the object you require at run time. So coupling among objects will be reduced.
On the other hand, Strategy design pattern allows you to take better control of hierarchical structures by using "has a" relationship over "is a" relationship. Because if we tempt to use inheritance (is a) in a more complex scenario then we may have to override the methods inherited over generations and it avoids code reuse.
Let's say you create an Animal class(or interface) and you are having a move method in it.
And you are hoping to create a bird class by extending it. So you will add flying features under move() method. But what is the case with penguins? They will have walking features.
So every time you create an animal by extending the Animal class, you will have to override the move() method again and again. You can clearly understand move() method is more vulnerable to changes, so best practice is to separate the changing part from core codes.
Simply we can create a separate hierarchy to move() methods. You can assign related move() method to the object via setter methods. So control is passed to run time. Following diagram illustrates that fact;
Following are 2 of my blog posts if you like you can refer them for further details.
Factory Design pattern
Strategy Design pattern