在工厂方法模式中,我们使用一个工厂创建一个产品,也就是说一个具体的工厂对应一个具体的产品。但是有时候我们需要一个工厂能够提供多个产品对象,而不是单一的对象,这个时候我们就需要使用抽象工厂模式。
在讲解抽象工厂模式之前,我们需要厘清两个概念:
产品等级结构。产品的等级结构也就是产品的继承结构。例如一个为空调的抽象类,它有海尔空调、格力空调、美的空调等一系列的子类,那么这个抽象类空调和他的子类就构成了一个产品等级结构。
产品族。产品族是在抽象工厂模式中的。在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品。比如,海尔工厂生产海尔空调。海尔冰箱,那么海尔空调则位于空调产品族中。
产品等级结构和产品族结构示意图如下:
一、基本定义
抽象工厂模式提供一个接口,用于创建相关或者依赖对象的家族,而不需要明确指定具体类。
抽象工厂允许客户端使用抽象的接口来创建一组相关的产品,而不需要关系实际产出的具体产品是什么。这样一来,客户就可以从具体的产品中被解耦。
二、模式结构
抽象工厂模式的UML结构图如下:
模式结构说明。
AbstractFactory:抽象工厂。抽象工厂定义了一个接口,所有的具体工厂都必须实现此接口,这个接口包含了一组方法用来生产产品。
ConcreteFactory:具体工厂。具体工厂是用于生产不同产品族。要创建一个产品,客户只需要使用其中一个工厂完全不需要实例化任何产品对象。
AbstractProduct:抽象产品。这是一个产品家族,每一个具体工厂都能够生产一整组产品。
Product:具体产品。
三、模式实现
依然是披萨店。为了要保证每家加盟店都能够生产高质量的披萨,防止使用劣质的原料,我们打算建造一家生产原料的工厂,并将原料运送到各家加盟店。但是加盟店都位于不同的区域,比如纽约、芝加哥。纽约使用一组原料,芝加哥使用另一种原料。在这里我们可以这样理解,这些不同的区域组成了原料家族,每个区域实现了一个完整的原料家族。
首先创建一个原料工厂。该工厂为抽象工厂,负责创建所有的原料。
PizzaIngredientFactory.java
public interface PizzaIngredientFactory {
/*
* 在接口中,每个原料都有一个对应的方法创建该原料
*/
public Dough createDough();
public Sauce createSauce();
public Cheese createCheese();
public Veggies[] createVeggies();
public Pepperoni createPepperoni();
public Clams createClams();
}
原料工厂创建完成之后,需要创建具体的原料工厂。该具体工厂只需要继承PizzaIngredientFactory,然后实现里面的方法即可。
纽约原料工厂:NYPizzaIngredientFactory.java。
public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
@Override
public Cheese createCheese() {
return new ReggianoCheese();
}
@Override
public Clams createClams() {
return new FreshClams();
}
@Override
public Dough createDough() {
return new ThinCrustDough();
}
@Override
public Pepperoni createPepperoni() {
return new SlicedPepperoni();
}
@Override
public Sauce createSauce() {
return new MarinaraSauce();
}
@Override
public Veggies[] createVeggies() {
Veggies veggies[] = {new Garlic(),new Onion(),new Mushroom(),new RefPepper()};
return veggies;
}
}
重新返回到披萨。在这个披萨类里面,我们需要使用原料,其他方法保持不变,将prepare()方法声明为抽象,在这个方法中,我们需要收集披萨所需要的原料。
Pizza.java
public abstract class Pizza {
/*
* 每个披萨都持有一组在准备时会用到的原料
*/
String name;
Dough dough;
Sauce sauce;
Veggies veggies[];
Cheese cheese;
Pepperoni pepperoni;
Clams clams;
/*
* prepare()方法声明为抽象方法。在这个方法中,我们需要收集披萨所需要的原料,而这些原料都是来自原料工厂
*/
abstract void prepare();
void bake(){
System.out.println("Bake for 25 munites at 350");
}
void cut(){
System.out.println("Cutting the pizza into diagonal slices");
}
void box(){
System.out.println("Place pizza in official PizzaStore box");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
CheesePizza.java
public class CheesePizza extends Pizza{
PizzaIngredientFactory ingredientFactory;
/*
* 要制作披萨必须要有制作披萨的原料,而这些原料是从原料工厂运来的
*/
public CheesePizza(PizzaIngredientFactory ingredientFactory){
this.ingredientFactory = ingredientFactory;
prepare();
}
/**
* 实现prepare方法
* prepare 方法一步一步地创建芝士比萨,每当需要原料时,就跟工厂要
*/
void prepare() {
System.out.println("Prepareing " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
Pizza的代码利用相关的工厂生产原料。所生产的原料依赖所使用的工厂,Pizza类根本不关心这些原料,它只需要知道如何制作披萨即可。这里,Pizza和区域原料之间被解耦。
ClamPizza.java
public class ClamPizza extends Pizza{
PizzaIngredientFactory ingredientFactory;
public ClamPizza(PizzaIngredientFactory ingredientFactory){
this.ingredientFactory = ingredientFactory;
}
@Override
void prepare() {
System.out.println("Prepare " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
clams = ingredientFactory.createClams();
}
}
做完披萨后,需要关注披萨店了。
在披萨店中,我们依然需要关注原料,当地的披萨店需要和本地的原料工厂关联起来。
PizzaStore.java
public abstract class PizzaStore {
public Pizza orderPizza(String type){
Pizza pizza;
pizza = createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
/*
* 创建pizza的方法交给子类去实现
*/
abstract Pizza createPizza(String type);
}
纽约的披萨店:NYPizzaStore.java
public class NYPizzaStore extends PizzaStore{
@Override
Pizza createPizza(String type) {
Pizza pizza = null;
//使用纽约的原料工厂
PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
if("cheese".equals(type)){
pizza = new CheesePizza(ingredientFactory);
pizza.setName("New York Style Cheese Pizza");
}
else if("veggie".equals(type)){
pizza = new VeggiePizza(ingredientFactory);
pizza.setName("New York Style Veggie Pizza");
}
else if("clam".equals(type)){
pizza = new ClamPizza(ingredientFactory);
pizza.setName("New York Style Clam Pizza");
}
else if("pepperoni".equals(type)){
pizza = new PepperoniPizza(ingredientFactory);
pizza.setName("New York Style Pepperoni Pizza");
}
return pizza;
}
}
下图是上面的UML结构图。
其中PizzaIngredientFactory是抽象的披萨原料工厂接口,它定义了如何生产一个相关产品的家族。这个家族包含了所有制作披萨的原料。
NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory是两个具体披萨工厂类,他们负责生产相应的披萨原料。
NYPizzaStore是抽象工厂的客户端。
四、模式优缺点
优点
1、 抽象工厂隔离了具体类的生成,是的客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口,因此只需要改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。
2、 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。
缺点
添加新的行为时比较麻烦。如果需要添加一个新产品族对象时,需要更改接口及其下所有子类,这必然会带来很大的麻烦。
五、模式使用场景
1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是重要的。
2.系统中有多于一个的产品族,而每次只使用其中某一产品族。
3. 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。
4. 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。
六、总结
1、 抽象工厂模式中主要的优点在于具体类的隔离,是的客户端不需要知道什么被创建了。其缺点在于增加新的等级产品结构比较复杂,需要修改接口及其所有子类。
分享到:
相关推荐
《C++20设计模式》学习笔记-第3章工厂方法和抽象工厂模式学习代码
共150讲,时长共 33...1) 内容包括: 设计模式七大原则(单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特法则、合成复用)、UML类图(类的依赖、泛化和实现、类的关联、聚合和组合) 23种设计模式包括...
1. 创建型模式:创建型模式关注对象的创建过程,包括简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式和单例模式。这些模式可以帮助我们更灵活地创建对象,避免直接使用new关键字来创建对象,降低...
3.设计模式Design Pattern:创建型模式(厂模式Factory、抽象工厂模式Abstract Factory、单例模式Singleton、建造者模式Builder、原型模式Prototype和对象池模式Object Pool Pattern)、结构型模式(适配器模式、...
来自《Head Fist 设计模式》一书的实例,个人学习笔记用途
主要介绍了Java设计模式笔记之抽象工厂代码示例,见解独到,代码详细,具有一定参考价值,需要的朋友可以了解下。
定义: 结构说明: 相关概念: 接口: 接口与抽象类的区别: 面向接口编程: 功能: 时序图: 优缺点: 代码阐释:
设计模式(Design Pattern)是前辈们对代码开发经验的总结,是解决特定问题的一系列套路。它不是语法规定,而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。工厂模式、抽象工厂模式、...
{2.9}抽象与接口}{59}{section.2.9} {2.10}访问控制}{60}{section.2.10} {2.10.1}类的属性}{60}{subsection.2.10.1} {2.10.2}类的方法}{61}{subsection.2.10.2} {2.10.3}静态代码块}{62}{subsection.2.10.3} {...
设计模式学习笔记,此项目参考《大话设计模式》,只能作为入门级设计模式学习 设计原则 职责单一原则 开放-封闭原则 依赖倒转原则 高层模块不依赖底层模块,两个模块都应该依赖抽象。抽象不依赖细节,细节依赖抽象。...
抽象工厂模式(Abstract Factory Pattern) 单例模式(Singleton Pattern) 建造者模式(Builder Pattern) 原型模式(Prototype Pattern) 结构型模式 适配器模式(Adapter Pattern) 桥接模式(Bridge Pattern) ...
3 模式结构图 4 UML类图 5 代码 6运行结果 实验三 抽象工厂模式的应用 1 实验目的 1) 掌握抽象工厂模式(Abstract Factory)的特点 2) 分析具体问题,使用抽象工厂模式进行设计。 2 实验内容和要求 麦当劳...
泛型技巧系列:用泛型打造可复用的抽象工厂 体验.net2.0的优雅(四):Provider、策略、控制反转和依赖注入 泛型最佳实践 asp.net 2.0下嵌套masterpage页的可视化编辑 C# 2.0与泛型 动态调用对象的属性和方法——...
:hot_beverage: 用Java实现的设计模式〜 ... :check_mark:抽象工厂模式( Abstract Factroy Pattern ) :memo: , :check_mark:建造者模式( Builder Pattern ) :memo: , :check_mark:单例模式( S
describe:设计模式学习笔记 逻辑结构图 代码结构图 设计模式简述 创建型模式,共五种:工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式。 结构型模式,共七种:适配器模式,装饰器模式,代理模式,...
酒店管理客房系统Java源码 创建型模式:关注对象的创建过程 :保证一个类只有一个实例,并且提供一个访问该实例的全局访问点 ...抽象工厂模式是工厂模式的一种升级版本。 :分离了对象子组件的单独构造(由Builder来负
第一部分:设计模式 & UML 简单工厂 工厂方法模式 抽象工厂模式 策略模式 责任链模式 命令模式 模板方法模式 适配器模式 代理模式 外观模式 组合模式 装饰模式 享元模式 桥接模式 Builder模式 状态模式 解释器模式 ...
工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式) 笔记内容:https://blog.csdn.net/weixin_46168350/article/details/110285717
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式,共十一种:...
抽象工厂模式 状态模式 解释器模式 命令模式 备忘录模式 迭代器模式 模板方法模式 访问者模式 中介者模式 组合模式 装饰模式 享元模式 桥接模式 ##第二部分 ##第三部分 链表 字符串 树 图 查找 《剑指Offer》 ...