Factory modelBoth the strategy pattern are important in the design patternComponents, They are used to solve different types of software design problems. Here are the differences between them:
-
Different purposes：
- Factory modelThe main purpose of (Factory Pattern) is to create objects. It provides an interface for creating objects so that subclasses can decide which class to instantiate. The focus of the factory model is on how to create and manage objects.
- Policy Mode(Strategy Pattern) aims to define a series of algorithms, encapsulate each algorithm and make them interchangeable. The policy pattern allows the algorithm to change without affecting the client. Its focus is on how to use different methods or algorithms to accomplish a certain behavior.
-
Use scenarios：
- Factory modelCommonly used when we need to dynamically decide which instance of the class to create at runtime, and these classes have common interfaces or base classes.
- Policy ModeSuitable for use when a behavior or algorithm that requires dynamically changing an object, and these behaviors can be replaced with each other.
-
Different roles：
- Factory modelIncludes factory interfaces (or abstract classes) and concrete factory classes, which are responsible for creating product objects.
- Policy ModeContains policy interfaces and specific policy implementations, and uses these policies in context classes.
-
Design Intent：
- Factory modelThe complexity and specific implementation of creating objects are hidden. The client only needs to obtain the required objects through the factory, without knowing the object creation process.
- Policy ModeAllow clients to select algorithms in the same family of algorithms to ensure that changes in algorithms do not affect customers using algorithms.
Scene: Suppose we have an application that needs to create various types of documents in different ways, such asWorddocument,PDFdocument,Exceldocument. Each document type has a different creation implementation.
Implement factory model：
-
Document interface: Define a common interface or abstract class to represent a document.
java-
interface Document {
-
void open();
-
}
Open in:Code Editor
-
-
Specific document categories: Different classes that implement document interfaces.
java-
class WordDocument implements Document {
-
public void open() {
-
System.out.println("Opening a Word document.");
-
}
-
}
-
-
class PdfDocument implements Document {
-
public void open() {
-
System.out.println("Opening a PDF document.");
-
}
-
}
Open in:Code Editor
-
-
Factory: Provides a unified interface for document creation through factory classes.
java-
class DocumentFactory {
-
public Document createDocument(String type) {
-
if (type.equalsIgnoreCase("Word")) {
-
return new WordDocument();
-
} else if (type.equalsIgnoreCase("PDF")) {
-
return new PdfDocument();
-
} else {
-
throw new IllegalArgumentException("Unknown document type");
-
}
-
}
-
}
Open in:Code Editor
-
-
Use factory：
java-
public class Main {
-
public static void main(String[] args) {
-
DocumentFactory factory = new DocumentFactory();
-
Document doc = factory.createDocument("Word");
-
doc.open(); // Output: Opening a Word document.
-
}
-
}
Open in:Code Editor
-
Policy ModeCase
Scene: Suppose we have an application responsible for processing different types of payments. We need to support a variety of payment strategies, such as credit card payment, Alipay payment and WeChat payment.
Implementing the policy model：
-
Payment policy interface: Define a common interface to represent payment policy.
java-
interface PaymentStrategy {
-
void pay(int amount);
-
}
Open in:Code Editor
-
-
Specific strategy category: Implement different types of payment policy interfaces.
java-
class CreditCardPayment implements PaymentStrategy {
-
public void pay(int amount) {
-
System.out.println("Paying " + amount + " using Credit Card.");
-
}
-
}
-
-
class AlipayPayment implements PaymentStrategy {
-
public void pay(int amount) {
-
System.out.println("Paying " + amount + " using Alipay.");
-
}
-
}
Open in:Code Editor
-
-
Context Class: Use policy interfaces in context class.
java-
class PaymentContext {
-
private PaymentStrategy strategy;
-
-
public PaymentContext(PaymentStrategy strategy) {
-
this.strategy = strategy;
-
}
-
-
public void executePayment(int amount) {
-
(amount);
-
}
-
}
Open in:Code Editor
-
-
Usage strategies：
java-
public class Main {
-
public static void main(String[] args) {
-
PaymentContext context = new PaymentContext(new CreditCardPayment());
-
(100); // Output: Paying 100 using Credit Card.
-
-
context = new PaymentContext(new AlipayPayment());
-
(200); // Output: Paying 200 using Alipay.
-
}
-
}
Open in:Code Editor
-
Summary of the difference
The factory model focuses on the creation process, while the policy model focuses on changes in behavior or algorithms. They can be used alone in different designs or combined to achieve more complex functions.
-
Factory model: Transfer the responsibility for instantiating an object to the factory by creating a factory class. When we don't know which class we need to instantiate, the factory pattern is used. It hides the complexity of object instantiation.
-
Policy Mode: Allows the selection of different algorithms or operations during execution. When we need to dynamically change the behavior or algorithm of an object, we use the policy pattern. This allows the algorithm to vary independently of the client using it.