工厂模式(Factory Design Pattern)分为三种更加细分的类型:简单工厂、工厂方法和抽象工厂。在这三种细分的工厂模式中,简单工厂、工厂方法原理比较简单,在实际的项目中也比较常用。而抽象工厂的原理稍微复杂点,在实际的项目中相对也不常用。
工厂模式是一种常见的创建型设计模式,其主要目的是封装对象的创建过程,并隐藏具体实现细节。每种方式都有其独特的优点和缺点。
下面是工厂模式的一些优点:
缺点:
选择是否使用工厂模式的标准:
简单工厂模式(Simple Factory Pattern)通过一个工厂类来封装对象的创建过程,根据不同的参数返回对应的具体产品实例。
简单工厂模式包含以下角色:
简单工厂模式的步骤如下:
优点:
缺点:
总的来说,简单工厂模式适用于创建的产品种类较少且不会经常变动的情况。如果产品种类较多或经常变动,建议使用工厂方法模式或者抽象工厂模式。
有一个 Car 接口,以及实现类 Ford, Ferrari。
public interface Car {
String getDescription();
}
public class Ford implements Car {
static final String DESCRIPTION = "This is Ford.";
@Override
public String getDescription() {
return DESCRIPTION;
}
}
public class Ferrari implements Car {
static final String DESCRIPTION = "This is Ferrari.";
@Override
public String getDescription() {
return DESCRIPTION;
}
}
以下的枚举用于表示支持的 Car 类型(Ford 和 Ferrari)
public enum CarType {
FORD(Ford::new),
FERRARI(Ferrari::new);
private final Supplier<Car> constructor;
CarType(Supplier<Car> constructor) {
this.constructor = constructor;
}
public Supplier<Car> getConstructor() {
return this.constructor;
}
}
接着我们实现了一个静态方法 getCar 用于封装工厂类 CarsFactory 创建 Car 具体对象实例的细节。
public class CarsFactory {
public static Car getCar(CarType type) {
return type.getConstructor().get();
}
}
现在我们可以在客户端代码中通过工厂类创建不同类型的 Car 对象实例。
var car1 = CarsFactory.getCar(CarType.FORD);
var car2 = CarsFactory.getCar(CarType.FERRARI);
LOGGER.info(car1.getDescription());
LOGGER.info(car2.getDescription());
程序输出:
This is Ford.
This is Ferrari.
工厂方法模式(Factory Method Pattern)将对象的创建延迟到子类中进行。工厂方法模式通过定义一个创建对象的接口,但将具体的对象创建交给子类来实现。
工厂方法模式包含以下角色:
工厂方法模式的步骤如下:
优点:
缺点:
工厂方法模式适用于需要创建多个具有共同接口或基类的产品对象的情况,且这些产品对象的创建逻辑相似但可能会有差异。它提供了一种灵活的扩展机制,能够方便地添加新的产品类型,而不影响已有的代码。
例子: 铁匠生产武器。精灵需要精灵武器,而兽人需要兽人武器。根据客户来召唤正确类型的铁匠。
public interface Blacksmith {
Weapon manufactureWeapon(WeaponType weaponType);
}
public class ElfBlacksmith implements Blacksmith {
public Weapon manufactureWeapon(WeaponType weaponType) {
return ELFARSENAL.get(weaponType);
}
}
public class OrcBlacksmith implements Blacksmith {
public Weapon manufactureWeapon(WeaponType weaponType) {
return ORCARSENAL.get(weaponType);
}
}
使用工厂方法:
/**
* 抽象工厂 Blacksmith 具体工厂 OrcBlacksmith ElfBlacksmith
*/
Blacksmith blacksmith = new OrcBlacksmith();
Weapon weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
LOGGER.info("{} manufactured {}", blacksmith, weapon);
weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
LOGGER.info("{} manufactured {}", blacksmith, weapon);
blacksmith = new ElfBlacksmith();
weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
LOGGER.info("{} manufactured {}", blacksmith, weapon);
weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
LOGGER.info("{} manufactured {}", blacksmith, weapon);
程序输出:
The orc blacksmith manufactured an orcish spear
The orc blacksmith manufactured an orcish axe
The elf blacksmith manufactured an elven spear
The elf blacksmith manufactured an elven axe
通俗的讲就是工厂的工厂, 一个将单个但相关/从属的工厂分组在一起而没有指定其具体类别的工厂。
在抽象工厂模式中,有一个抽象工厂接口,定义了一系列用于创建产品对象的方法。每个具体的工厂类都实现了这个抽象工厂接口,并负责创建一组相关的产品。这些产品通常属于同一族或遵循某种主题。
关键要素:
优点:
以下是抽象工厂模式的简单示例,其中AbstractFactory
为抽象工厂:
// 抽象产品A
interface AbstractProductA {
void operationA();
}
// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
public void operationA() {
System.out.println("ConcreteProductA1 operationA");
}
}
// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
public void operationA() {
System.out.println("ConcreteProductA2 operationA");
}
}
// 抽象产品B
interface AbstractProductB {
void operationB();
}
// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
public void operationB() {
System.out.println("ConcreteProductB1 operationB");
}
}
// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
public void operationB() {
System.out.println("ConcreteProductB2 operationB");
}
}
// 抽象工厂
interface AbstractFactory {
// 减少简单工厂的数量
AbstractProductA createProductA();
AbstractProductB createProductB();
}
// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
// 使用抽象工厂创建产品
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.operationA();
productB1.operationB();
AbstractFactory factory2 = new ConcreteFactory2();
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.operationA();
productB2.operationB();
}
}
输出
ConcreteProductA1 operationA
ConcreteProductB1 operationB
ConcreteProductA2 operationA
ConcreteProductB2 operationB
以上内容基于GPT创建和整理。