Factory Pattern
1. Simple Factory
Understanding
Factory classes in the simple factory pattern generally use static methods to return different object instances based on the different parameters they receive.
It cannot be expanded without modifying the code.
Example
Product interface
//Product interface
public interface ProductI {
public void productName();
}
Product entity class
public class ProductA implements ProductI {
@Override
public void productName() {
System .out.println("product A");
}
}
public class ProductB implements ProductI {
@Override
public void productName() {
System.out.println("product B");
}
}
Factory class
//Simple factory pattern
public class Factory {
public ProductI create(String productName) {
switch (productName) {
case "A": use using ‐ ‐ use using through through through through ‐ ‐ ‐‐ ‐‐ ‐‐‐‐ to
return new ProductB();
return null; Factory();
ProductI productA = factory.create("A");
productA.productName();
ProductI productB = factory.create("B"); productB.productName();
}
}
Output
product A
product B
Factory method
Understanding
The factory method provides a factory class for each product. Different product instances are created through different factory instances.
In the same hierarchical structure, any product is supported.
Example
The product interface, product entity class and simple factory are the same.
Factory interface
public interface FactoryI {
// The purpose of the factory is to produce products
public ProductI create();
}
Factory entity class
public class FactoryA implements FactoryI {
@Override
public ProductI create() {
Return new ProductA();
public class Client {
public static void main(String[] args) {
FactoryI factoryA = new FactoryA();
ProductI productA = factoryA.create();
productA.productName();
//
FactoryI factoryB = new FactoryB();
ProductI productB = factoryB.create();
productB.productName();
}
}
Output
product A
product B
Abstract Factory
Understanding
Abstract factory is a response to product families Conceptual. For example, each automobile company may want to produce cars, trucks, and buses at the same time, so each factory must have a method for creating cars, trucks, and buses.
It was born in response to the concept of product family. It is easy to add new product lines, but it is impossible to add new products.
The difference from factory methods is that abstract factories often have multiple methods that can produce multiple products, that is, product clusters.
Example
Abstract factory class
// Drawing factory pattern
public interface AbstractFactory {
public ProductAI createProductA();
public ProductBI createProductB();
}
Factory entity class
public class Factory1 implements AbstractFactory {
@Override
public ProductAI createProductA() {
return new ProductA1();
}
@Override
public ProductBI createProductB() {
return new ProductB1();
}
}
public class Factory2 implements AbstractFactory {
@Override
public ProductAI createProductA() {
return new ProductA2();
}
@Override
public ProductBI createProductB() {
return new ProductB2();
}
}
产品接口
//产品接口
public interface ProductBI {
public void productName();
}
//产品接口
public interface ProductAI {
public void productName();
}
产品实体类
public class ProductA1 implements ProductAI {
@Override
public void productName() {
System.out.println("product A1");
}
}
更多Java设计模式之工厂模式(三种)相关文章请关注PHP中文网！